Discussion :

[glindayzar]

Bonjour,

j'ai fais un générateur qui créent des fichiers .h et des .cpp, dans ces fichiers je fais un certain traitement pour les classes de ma librairie, et à un certain moment dans mon code généré il ya un "new Maclasse", pour les classes abstraites j'ai des erreurs de compils,
est ce que je peux detecter qu'une classe est abstraite pour adapter le code à générer dans ce cas.

j'espere que j'ai été clair et merci pour votre aide.

[r0d]

Peux-tu analyser ton .h pour savoir si la classe contient au moins une fonction virtuelle pure?

[Alp]

http://www.boost.org/doc/html/boost_...ts.is_abstract

[Mat.M]

http://www.boost.org/doc/html/boost_...ts.is_abstract

1-c'est en runtime intrinséquement qu'on va détecter si la classe est abstraite ou non.
Là c'est radicalement différent c'est de l'analyse de texte.

2-Et si je n'utilise pas boost ?

Comme le dit R0d il faut détecter la présence du mot clé "vitual"

[r0d]

En réalité c'est un peu plus compliqué que cela. Pour qu'une classe soit abstraite, et qu'elle ne puisse donc pas être instanciée, elle doit contenir au moins une fonction virtuelle pure. Il faut donc détecter le mot-clé virtual et le =0.

Mais bon, nous ne connaissons rien du contexte.

[glindayzar]

dans mon cas, je parse le .h de la classe donc avec qlq modifications je peux detecter la declaration d'une méthode virtuelle pure, j'ai aussi boost dans mon environnement je vais creuser un peu ces 2 pistes et je vous reviens, merci pour vos propositions

[Laurent Gomila]

1-c'est en runtime intrinséquement qu'on va détecter si la classe est abstraite ou non.
Là c'est radicalement différent c'est de l'analyse de texte.

C'est détecté à la compilation.

Pour qu'une classe soit abstraite, et qu'elle ne puisse donc pas être instanciée, elle doit contenir au moins une fonction virtuelle pure

Une classe ne possédant que des constructeurs protégés sera également abstraite, si on considère qu'une classe abstraite est une classe qui ne peut être instanciée.

[r0d]

Une classe ne possédant que des constructeurs protégés sera également abstraite, si on considère qu'une classe abstraite est une classe qui ne peut être instanciée.

Exact.
Il y a aussi le cas suivant:

Code c++ :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class A
{
public:
   virtual void f() = 0;
};
 
class B : A
{
};
 
class C : B
{
public:
   void f(){/*fait quelque chose*/}
};

Dans l'exemple ci-dessus, B est considérée comme abstraite car elle ne peut pas être instanciée (à cause de f() qui reste virtuelle pure au sein de B).

[glindayzar]

oui avec ces cas, et peut etre qu'il y en a d'autres par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
class A {
  virtual void f() =0;
  virtual void g() =0;
};
 
class B : public A{
  virtual void f() { /*traitement*/ }
};
 
class C : public B {
  virtual void f() { /*traitement*/ }
  virtual void g() { /*traitement*/ }
};

on peut pas faire un new B.

c'est complexe de detecter si on peux faire new B ou pas.
j'ai testé boost, j'ai pas la bonne version du compilateur.

qlq aurais t'il des idées ?

Merci.



balises [code] rajoutées par r0d. Merci d'y penser.

[Alp]

Mat.M : aucune des structures de Boost.Typetraits ne donne des informations qu'à l'exécution. Tout est fait pour donner des infos à la compilation.

C'est pourquoi je l'ai suggéré. De plus, ce n'est qu'un header, rien à lier. Il suffit d'avoir boost d'installé.

Est-ce que cela satisfait l'auteur ?

[Alp]

Comment ça tu n'as pas la bonne version ?
Boost est cross-compiler, pour peu que ton compilateur ne soit pas de l'âge de pierre. Quel est ton compilo ?

[Laurent Gomila]

is_abstract requiert qu'une certaine technique soit implémentée, ce qui n'est le cas qu'à partir de VC 7.1 ou gcc 3.3 si je me souviens bien.

[Alp]

Oui c'est sur qu'avec VC6 ça passera pas.
Mais bon, pour peu qu'il n'y ait pas une restriction trop sévère sur le compilo, il n'y a pas de problème.

[glindayzar]

ma version du compilo est CC 6.12, is_astract se comporte comme is_polymorphic qui est un comportement erroné dans mon cas.

[koala01]

Salut,

Pour ce qui concerne les classes abstraites parce que leur constructeur est protected, la seule solution, si tu ne peux utiliser boost, consiste à vérifier si les classes dérivées ont un constructeur publique et si elles appellent (par liste d'initialisation ) le constructeur de la classe de base.

Pour ce qui concerne les classes abstraites du fait de la présence de fonctions virtuelles pures, le plus logique serait, peut etre, de maintenir une liste des fonctions virtuelles pures rencontrées dans la classe de base.

Tu maintiendrais également une liste des fonctions déclarées dans la classe dérivée.

La vérification pourrait alors prendre une forme qui vérifierait que toutes les fonctions présentes dans la liste des fonctions virtuelles pure de la classe de base soient redéclarées dans la classe dérivée:

Si c'est le cas, la classe dérivée est instanciable, sinon, c'est elle meme une classe abstraite

Tu pourrais donc avoir une classe de lecture qui pourrait prendre à peu pres cette forme:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
class ClasseLue
{
    public:
        ClasseLue(/*...*/);
        ~ClasseLue();
        bool IsBase(); const /* permet de savoir si on a affaire à une classe
                              * de base */
        bool IsAbstract() const;/* pour les classes de bases */
        bool IsAbstract(const ClasseLue& base) const;/* pour les classes 
                                                      * dérivées */
        bool MethodExists(const string& proto) const /* vérifie si une fonction 
                                                      * est déclarée */
        const vector<string> AllVirtualPures() const;/* pour récupérer 
                                   * la liste des fonctions virtuelles pures */
        /* tout le reste */
    private:
        vector<CTors> ctors;/* liste des constructeurs */
        string dtors;/* le destructeurs */
        vector<Method> methods;/* liste des fonctions */
        vector<string> virtualpures; /* juste les prototypes des fonctions 
                                      * virtuelles pures */
        bool isbase;
        /* tout le reste */
};
bool ClasseLue::IsBase() const{return isbase;}
const vector<string> AllVirtualPures() const{return virtualpures;}
bool ClasseLue::IsAbstract() const 
{
    /* D'abord, vérifier si les constructeurs sont tous protected */
    bool areprotected=true;
    for(size_t i=0;i<ctors.size();i++)
        if(!ctors[i].IsProtected())
            areprotected=false;
    /* renvoyer vrai si tous les constructeurs sont protected ou si on a au
     * minimum une fonction virtuelle pure */
    return areprotected | virtualpurs.size()>0;
}
bool ClasseLue::IsAbstract(const ClasseLue& base) const
{
    /* une idée parmis tant d'autres */
    vector<string> virutalbase=base.AllVirtualPures();
    size_t basecount=virtualbase.size();
    /* Pour chacune des classes virtuelles pures redéfinies dans
     * la classe dérivées, on décréemente le compteur
     */
    for(size_t i=0;i<virtualbase.size();i++)
        if(MethodExists(virtualbase[i])
            --basecount;
    /* Renvoie vrai si la classe dérivée est elle-meme abstraite ou si il reste
     * ne serait-ce qu'une seule fonction virtuelle pure non redéclarée */
    return basecount>0 | IsAbstract();
}

Nota:

Certaines informations sont peut etre manquantes:

• IsProtected() serait une méthode permettant de déterminer si une fonction membre a une visibilité "protected"
• Il reste de ta responsabilité, lorsque tu rajoute une méthode, de vérifier si elle est virtuelle pure, et, si c'est le cas, d'en rajouter son prototype dans le vector "virtualpures"
• Pour chaque fonction membre, il serait utile de pouvoir en récupérer le prototype, et de s'en servir pour chercher si une fonction est déclarée dans MethodExists
• Je n'ai pas pris en compte les héritages multiples

[Mat.M]

C'est détecté à la compilation.

Je suis bien d'accord mais c'est lui qui fait l'interprétation du fichier ( du moins écrire le code pour ) pas le compilateur ou je n'ai rien pigé

[Laurent Gomila]

Honêtement je ne sais pas du tout comment il s'y prend (est-ce qu'il l'a clairement expliqué ?), mais je pense que tu as raison. C'était juste pour te corriger que j'ai fait cette petite remarque

[glindayzar]

je pense que la reponse de koala01 est la solution pour mon probleme il faudrait maintenir une table des symboles et s'assurer de la définition des symboles de la classe abstraite dans les classes dérivés pour dire si il sont abstraites elle aussi,
mais j'ai pas beaucoup de temps pour creuser ça donc je vais pas traiter ce problème, je déclare un #define ABSTRACT et j'ajoute ce mot dans mes déclarations de classe : class ABSTRACT A { /**/ }; ca ne change pratiquement rien au code de mon application mais je peux facilement detecter que ma classe est abstraite avec mon parseur.

merci pour vos réponses.

[koala01]

Mais comment parse tu ton fichier

Car, finalement, tu obtiens toutes les réponses qu'il te faut :

• au début de la classe, avant tout mot clé de visibilité (private, protected ou public), les déclarations qui suivent sont private
• les mots clés private/protected/public s'appliquent jusqu'à ce qu'un autre mot clé de la meme famille apparaisse
• le constructeur est la seule fonction dont le nom soit... celui de la classe
• une fonction est virtuelle pure si elle est précédée du mot clé virtual et si sa liste de paramètres est suivie de =0 avant le ;

Au pire, rien ne t'empeche de garder simplement, dans ta classe qui parse le fichier, un booleen hasprotectedconstructors, et tu pourrais tres bien avoir maintenir la liste des fonctions virtuelles pures sous une forme utilisant une std::map<std::string, std::vector<string> > statique, ainsi qu'un tableau statique de chaines:

La clé serait le nom de la classe, les valeurs (ici un vecteur de chaines ) seraient le nom des fonctions virtuelles pures

Le tableau de chaines statique servirait pour sa part à garder les noms des fonctions déclarées pour chaque classe lues: à chaque fois que tu rencontre le mot cle class dans le code, tu le vide, puis tu rajoutes les fonctions au fur et à mesure de leurs déclarations.

Quand vient le moment de vérifier si une classe est abstraite, tu n'aurais plus quà récupérer pour chaque héritage le tableau des fonctions virtuelles pures et à le comparer avec le tableau des fonctions déclarées: si une seule fonction apparaît dans le tableau des fonctions virtuelles pures et n'apparaît pas dans le tableau des fonctions déclarée OU si le membre hasprotectedconstructors est à true, c'est que ta classe est abstraite

[glindayzar]

salut,
pour parser mon fichier j'ai implémenté un automate d'analyse syntaxique selon la grammaire définis par mes besoins,.

koala01 je suis tous à fait d'accord avec toi et je pense que ta solution resout mon problème, pour son implémention elle est assez simple dans mon cas puisque je contrôle parfaitement mon automate d'analyse et qu'il suffira d'ajouter des états pour detecter les cas cités.

pour l'instant je laisse ca comme évol de mon projet et je vais la dévelloper dés que j'ai un peu de temps.
Merci,