Erreur: Impossible d'instancier une classe abstraite
Bonsoir,
J'ai un petit soucis dans mon programme C++...
J'ai créer une classe abstraite, et une autre classe qui a hérité de la première.
J'ai bien redéfini les méthodes qui étaient virtuelle pur de la classe maitre, dans les classes filles.
Mais quand j'essaye d'utiliser cette classe, Visual me dit ceci:
'InputSignal_Step'*: impossible d'instancier une classe abstraite
J'ai essayer de bien relire mon cours, certain bouquin, mais je ne comprend d'ou vient l'erreur...
Classe maitresse (Header):
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
| #ifndef INPUTSIGNAL_H
#define INPUTSIGNAL_H
#include "stdafx.h"
#include <iostream>
class InputSignal
{
public: //________________________________________________________
// CONSTRUCTOR
InputSignal();
InputSignal(unsigned int, unsigned int);
InputSignal(const InputSignal&);
virtual ~InputSignal();
// OPERATOR
virtual float& operator [] (unsigned int);
// GET/SET
virtual unsigned int get_lenght() const;
virtual void set_lenght(unsigned int) =0;
virtual int get_tech() const;
virtual void set_tech(int) =0;
virtual float get_insignal_value(unsigned int) const;
virtual void set_insignal_value(unsigned int, float);
virtual float* get_insignal() const;
//virtual void set_insignal(const InputSignal&);
// METHOD
virtual void build_insignal() =0;
protected: //_____________________________________________________
unsigned int lenght; //en nombre d'échantillon
unsigned int tech; //en ms
float* insignal; //tableau qui contient le signal d'entrée
private: //_______________________________________________________
};
#endif |
Classe maitresse (CPP):
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
| #include "stdafx.h"
#include "InputSignal.h"
//### PUBLIC ####################################################################
//###############################################################################
//_______________________________________________________________________________
// CONSTRUCTOR
InputSignal::InputSignal():
lenght(1), tech(1)
{
float* buffer = new float[lenght];
for(unsigned int i=0; i<lenght;i++)
{
buffer[i] = 0;
}
insignal = buffer;
}
InputSignal::InputSignal(unsigned int new_lenght,unsigned int new_tech):
lenght(new_lenght), tech(new_tech)
{
float* buffer = new float[lenght];
for(unsigned int i=0; i<lenght;i++)
{
buffer[i] = 0;
}
insignal = buffer;
}
InputSignal::InputSignal(const InputSignal& InputCopy):
lenght(InputCopy.get_lenght()), tech(InputCopy.get_tech())
{
float* buffer = new float[lenght];
for(unsigned int i=0; i<lenght;i++)
{
try
{
buffer[i] = InputCopy.get_insignal_value(i);
}
catch(const std::out_of_range& e)
{
std::cout << std::endl << "e";
}
}
insignal = buffer;
}
InputSignal::~InputSignal()
{
if (insignal != NULL)
delete [] insignal;
}
//_______________________________________________________________________________
// OPERATOR
float& InputSignal::operator[] (unsigned int index)
{
return insignal[index];
}
//_______________________________________________________________________________
// GET/SET
unsigned int InputSignal::get_lenght() const
{
return lenght;
}
int InputSignal::get_tech() const
{
return tech;
}
float InputSignal::get_insignal_value(unsigned int index) const
{
if(index < lenght){
return insignal[index];
} else {
throw std::out_of_range("Out of range for InputSignal table");
}
}
void InputSignal::set_insignal_value(unsigned int index, float new_value)
{
if(index < lenght){
insignal[index] = new_value;
} else {
throw std::out_of_range("Out of range for InputSignal table");
}
}
float* InputSignal::get_insignal() const
{
return insignal;
}
//### PROTECTED #################################################################
//###############################################################################
//### PRIVATE ###################################################################
//############################################################################### |
Classe fille (Header):
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
| #ifndef INPUTSIGNALSTEP_H
#define INPUTSIGNALSTEP_H
#include "stdafx.h"
#include "InputSignal.h"
#include <iostream>
class InputSignal_Step: public InputSignal
{
public: //________________________________________________________
// CONSTRUCTOR
InputSignal_Step();
InputSignal_Step(float);
InputSignal_Step(const InputSignal_Step&);
virtual ~InputSignal_Step();
// GET/SET
virtual void set_lenght(unsigned int); //Fonction virtuelle
virtual void set_tech(unsigned int); //Fonction virtuelle
virtual float get_amp() const;
virtual void set_amp(float);
// METHOD
virtual void build_insignal(); //Fonction virtuelle
protected: //_____________________________________________________
private: //_______________________________________________________
float amp;
};
#endif INPUTSIGNALSTEP_H |
Classe fille (CPP):
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
| #include "stdafx.h"
#include "InputSignal_Step.h"
//### PUBLIC ####################################################################
//###############################################################################
//_______________________________________________________________________________
// CONSTRUCTOR
InputSignal_Step::InputSignal_Step()
{
build_insignal();
}
InputSignal_Step::InputSignal_Step(float new_amp):
amp(new_amp)
{
build_insignal();
}
InputSignal_Step::InputSignal_Step(const InputSignal_Step& InputCopy):
amp(InputCopy.get_amp())
{
build_insignal();
}
InputSignal_Step::~InputSignal_Step()
{}
//_______________________________________________________________________________
// GET/SET
void InputSignal_Step::set_lenght(unsigned int new_lenght)
{
lenght = new_lenght;
build_insignal();
}
void InputSignal_Step::set_tech(unsigned int new_tech)
{
tech = new_tech;
build_insignal();
}
float InputSignal_Step::get_amp() const
{
return amp;
}
void InputSignal_Step::set_amp(float new_amp)
{
amp = new_amp;
build_insignal();
}
//_______________________________________________________________________________
// METHOD
void InputSignal_Step::build_insignal()
{
for(unsigned int i=0; i<lenght;i++)
{
try {
set_insignal_value(i,amp);
} catch(const std::out_of_range& e) {
std::cout << std::endl << "e";
}
}
}
//### PROTECTED #################################################################
//###############################################################################
//### PRIVATE ###################################################################
//############################################################################### |
