Discussion :

[donkeyquote]

Bonjour !

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

Code :

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

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 !

[Davidbrcz]

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.

[Mat007]

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 :

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

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.

[Davidbrcz]

ou alors utilisé boost::noncopyable

[poukill]

Oui, plus clair et moins encombrant !

[Floréal]

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 :

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

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

[Mat007]

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 :

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

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 :

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

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.

[poukill]

Question : pourquoi le namespace anonyme dans ton exemple ?

[donkeyquote]

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

[Mat007]

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

Excusez-moi, pouvez vous illustrer dans quels cas il peut se générer une copie d'une instance d'une 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
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.