Erreur: Impossible d'instancier une classe abstraite

**petitnul12** · 16/11/2012, 23h21

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ###################################################################
//###############################################################################

**djuju** · 16/11/2012, 23h33

Salut,

set_tech n'est pas défini de la même façon dans les 2 classes.

Mère :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

virtual void set_tech(int) =0;

Fille:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

virtual void set_tech(unsigned int);

En passant, si personne n'hérite de "Fille", pas besoin de déclarer tes fonctions virtuelles. C'est même recommandé de ne pas le faire, puisque ça évite de résoudre la portée des fonctions dans la table des fonctions virtuelles.

**petitnul12** · 16/11/2012, 23h39

Ooooooh !
J'ai relu plusieurs fois mes trucs, mais je suis passé à coté d'une erreur aussi futile et je me suis pris la tête sur le reste =)

Bien le merci !

Erreur: Impossible d'instancier une classe abstraite

C++

Discussions similaires

Partager

Partager