Classe purement abstraite

Bonjour !

J'ai un doute...
Pour faire une classe purement abstraite en C++ (genre "interface") est-ce que je pourrais la definir ...

Code:

---

1 2 3 4 5 6 7 8 9 10

class myClass { virtual method1(typeA param1,..paramN) =0; //..... virtual methodN(typeA param1,..paramN) =0;   //No attributes   }

---

Ou il faudrait forcement déclarer un constructeur (et l'implementer) et un destructeur virtuel ?

Merci !

Nan.
Des que ta classe possède une fonction virtuelle pure, c'est une interface.
Dans la plus part des cas,on prend comme habitude de définir en plus le destructeur de ta classe comme virtuel.

En effet, si celle ci est une interface, alors tu va (dans 99% des cas) manipuler des donnée référé par des pointeurs de type "Base".
De ce fait,quand tu va faire un delete sur ce pointeur, il faut que ton destructeur de Base soit virtuel pour que le bon destructeur soit appelé car sinon,bonjour les dégâts.

Salut,

A mon avis il peut aussi être pas mal de rendre non-copiable une telle classe pour éviter des boulettes (rares mais chères) :
Le problème est qu'alors il faut un constructeur par défaut, car le compilateur ne le génère pas, du coup on se retrouve avec :

Code:

---

1 2 3 4 5 6 7 8 9 10

class MyClass { public: MyClass() {} virtual ~MyClass() {} ... private: MyClass( const MyClass& ); MyClass& operator=( const MyClass& ); };

---

Pas très embêtant cela dit, en général les interfaces ont quand même peu de méthodes et ça n'encombre pas trop.
Et puis il suffit d'avoir des macros un peu évoluées pour créer ses classes, et ça met tout ça tout seul...

MAT.

ou alors utilisé boost::noncopyable

Oui, plus clair et moins encombrant ! :mrgreen:

Je profite de ce sujet pour éclaircir un point de vocabulaire.
Donkeyquote, tu parles d'interface. En C++ ce mot peut avoir plusieurs sens:
- Au sens "purement" C++, c'est la déclaration que tu mets dans ton .h, en général
- Au sens objet, c'est la définition d'un comportement que tu décris à dans les classes qui implémentent la-dite interface.
Je trouve qu'en C++ les termes "interface" et "implémentation" sont à double sens, et il faut voir si l'on parle d'un point de vue de la théorie objet, ou d'un point de vue langage.

Une petite illustration:
Inferface au sens Objet:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

//interface template<class T> class iComparable { public: virtual int compare(const T&) = 0; }   //implémentation class Vecteur2D : public iComparable<Vecteur2D>, public iComparable<Complexe> { //autres membres public: int compare(const Vecteur2D&); int compare(const Complexe&); }

---

Au sens C++:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

//interface class Vecteur2D : public iComparable<Vecteur2D>, public iComparable<Complexe> { //autres membres public: int compare(const Vecteur2D&); int compare(const Complexe&); }   //implémentation int Vecteur2D::compare(const Vecteur2D&) { //code }   int Vecteur2D::compare(const Complexe&) { //code }

---

Citation:

---

Envoyé par Davidbrcz

ou alors utiliser boost::noncopyable

---

Le problème de boost::noncopyable c'est qu'en cas d'erreur le message ne donne pas l'emplacement exact :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#include <boost/noncopyable.hpp>   namespace { class A : private boost::noncopyable { }; void f() { A a1, a2; a1 = a2; } }

---

Donne :

Code:

---

1 2 3 4

BoostNonCopyableTest.cpp(7) : error C2248: 'boost::noncopyable_::noncopyable::operator =' : cannot access private member declared in class 'boost::noncopyable_::noncopyable' boost/noncopyable.hpp(28) : see declaration of 'boost::noncopyable_::noncopyable::operator =' boost/noncopyable.hpp(22) : see declaration of 'boost::noncopyable_::noncopyable' This diagnostic occurred in the compiler generated function '`anonymous-namespace'::A &`anonymous-namespace'::A::operator =(const `anonymous-namespace'::A &)'

---

MAT.

Question : pourquoi le namespace anonyme dans ton exemple ?

Excusez-moi, pouvez vous illustrer dans quels cas il peut se générer une copie d'une instance d'une classe abstraite ? :roll:

Citation:

---

Envoyé par poukill

Question : pourquoi le namespace anonyme dans ton exemple ?

---

C'est un réflexe, je mets tout le temps des namespaces anonymes.
Mais c'est vrai que là, pour l'exemple, ça n'apporte rien....

Citation:

---

Envoyé par donkeyquote

Excusez-moi, pouvez vous illustrer dans quels cas il peut se générer une copie d'une instance d'une classe abstraite ?

---

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

class A { virtual void f() = 0; }; class B : public A { virtual void f() {} }; class C : public B { }; void test() { C c; B b( c ); }

---

J'admets que c'est un peu tiré par les cheveux, que c'est rare de tomber dans le panneau, et qu'à la limite c'est plus à B d'empêcher sa propre copie.
L'intérêt de le mettre sur A c'est qu'on est tranquille...

MAT.

Tout simplement (un peu moins tiré par les cheveux):

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

class A { virtual func() = 0; }   class B { virtual func(); }   class Toto { BadFunc(A t); }   main() { B b; Toto toto; toto.BadFunc(b); // <= une copie de "A" sera générée }

---

Sauf que ça ne passe pas:

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

class A { public: virtual void func(void) = 0; };   class B : public A { public: virtual void func(void); };   class Toto { public: void BadFunc(A t); //<--- La ligne 65 était ici };   int main(void) { B b; Toto toto; toto.BadFunc(b); // <= une copie de "A" sera générée return 0; }

---

Code:

---

tests.cpp(65) : error C2259: 'A' : cannot instantiate abstract class

---

Ben oui Médinoc... c'est justement pour montrer un exemple ou ca ne compile pas.... à cause d'un constructeur de recopie ....

Sauf que là, pas besoin de constructeur de copie privé pour que ça ne compile pas...

Exact, il faut passer par un pointeur, une classe abstraite n'est pas instanciable...