Discussion :

[buzzkaido]

Bonjour,

Voila, j'ai un ensemble de classe qui me permettent de stocker des objets.
Je voudrais établir une fonction de convertion de type.

Par exemple A pour des cubes et B pour des spheres, une convertion d'un cube en sphere serait de creer une sphere qui a le meme volume que le cube.

Le probleme, c'est que je ne connait pas à l'avance le type des objets.

Je voudrais pouvoir appeler :

A = convertir(B);

Si A est une sphere et B un cube
ou Si A est une sphere et B une sphere
ou Si A est un cube et B une sphere
ou Si A est un cube et B un cube

Et si B ou A est un poireau, et qu'il n'existe donc pas de conversion logique, la fonction renvoit NULL (on convertit des pointeurs)

Je pense le faire en faisant deriver tous mes objets d'une classe mere "objetConvertible".

Dans cette classe, il y aurait :
- une info de type, initialisée par le constructeur de chaque classe dérivée
- une fonction de conversion qui connait toutes les combinaisons d'objets convertibles et renvoit un pointeur ou NULL


C'est un bon début à votre avis ?

Sinon je connait pas trop boost::any et boost::any_cast, y'aurais moyen de faire un truc propre avec ça ?

[lun4t1k]

Un cast? dynamic_cast?

[buzzkaido]

Ben oui, un truc dans ce genre, mais je cherche comment implémenter ça proprement.

J'ai déjà bricolé un truc, mais je trouve ça un peu trop bancale.

Et les convertions de type que je veux faire, il faut que je les implemente moi-meme car ce ne sont pas des types de données genre INT ou CHAR, mais des objets bien spécifiques...

[lun4t1k]

Ben regarde dynamic cast, il ne fait pas que les types primitifs.

[buzzkaido]

Ok, mais je ne trouve pas comment on implemente une conversion en particulier...

Par exemple, pour definir la conversion entre un objet cSphere et un objet cCube qui dérivent tous les deux de cConvertible ?

[lun4t1k]

Exemple tu crées un vecteur de cConvertible

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
vector<cConvertible *> c;
//tu le parcours
for (int i=0;i<c.size();i++)
{
     if (dynamic_cast<CSphere*>(c[i])!=0 )
                  //Ton objet est une cSphere
 
     else
      {
            // tu le convertis en CSphere ou CCube
            cCube *c= dynamic_cast<cConvertible *>(c[i]);
            if (c!=NULL) //C'est ok
       }
}

Enfin un truc du genre...

[loufoque]

Ben regarde dynamic cast, il ne fait pas que les types primitifs.

Il ne fait pas du tout les types primitifs.
dynamic_cast ne marche qu'avec les classes polymorphes.

[lun4t1k]

Bah oui, mais c'est vrai qu'en me relisant je me suis trompé.
je n'ai jamais fait de dynamic_cast sur un int

[FabaCoeur]

Mais je ne comprends pas, à part surcharger autant de fois que nécessaire la fonction convertir() je ne voie pas comment faire, puisque par exemple dans le cas que tu as donné, comment est ce que le compilateur va faire pour savoir les calculs à faire pour convertir un carré en sphère? Et de même pour convertir un poireau en carotte... il faut définir des règles, spécifique à tous les types à convertir, je ne voie pas comment est ce que le compilateur pourrait s'y retrouver la dedans s'il n'a pas des règles présices pour tous les types d'éléments...!

[buzzkaido]

C'est exactement ce que je cherche à faire : donner au compilateur un ensemble de regles de conversions.

Seulement, si je surcharge autant de fois que necessaire une fonction "convertir", dans le cas où aucune conversion n'existe (donc aucune fonction "convertir") comment ça se passe ?

En fait, je cherche une solution plus propre et moins bricolage qu'une fonction surchargée plein de fois.

Peut-etre en implementant des constructeurs de recopie qui prennent en parametre le type de base de la conversion dans chaque classe qui est destinataire de la conversion ?

Qu'en pensez-vous ?

[FabaCoeur]

Peut-etre en implementant des constructeurs de recopie qui prennent en parametre le type de base de la conversion dans chaque classe qui est destinataire de la conversion ?

Ca revient à quelque chose près à surcharger une fonction, et dans toutes les classes donc on retombe un peu sur nos pattes en quelque sorte !

[bountykiller]

Peut-etre en implementant des constructeurs de recopie qui prennent en parametre le type de base de la conversion dans chaque classe qui est destinataire de la conversion ?

Qu'en pensez-vous ?

Perso, je pense que c'est la bonne approche.

Ca revient à quelque chose près à surcharger une fonction, et dans toutes les classes donc on retombe un peu sur nos pattes en quelque sorte !

Je ne pense pas car si j'ai bien compris, il va juste dans chaque classe créer un constructeur qui prend en paramètre un cConvertible. Cela fait donc 1 seul constructeur à définir par classe.
Evidemment, je suppose ici que toutes les conversions se font de la même manière, à savoir sur base du volume occupé par chaque cConvertible.

[loufoque]

Mais je ne comprends pas, à part surcharger autant de fois que nécessaire la fonction convertir() je ne voie pas comment faire, puisque par exemple dans le cas que tu as donné, comment est ce que le compilateur va faire pour savoir les calculs à faire pour convertir un carré en sphère? Et de même pour convertir un poireau en carotte... il faut définir des règles, spécifique à tous les types à convertir, je ne voie pas comment est ce que le compilateur pourrait s'y retrouver la dedans s'il n'a pas des règles présices pour tous les types d'éléments...!

En effet, il faut définir les règles pour chaque couple de types pour la conversion.
Néanmoins, le problème principal c'est que dans son système il ne connait pas les types réels de ses objets avant l'execution.

[buzzkaido]

Loufoque a bien compris le probleme :

1/ le type des données à convertir n'est connu qu'à l'execution

Je n'ai aucun souci avec le fait de devoir implémenter une fonction pour chaque couple de types convertibles. Ca parait logique, le compilateur ne peut pas inventer ces conversions.

Par contre, l'autre souci, c'est :

2/ comment gérer le fait qu'à l'execution une conversion peut etre demandée entre deux types qui ne sont pas convertibles entre eux ? (dans ce cas, il faudrait que la conversion renvoit un pointeur NULL)

En implementant TOUTES les conversions, et en renvoyant NULL quand ce n'est pas possible ?

Vu que je vais avoir beaucoup d'objets, j'aimerais éviter cette solution...

Sinon j'ai pensé à ça :

Dans la classe mère cConvertible, mettre :
- un membre int m_type
- une méthode virtuelle convertir(int typeDestination)

Puis :

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
 
cConvertible* cConvertible::convertir(int typeDestination)
{
    return NULL;
}
 
cConvertible* cSphere::convertir(int typeDestination)
{
   cConvertible* pRetour = NULL;
 
   switch (type_destination)
   {
       case TYPE_SPHERE:
               pRetour = new cSphere(*this);
               break;
       case TYPE_CUBE:
               pRetour = new cCube();
               pRetour->m_cote = laBonneFormule
               break;
   }
 
   return pRetour;
}
 
cConvertible* cCube::convertir(int typeDestination)
{
   cConvertible* pRetour = NULL;
 
   switch (type_destination)
   {
       case TYPE_SPHERE:
               pRetour = new cSphere();
               pRetour->m_rayon = laBonneFormule
               break;
       case TYPE_CUBE:
               pRetour = new cCube(*this);
               break;
   }
 
   return pRetour;
}

Comme ça, si je crée une nouvelle dérivée cPyramide de cConvertible et que je tente une conversion avec une sphere, le type n'est pas reconnu et j'obtiens NULL (conversion échouée)

Mais le fait de stocker le type dans chaque objet et de faire des switch ne me plait pas trop....

Sinon y'a ce post : http://www.developpez.net/forums/sho...d.php?t=343965 qui me parait une bonne piste...