Discussion :

[LinuxUser]

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 :

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

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

Code :

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

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

Code :

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

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 :

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

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.

[Ehonn]

Dans ton .cpp

Code :

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

double function() const { }

doit être

Code :

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

double Derived::function() const { }

(?)

[Bousk]

Bonjour,

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

Code :

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

1
2
3
TypeReturn MyClass::MyMethod(args) [const]
{
}

[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).

[Bousk]

Le code que tu présentes est bon.
As-tu une surcharge de la méthode non const ?

[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 :

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

1
2
3
4
5
6
class DerivedUser
{
...
Derived m_derived;
// ERROR : must implement inherited oure virtual function Abstract::function()
};

[LinuxUser]

Apparement la solution est d'utiliser un pointer sur un objet de la classe dérivée:

Code :

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

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.

[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.

[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.

[[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 :

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

ClassAbstraitePure MonObjet;

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

Code :

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

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..

[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.

[LinuxUser]

OK.

Classe abstraite

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

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

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

Classe dérivée

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

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

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

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

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

[r0d]

Ok: ta fonction dérivée n'a pas la même signature que celle de la classe de base.

[LinuxUser]

quel con.

Merci infiniment.