Regroupement en un type

Bonjour,

je voudrais savoir s'il est possible de créer un type d'objet regroupant plusieurs types d'objets même si ceux-ci n'ont aucun attributs communs. Et si oui comment faire.

Merci

c'est un truc du genre que tu veux faire?

Code:

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
 
class Objet_A{
private:
   int m_toto;
   ...
 
   Objet_A(){m_toto=0;};
}
 
 
class Objet_B{
private:
   int     m_tata;
   float  m_gege;
 
   Objet_B(){m_tata=0;m_gege=0;};
}
 
 
class Objet_regroup{
private:
    Objet_A  m_objA;    //appelle constructeur Objet_A()
    Objet_B  m_objB;
 
    Objet_regroup()
}

hum pas tout à fait puisque la classe regroupante sera soit un objet soit un autre. En fait c'est comme si j'avais une classe truc qui pourrait être soit un objet de type montre ou soit un objet de type scotch (alors que scotch et motre n'ont rien de commun).

tu parles du principe des unions

Salut,

Il y a plursieurs possibilités pour faire ce que tu veux...

En gros, tout tient dans un terme "conception" :D

L'une des solution est de te dire que "un élément contient des informations de type montre et de type scotch"...

Une simple agrégation peut alors suffir sous la forme de
Code:

1 2 3 4 5 6 class MonType { /*...*/ scotch m_s; montre m_m; };
Sinon, tu peux aussi te dire que "un élément est tout à la fois du type scotch et du type montre", parce que l'élément en question a "toutes les caractéristiques" de ce qui fait "une montre" et "du scotch" (bon, ici, il faudra quand meme chercher ce que ca peut être :p) car le C++ autorise l'héritage multiple.

Tu peux donc créer un type "MontreScotch" sous une forme proche de
Code:

1 2 3 4 class MontreScotch : public montre, public scotch { /*...*/ };
et, si le type montre et le type scotche ont des membre dont le nom est commun (ex: prix), tu devra préciser si tu souhaite avoir le prix venant de montre ou celui venant de scotch sous une forme proche de
Code:

1 2 3 4 5 6 7 void MontreScotch::fonction() { /* accede au prix de montre*/ type pm = montre::prix; /* accede au prix de scotch */ type ps = scotch::prix; }
Maintenant, il est souvent préférable de voir s'il n'y a pas moyen de créer une interface commune, dont les différents types pourraient hériter, et qui te servirait de base pour le polymorphisme

Ainsi, une classe Vendable pourrait faire l'affaire sous une forme proche de
Code:

1 2 3 4 5 6 7 8 class Vendable { public: /* les méthodes communes à scotch et à montre */ private: /* les membre communs à scotch et à montre, parmis lesquels */ float prix_vente; };
scotch et montre hériteraient de Vendable selon le principe que "scotch a toutes les caractéristiques qui font qu'il est vendable" (et idem pour montre) sous la forme de
Code:

1 2 3 4 5 6 7 8 9 10 class scotch : public Vendable { /*...*/ /*méthodes et membres propres à du scotch */ }; class montre : public Vendable { /*...*/ /*méthodes et membres propres à du scotch */ };
et, quand tu dois faire cohabiter les deux, tu les considère comme étant... des vendables sous une forme proche de
Code:

1 2 3 4 5 6 7 8 std::vector<Vendable*> tab; /* ajoute un nouveau scotch */ tab.push_back(new scotch(/*...*/); /* ajoute une nouvelle montre */ tab.push_back(new montre(/*...*/); /* accede aux méthode de Vendable pour le scotch et pour la montre*/ tab[1]->methode1(); tab[2]->methode2();
ou méthode1 et méthode2 sont des fonctions éventuellement redéfinies pour être polymorphiques ;)

Merci pour votre aide