Implémentation d'une méthode virtuelle pure par la classe dérivée

Version imprimable

10/01/2013, 12h50
LinuxUser

Implémentation d'une méthode virtuelle pure par la classe dérivée
Bonjour,

Je cherche à implémenter une méthode virtuelle pure héritée (dans la classe dérivée).
Je pensais avoir bien fait les choses et pourtant, j'ai une erreur à la compulation qui m'indique que je dois implémenter la méthode pure héritée (ce que j'ai pourtant fait), voici le topo :
Code:

1 2 3 4 5 class Abstract { ... virtual double function() const=0; };
Code:

1 2 3 4 5 class Derived : public Abstract { ... virtual double function() const; };
Code:

1 2 3 4 5 6 #include "Derived.h" ... double Derived::function() const { // implementation }
L'erreur survient lorsque j'instancie une classe dérivée
Code:

1 2 m_derived = Derived(); // ERROR : must implement inherited pure virtual fucntion Abstract::function()
Je comprends pas ce que j'ai fait de travers.

EDIT: je précise que la classe Abstract a d'autres fonctions virtuelles simples, mais l'erreur concerne uniquement la virtuelle pure.

EDIT : correction dans Derived.cpp : double Derived::function() const et non double function() const
Merci de votre aide.
10/01/2013, 12h56
Ehonn

Dans ton .cpp

Code:

double function() const { }

doit être

Code:

double Derived::function() const { }

(?)
10/01/2013, 12h57
Bousk
Bonjour,

dans un .cpp l'implémentation d'une fonction membre c'est
Code:

1 2 3 TypeReturn MyClass::MyMethod(args) [const] { }
10/01/2013, 13h04
LinuxUser

Oui merci j'ai corrigé dans l'exemple, c'était juste un oubli dans l'exemple (dans mon code c'était déjà bon).
10/01/2013, 13h11
Bousk

Le code que tu présentes est bon.
As-tu une surcharge de la méthode non const ?
10/01/2013, 13h14
LinuxUser
Non, la fonction est implémentée une seule fois comme indiqué au-dessus.

EDIT: je suis sous Eclipse, et l'erreur apparait immédiatement dès que je déclare la classe dérivée comme varible membre d'une autre classe:
Code:

1 2 3 4 5 6 class DerivedUser { ... Derived m_derived; // ERROR : must implement inherited oure virtual function Abstract::function() };
10/01/2013, 15h26
LinuxUser
Apparement la solution est d'utiliser un pointer sur un objet de la classe dérivée:
Code:

1 2 3 4 5 class DerivedUser { ... Derived* m_derived; // là c'est bon };
J'ai vu ça sur Stack Overflow :
http://stackoverflow.com/questions/4...-abstract-type

Mais j'ai pas bien compris pourquoi.

EDIT : en fait nan ça marche pas, je peux juste déclarer un membre de type Derived*, mais il me dis toujours qu'il faiut implémenter la méthode virtuelle pure héritée.
10/01/2013, 15h32
r0d

Nan mais ton code est bon, le problème est ailleurs.
Ou alors tu as fait une faute de frappe (genre uns fois tu écris function, et une autre fonction, ou Fonction) ou un truc comme ça.
10/01/2013, 15h32
Bousk

Pourrait-on voir plus de code et du vrai code ? Includes compris ?
Parce que ce simple héritage avec la méthode virtual implémentée dans la classe dérivée est tout à fait correct.
10/01/2013, 15h34
[Hugo]

Je ne vois pas pourquoi le problème viendrait de là dans ton cas... Le cas que tu cites sur stackoverflow est différent : il essaye d'instancier un objet d'une classe abstraite pure. Les classes abstraites pures sont plutôt faites pour servir d'interface - pour ce que je comprends du C++ en tout cas - et certainement pas pour être instanciées.
Dans le cas de stackoverflow il essaye d'écrire :

Code:

ClassAbstraitePure MonObjet;

Ce qui demande l'instanciation d'une classe abstraite pure. Ce qu'il faut faire c'est :

Code:

ClassAbstraitePure* MonObjet;

Ce qui demande la création d'un pointeur vers la classe abstraite pure, qui pourra accueillir tout objet d'une classe dérivée de ClassAbstraitePure, qui elles seront bien instanciables.

Dans ton cas, tu crées bien un objet dérivé instanciable... du coup, pour moi, c'est un peu mystérieux..
10/01/2013, 15h57
white_tentacle

C’est la seule erreur que tu as ?

Parce que si le code de double Derived::function() const ne compile pas, tu peux te retrouver avec cette erreur en plus d’une précédente.

L’autre possibilité est que tu n’édites / compiles pas le bon fichier, car comme l’ont dit les autres, l’extrait que tu montres est correct.

OK.

Classe abstraite

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
#ifndef RHEOLOGY_H_
#define RHEOLOGY_H_
/**
 * @class Rheology Rheology.h
 * @brief This class defines features of rheology law
 */
class Rheology
{
public:
/******************************** CONSTRUCTOR *********************************/
	/**
         * @brief Default constructor.
         */
	Rheology();
/********************************* DESTRUCTOR *********************************/
	/**
         * @brief Default destructor.
         */
	virtual ~Rheology();
/*********************************** METHODS **********************************/
	virtual double sigmaCalc(double epsilon) const=0;
};
 
#endif /* RHEOLOGY_H_ */

Code:

1
2
3
4
5
6
7
8
9
#include "Rheology.h"
 
Rheology::Rheology()
{
}
 
Rheology::~Rheology()
{
}

Classe dérivée

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
#ifndef SMATCH_H_
#define SMATCH_H_
 
#include "Rheology.h"
/**
 * @class Smatch Smatch.h
 * @brief This class defines the Smatch law
 */
class Smatch: public Rheology
{
public:
/******************************** CONSTRUCTOR *********************************/
	/**
         * @brief Default constructor.
         */
	Smatch();
/********************************* DESTRUCTOR *********************************/
	/**
         * @brief Default destructor.
         */
	virtual ~Smatch();
/*********************************** METHODS **********************************/
	virtual double sigmaCalc(double epsilon, double offsetYieldStress) const;
};
 
#endif /* SMATCH_H_ */

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include "Smatch.h"
 
Smatch::Smatch()
{
}
 
 
Smatch::~Smatch()
{
}
 
double Smatch::sigmaCalc(double epsilon, double offsetYieldStress) const
{
	double sigma = 0.0;
 
	return (sigma);
}

Classe utilisant la classe dérivée

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
#ifndef MODELHANDLER_H_
#define MODELHANDLER_H_
 
#include "Smatch.h"
#include <math.h>
 
/**
 * @class ModelHandler ModelHandler.h
 * @brief This class provides an interface to use models
 */
class ModelHandler
{
public:
/******************************** CONSTRUCTOR *********************************/
	/**
         * @brief Default constructor.
         */
	ModelHandler();
/********************************* DESTRUCTOR *********************************/
	/**
         * @brief Default destructor.
         */
	virtual ~ModelHandler();
/*********************************** METHODS **********************************/
	/**
         * @brief Initialize rheology parameters of Smatch law
         * @pre
         */
	int initializeRheology(double& A, double& B, double& C, double& D);
private:
	Smatch m_rheologySmatch;
};
 
#endif /* MODELHANDLER_H_ */

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include "ModelHandler.h"
 
ModelHandler::ModelHandler() :
		m_rheologySmatch()
{
}
ModelHandler::~ModelHandler()
{
}
 
int ModelHandler::initializeRheology(double& A, double& B, double& C, double& D)
{
	m_rheologySmatch = Smatch(A, B, C, D);
 
	return (0);
}

Résultat à la compilation:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
In file included from ModelHandler.cpp:1:0:
ModelHandler.h:31:9: erreur: cannot declare field ‘ModelHandler::m_rheologySmatch’ to be of abstract type ‘Smatch’
In file included from ModelHandler.h:4:0,
                 from ModelHandler.cpp:1:
Smatch.h:9:7: note:   because the following virtual functions are pure within ‘Smatch’:
In file included from Smatch.h:4:0,
                 from ModelHandler.h:4,
                 from ModelHandler.cpp:1:
Rheology.h:21:17: note: 	virtual double Rheology::sigmaCalc(double) const
ModelHandler.cpp: In constructor ‘ModelHandler::ModelHandler()’:
ModelHandler.cpp:4:20: erreur: cannot allocate an object of abstract type ‘Smatch’
In file included from ModelHandler.h:4:0,
                 from ModelHandler.cpp:1:
Smatch.h:9:7: note:   since type ‘Smatch’ has pure virtual functions
ModelHandler.cpp: In member function ‘int ModelHandler::initializeRheology(double&, double&, double&, double&)’:
ModelHandler.cpp:13:38: erreur: cannot allocate an object of abstract type ‘Smatch’
In file included from ModelHandler.h:4:0,
                 from ModelHandler.cpp:1:
Smatch.h:9:7: note:   since type ‘Smatch’ has pure virtual functions

10/01/2013, 16h10
r0d

Ok: ta fonction dérivée n'a pas la même signature que celle de la classe de base.
10/01/2013, 16h19
LinuxUser

:arf: quel con.

Merci infiniment.