Discussion :

[ZaaN]

salut,

comment rendre une class abstraite si elle ne contient pas de methode ?

Je veux qu elle ne soit pas instanciable, c'est tout.

-proteger les constructeur/desctructeur serais-ce une bonne idée ?

[zotson]

Oui, déclarer les constructeur/destrcuteur private serait une solution

Ta classe contient des données membres private/protected ? Sinon tu peux utiliser une structure plutot

[koala01]

Salut,

Si tu veux juste que ta classe ne soit pas instanciable, il suffit de rendre le constructeur protected... Car les classes qui en dérivent doivent pourvoir y accéder

Et tu peux tres bien y placer des fonctions virtuelles qui ne soient pas des fonctions virtuelles pures...

Voir, meme, déclarer des fonctions virtuelles pures, et pourtant les instancier

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
 
// on ne veut permettre d'instancier Base
class Base
{
    public:
       virtual ~Base(){}
       virtual int GetA(){return a;}
       virtual int GetB(){return b;}
   protected:
       Base(int a, int b):a(a),b(b){}
    private:
       int a;
       int b;
};
class Derivee:public Base
{
    public:
       Derivee(int a, int b, int c):Base(a,b),c(c){}
       virtual ~Derivee(){}
       int GetC(){return c;}
    private:
       int c;
};
class Deriv2:public Base
{
    public:
        Deriv2(const std::string& c,int a, int b):Base(a, b),c(c){}
        virtual ~Deriv2(){}
        const std::string GetC(){return c;}
    private:
        std::string c;
};

à l'utilisation:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
//  Base b(1,2); erreur: Base n'est pas instanciable
    Derivee d1(1,2,3);//ok
    Deriv2  d2("Salut",1,2);//ok
    Base &b1=d1; //ok constructeur par copie et opérateur d'affectation ajoutés par défaut en public par le compilo
    Base &b2=d2;//ok constructeur par copie et opérateur d'affectation ajoutés par défaut en public par le compilo
    std::cout<<b1.GetA();//ok... GetA() existe dans Base
    std::cout<<b2.GetB();//ok (idem)
//  std::cout<<b1.GetC(); erreur... GetC() n'est pas déclaré dans Base
//  Deriv2 dcaste=dynamic_cast<Deriv2&>(b1); Echouera:b1 n'est pas castable en Deriv2
    Derivee essai=dynamic_cast<Derivee&>(b1);//ok, c'est la bonne dérivée
    std::cout<<essai.GetC();

[Fiquet]

Une autre solution est de déclarer son constructeur virtuel pur tout simplement

EDIT : je voulais dire destructeur

[koala01]

Une autre solution est de déclarer son constructeur virtuel pur tout simplement

Ah, non... en C++, un constructeur ne peut pas etre déclaré virtuel... du moins dans les versions actuellement utilisées de la norme
[EDIT]Par contre, la déclaration du destructeur d'une classe comme étant vitruel pur (et en ayant une implémantation) peut faire l'affaire:

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
class Base
{
    public:
       Base(int a, int b):a(a),b(b){}
       virtual ~Base()=0;//la déclaration d'une méthode virtuelle pure suffit à rendre la classe non instanciable
       virtual int GetA(){return a;}
       virtual int GetB(){return b;}
   protected:
 
    private:
       int a;
       int b;
};
/* il nous faut cependant le destructeur de la classe de base car il est appelé
 * par les destructeurs des classes dérivées
 */
Base::~Base(){}

En tout cas, avec mingw, cela fontionne

[Jean-Marc.Bourguet]

Une autre solution est de déclarer son constructeur virtuel pur tout simplement

Constructeur virtuel pur

[Laurent Gomila]

Pour résumer, au choix :

- Le destructeur virtuel pur (pas supporté par tous les compilos -- je me souviens de problèmes avec un compilo Borland).

- Le(s) constructeur(s) protégés.

[Fiquet]

Euh je voulais dire destructeur bien sûr , c'est modifié