Discussion :

[lodacom]

Comme il est conseillé dans la FAQ de développez, j'ai déclaré mes .h et mes .cpp dans un seul fichier (ce qui m'a permis de résoudre pas mal de problèmes ). Mais maintenant il me reste un problème que je n'arrive pas à résoudre. C'est le passage d'un objet générique en paramètre d'une de mes fonctions (je le fait dans plusieurs de mes fonctions).
Voici ce que je fait:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
template <class G,class S,class A>
GenericAretes<G,S,A>::GenericAretes(G* p_arete_dans,S* p_somm1,S* p_somm2){
    num++;
	stringstream s;
    s << "A" << num;
	nom_arete=s.str();
    arete_dans=p_arete_dans;
	somm1=p_somm1;
	somm2=p_somm2;
    somm1->setSommet_dans(p_arete_dans);
    somm2->setSommet_dans(p_arete_dans);
    somm1->addArete(this);//erreur de compile ici
}

Je n'obtiens pas d'erreur de syntaxe, par contre ça plante quand je compile:

Code :

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

1
2
 
GenericAretes.h:55:21: Cannot initialize a parameter of type 'GenericLiens *' with an rvalue of type 'GenericAretes<GenericReseaux, GenericNoeuds, GenericLiens> *'

(GenericLiens hérite de GenericAretes et concrétise cette dernière).
J'ai essayé de trouver des réponses (passer par des cast et tout rien à faire) un peu partout mais impossible les rapprocher de mon problème.
Voici ma fonction addArete:

Code :

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

1
2
3
4
5
 
template <class G,class S,class A>
void GenericSommets<G,S,A>::addArete(A* p_arete){
	aret_incidents.push_back(p_arete);
}

et "aret_incidents est un vector déclaré ainsi:

Code :

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

1
2
 
vector<A*> aret_incidents;

Informations supplémentaires: je compile avec l'IDE XCode (qui prend en charge la dernière version du compilateur g++) de MAC OS X.
Voilà si vous pourriez m'aider ça serait vraiment super. Merci d'avance.

[Flob90]

Il n'y a pas grand chose à faire, l'erreur est une erreur de conception. Ton objet this est de type GenericAretes<GenericReseaux, GenericNoeuds, GenericLiens>* pourquoi une fonction qui attend un GenericLiens* l'accepterait ? Un objet de type GenericAretes<GenericReseaux, GenericNoeuds, GenericLiens> n'est pas un objet de type GenericLiens, c'est l'inverse (grâce à ton héritage).

[koala01]

Salut,

Le monsieur te dit qu'il ne sait pas comment convertir un pointeur sur un objet de type GenericAretes<A, B, C> en un pointeur vers un objet de type GenericLiens.

Cela semble logique lorsque l'on sait que GenericLiens hérite de GenericArretes car la substituabilité permet de faire passer un (pointeur vers un) objet du type dérivé pour un (pointeurs vers un) objet du type de base.

Par contre, il est tout à fait impossible d'utiliser la substituabilité pour récupérer un (pointeur sur un ) objet du type dérivé au départ d'un (pointeur sur un) objet du type de base et ce pour plusieurs raisons:

Si le type dérivé connait le type de base, le type de base n'a par contre aucune connaissance du type dérivé, et n'a normalement pas à en avoir.

Il peut y avoir plusieurs types dérivés d'un seul et même type de base, or, on connait l'objet pointé comme étant du type de base... Pour pouvoir récupérer le type réel de l'objet, il faudrait... qu'on ait la certitude d'essayer de récupérer le bon type réel, et cette certitude ne peut être acquise que si tu dis explicitement au compilateur de convertir ton type de base en type dérivé (static_cast ou dynamic_cast).

Mais attention, à ce moment là, tu as vraiment intérêt à... etre sur de ton coup car si tu essaye de convertir ton objet "passant pour être" de type A en un objet de type B alors que c'est en réalité un objet de type C, tu coures à la catastrophe

Tout cela pour dire que tu as, en gros, deux (allez, trois) solutions:

Soit tu change le type du pointeur que tu essayes d'initialiser pour qu'il corresponde au type de base.

Soit tu force le transtypage du pointeur obtenu en argument en un pointeur du type dérivé (static_ ou dynamic_ cast)

Soit enfin tu crées une indirection supplémentaire qui te permettra d'utiliser le double dispatch afin d'être sur du type réel de l'objet pointé.

[lodacom]

Bonjour,
Merci de vos réponses si rapides. Pour répondre à koala01, la première solution a priori ne me convient pas puisque mon paramètre de "addArete" est sensé rester générique. Et d'ailleurs, c'est qui n'est pas très logique, un paramètre qui est générique est sensé accepté tous les types des classes qui dérivent "GenericAretes" là j'avoue je ne comprend pas très bien .
Pour ce qui est de la deuxième solution, comme tu le dit si bien:

Mais attention, à ce moment là, tu as vraiment intérêt à... être sur de ton coup car si tu essaye de convertir ton objet "passant pour être" de type A en un objet de type B alors que c'est en réalité un objet de type C, tu coures à la catastrophe

Et malheureusement je vais avoir une autre classe (qui va s'appeler GenericLiaisons et qui va elle aussi hériter de GenericAretes). Donc si j'ai bien compris cette deuxième solution est à écarter.
En ce qui concerne la troisième solution, j'avoue sincèrement que je ne l'ai pas comprise et surtout que je ne sais pas le faire.

indirection supplémentaire qui te permettra d'utiliser le double dispatch

Si vous avez besoin de plus de codes ou indices qui pourraient me guider n'hésiter pas à me le demander.
Encore merci à vous pour vos réponses rapides.

[koala01]

Et malheureusement je vais avoir une autre classe (qui va s'appeler GenericLiaisons et qui va elle aussi hériter de GenericAretes). Donc si j'ai bien compris cette deuxième solution est à écarter.

A moins d'utiliser le dynamic_cast et de prendre soin de vérifier que son résultat n'est pas null...

Mais, de manière générale, c'est aussi "à éviter" (d'autant plus que les template s'accordent globalement assez mal avec la déclaration des fonctions virtuelles qui est nécessaire pour profiter du dynamic_cast )

En ce qui concerne la troisième solution, j'avoue sincèrement que je ne l'ai pas comprise et surtout que je ne sais pas le faire.

L'idée est de rajouter une classe ou une fonction qui permette de prendre en charge une partie spécifique de ton problème (c'est cela que l'on appelle une "indirection supplémentaire).

au début, j'avais sans doute pensé plus à quelque chose proche du principe du visiteur qu'autre chose.

Mais, à la réflexion, je me dis que l'idéal serait sans doute plutot de se baser sur un principe proche du patron de conception "décorateur".

Tu aurais une classe permettant de récupérer un pointeur sur le type dérivé et qui te servirait pour ton argument

[lodacom]

Alors voilà, j'ai fait d'après ce que j'avais compris

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
 
template <class G,class S,class A>
GenericAretes<G,S,A>::GenericAretes(G* p_arete_dans,S* p_somm1,S* p_somm2){
    num++;
	stringstream s;
    s << "A" << num;
	nom_arete=s.str();
    arete_dans=p_arete_dans;
	somm1=p_somm1;
	somm2=p_somm2;
    somm1->setSommet_dans(p_arete_dans);
    somm2->setSommet_dans(p_arete_dans);
    IndirectionGeneric* ig=new IndirectionGeneric();
    somm1->addArete(ig->conversion(*this));
}
//nouveau code

J'ai créé comme tu me l'a conseillé une classe qui récupère le pointeur de la classe dérivé et j'ai fait une fonction conversion mais ça ne lui plaît pas du tout.

Code :

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

1
2
3
4
5
6
7
8
9
 
//indirectiondeneric.h
class IndirectionGeneric{
public:
    GenericAretes<GenericReseaux,GenericNoeuds,GenericLiens>* recup;
 
    IndirectionGeneric();
    GenericAretes<GenericReseaux,GenericNoeuds,GenericLiens>* conversion(GenericAretes<GenericReseaux,GenericNoeuds,GenericLiens>*);
};

Code :

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

1
2
3
4
5
6
7
8
 
//indirectiongeneric.cpp
IndirectionGeneric::IndirectionGeneric(){}
 
GenericAretes<GenericReseaux,GenericNoeuds,GenericLiens>* IndirectionGeneric::conversion(GenericAretes<GenericReseaux, GenericNoeuds, GenericLiens>* p_truc){
    recup=p_truc;
    return recup;
}

Il me dit que ma conversion n'est pas viable (ce qui peut se comprendre puisque dès que je rajouterai une classe je devrai surcharger ma fonction de conversion. Et aussi dès que j'enlève le "*" avant le this je reviens à mon erreur précédente..
Voici l'erreur exacte:

Code :

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

1
2
 
GenericAretes.h:58:36: No viable conversion from 'GenericAretes<GenericReseaux, GenericNoeuds, GenericLiens>' to 'GenericAretes<GenericReseaux, GenericNoeuds, GenericLiens> *'

Enlever tous les pointeurs ne serait-il pas une solution (en plus)? J'ai l'impression que je suis proche de la solution.
Merci encore pour votre aide rapide.

[koala01]

A vrai dire, je pensais en réalité à une classe proche de quelque chose comme

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
template <typename Base, typename Derived>
class Decorator : public Base{
    public:
       /* j'adore les typedefs :D */
       typedef Derived derived_type;
       derived_type * realType(){return real_;}
    protected:
       Decorator(derived_type * real )=real_(real){}
       ~Decorator(){}
    private:
        derived_type * real_;
};

qui serait utilisée (pour ta classe GenericLiens, si j'ai bien compris ) sous une forme proche de

Code :

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

1
2
3
4
5
6
template <typename A, typename B, typename C>
class GenericLiens : public Decorator<GenericAretes<A, B, C>, GenericLiens>{
    public:
        GenericLiens(/*...*/):Decorator<GenericAretes<A, B, C>, GenericLiens>(this){}
    /* ... */
};

et dont tu te servirais dans ta classe GenericAretes sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
template <class G,class S,class A> // G = Decorator<Base,Derived> :D
GenericAretes {
    public:
        typedef typename G::derived_type real_data_type;
        GenericAretes(G* p_arete_dans,S* p_somm1,S* p_somm2){
            arete_dans = p_arete_dans->realType();
        } 
    private:
        real_data_type * arete_dans;
};

Bon, ce code n'est absolument pas testé, mais l'idée de base est de cet ordre

[lodacom]

Bonjour,
Alors j'ai suivi les conseils que vous m'avez donné. Cela m'a permis de résoudre deux erreurs. Mais ce qui est très bizarre, c'est des lignes équivalentes qui sont marquées (après compilation) comme sans erreur, sont marquées comme avec erreur dans d'autres fonctions. Alors que c'est exactement la même instruction. Voici un exemple (voir commentaire):

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
 
template <class G,class S,class A>
void GenericGraphes<G, S, A>::addArete(A* p_arete){
	if (p_arete->getArete_dans()==NULL){
		p_arete->setArete_dans(this);//pas d'erreur après compilé
	}
    if (!isAlreadyAdded(p_arete)){
        aretes.push_back(p_arete);
        if (!isAlreadyAdded(p_arete->somm1)){
            sommets.push_back(p_arete->somm1);
        }
        if (!isAlreadyAdded(p_arete->somm2)){
            sommets.push_back(p_arete->somm2);
        }
    }
}

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
 
template <class G,class S,class A>
void GenericGraphes<G, S, A>::addArete(A* p_arete,S* p_somm1,S* p_somm2){
	if (p_arete->getArete_dans()==NULL){
        p_arete->setArete_dans(this);//erreur après compil
    }
    p_somm1->setSommet_dans(this);//erreur après compil
	p_somm2->setSommet_dans(this);//erreur après compil
	p_somm1->addArete(p_arete);
	p_somm2->addArete(p_arete);
    p_arete->setSommets(p_somm1, p_somm2);
    //on ajoute l'arête dans le graphe
    aretes.push_back(p_arete);
    //on ajoute les sommets dans le graphe
    if (!isAlreadyAdded(p_arete->somm1)){
        sommets.push_back(p_somm1);
    }
    if (!isAlreadyAdded(p_arete->somm2)){
        sommets.push_back(p_somm2);
    }
}

J'ai fait les mêmes modifications dans toutes mes classes dérivées, c'est à dire:

Code :

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

1
2
3
4
 
class GenericReseaux: public Decorator<GenericGraphes<GenericReseaux,GenericNoeuds,GenericLiens>,GenericReseaux>{
//..........
}

Et au final je ne me sert pas de la fonction de conversion:

Code :

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

1
2
 
derived_type * realType(){return real_;}

Je ne fait que cacher mes sous-types avec le Decorator. Mais ça fonctionne pas super bien. Bref encore merci à vous pour votre patience et vos explications. Toujours est-il que le coup de l'héritage générique, j'avoue c'est superbe comme astuce.

[lodacom]

Bonjour,
He bien au final j'ai réussi à trouver la solution par moi même et elle était bien plus simple que l'utilisation d'un Decorator. Pas besoin de faire toutes ces modifications qui m'avaient parues bizarre. Enfin bref, voici ce qu'il fallait faire:

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
 
template <class G,class S,class A>
void GenericGraphes<G, S, A>::addArete(A* p_arete,S* p_somm1,S* p_somm2){
    if (p_arete->getArete_dans()==NULL){
        p_arete->setArete_dans(dynamic_cast<G*>(this));
    }
    p_somm1->setSommet_dans(dynamic_cast<G*>(this));
    p_somm2->setSommet_dans(dynamic_cast<G*>(this));
    p_somm1->addArete(p_arete);
    p_somm2->addArete(p_arete);
    p_arete->setSommets(p_somm1, p_somm2);
    //on ajoute l'arête dans le graphe
    aretes.insert(p_arete);
    //on ajoute les sommets dans le graphe
    sommets.insert(p_somm1);
    sommets.insert(p_somm2);
}

En réalité il suffisait de faire un cast générique (on appel aussi ce type de cast, j'ai trouvé ça dans un de mes cours une coercition). Et voilà grâce à cette simple modification, mon programme fonctionne.
Je remercie tout de même, koala01 et évidemment toutes les autres personnes qui ont pu m'aider (même si cela a été sans succès).

[therwald]

bonjour. note que le dynamic_cast introduit un risque: s'il se trouve que le runtime-type de ton argument n'est pas du sous-type visé, tu récupères un pointeur nul, ce qui veut dire que tu perds en sécurité sur la typage.
Sans plus de contexte, tu cours le risque de plantages dans certains cas (je ne te vois pas gérer le cas NULL) sauf si tu peux être SÛR PAR CONSTRUCTION que l'objet passé sera toujours de ton sous-type G...
Les cast sont utilisés sur this, la fonction template est elle membre d'une classe template qui dérive de G?

[koala01]

Bonjour,
He bien au final j'ai réussi à trouver la solution par moi même et elle était bien plus simple que l'utilisation d'un Decorator. Pas besoin de faire toutes ces modifications qui m'avaient parues bizarre. Enfin bref, voici ce qu'il fallait faire:

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
 
template <class G,class S,class A>
void GenericGraphes<G, S, A>::addArete(A* p_arete,S* p_somm1,S* p_somm2){
    if (p_arete->getArete_dans()==NULL){
        p_arete->setArete_dans(dynamic_cast<G*>(this));
    }
    p_somm1->setSommet_dans(dynamic_cast<G*>(this));
    p_somm2->setSommet_dans(dynamic_cast<G*>(this));
    p_somm1->addArete(p_arete);
    p_somm2->addArete(p_arete);
    p_arete->setSommets(p_somm1, p_somm2);
    //on ajoute l'arête dans le graphe
    aretes.insert(p_arete);
    //on ajoute les sommets dans le graphe
    sommets.insert(p_somm1);
    sommets.insert(p_somm2);
}

En réalité il suffisait de faire un cast générique (on appel aussi ce type de cast, j'ai trouvé ça dans un de mes cours une coercition). Et voilà grâce à cette simple modification, mon programme fonctionne.
Je remercie tout de même, koala01 et évidemment toutes les autres personnes qui ont pu m'aider (même si cela a été sans succès).

Hummm... Dangereux, ca

Déjà, le dynamic_cast ne fonctionne que si tu dispose d'une "table de fonctions virtuelles" (vtable).

Cela implique, au minimum, que GenericGraphes hérite d'une classe non template, même si c'est de manière indirecte (car la déclaration de fonctions virtuelles, surtout si elles sont pures ne se marie pas bien avec les templates).

En outre, cela signifie que G hérite de GenericGraphes, et que tu as la certitude que ton GenericGraphes<G, S, A> est, bel et bien un G (et non un S, un A ou meme un F qui hériterait, pourquoi pas, de GenericGraphes<G, S, A> ).

Peux tu apporter ces certitudes
[EDIT]Grilled C'est ce qui arrive quand on répond à deux discussions en meme temps

[lodacom]

Comme tu dis koala01 il faudrait que je borne mon G à ma classe GenericGraphes. Mais la généricité F-Bornée n'est pas possible à faire en C++. On ne peut que la simuler. Et malheureusement je ne sais pas comment on fait. Mais merci tout de même pour la remarque.

[therwald]

Mais exactement, qu'est-ce qui t'empêche de faire dériver ta classe (la fonction template étant visiblement une fonction d'instance) de G pour sécuriser la chose? En l'état tu peux écrire un code qui dis à tes sommets qu'il sont "sommet dans" NULL...ça fait partie des possibles? Sinon ça fera schpouf traîtreusement à 15 km du code fautif...

[lodacom]

Hehe justement c'est ce que j'ai fait (voir un peu plus haut dans les posts) avec par exemple la classe GenericReseaux qui hérite de GenericGraphes (qui en passant concrétise les paramètres génériques). Bref, mon problème est résolu c'est comme qui dirait l'essentiel.

[therwald]

Hehe justement c'est ce que j'ai fait (voir un peu plus haut dans les posts) avec par exemple la classe GenericReseaux qui hérite de GenericGraphes (qui en passant concrétise les paramètres génériques). Bref, mon problème est résolu c'est comme qui dirait l'essentiel.

Ce n'est pas faux mais la thread servira aussi aux personnes avec un problème similaire, donc autant marquer la chose noir sur blanc...or il m'a fallu un bon moment pour retrouver où dans les post quelque chose implique de faire descendre la classe GeneriqueGraphes de G...donc autant faire une synthèse.
Par ailleurs notons ce qu'a précisé koala01, pour que ça marche bien, GeneriqueGraphes doit être une classe non-template avec au moins une méthode virtuelle (le destructeur par ex?), ou descendre d'une classe non-template avec au moins une méthode virtuelle.