Tableau d'objets de type différents

Version imprimable

Bonjour à tous

J'ai deux classes différentes : classe1 et classe2
Est il possible, dans mon main de faire un tableau qui accepterait à la fois des éléments de type classe 1 et de type classe 2?

Ca donnerait :
Code:

1 2 3 4 5 6 7 8 9 10 11 #include "classe1.h" #include "classe2.h" classe1 * objet1; classe2 * objet2; (classe1 et classe2) * montableau[10] objet1 = new classe1(); objet2 = new classe2(); montableau[0] = objet1; montableau[1] = objet2;
Merci d'avance pour votre aide

11/01/2005, 19h06
Laurent Gomila

Oui :

- Via pointeur sur classe de base si classe1 et classe2 dérivent d'une même classe.
- Dans une classe de variants (boost::any) sinon.

Mais en général on évite ce genre de pratique. Quel est le but de la manip ?
11/01/2005, 19h06
Asarnil

Si ces classes ont quelque chose en commun, se ressemblent ... utilise le polymorphisme sinon tu ne dois pas faire ce genre de chose. Il y a moyen de faire un tableau de pointeurs void et de faire du casting mais c'est de la programmation bidon. Si ces classes ne se ressemblent pas alors elles n'ont rien a faire ensemble dans le meme tableau, pas comme en php ou on met un peu tout et n'importe quoi dans un tableau ;) .
11/01/2005, 19h12
Hell

mes deux classes héritent d'une même classe (on va dire classe 0), elles ont donc un gros morceau en commun, est ce que c'est suffisant?

car mon but, c'est de les mettre dans un tableau et de choisir un element aléatoirement et d'afficher ses propriétés

je sais que ça sert à rien mais c'est pour m'entrainer que je voudrais faire ça, est ce possible de cette manière?

alors tu fais un tableau de pointeur vers la classe parente ;)
Code:

1 2 3 4 5 6 7 8 9 10 class parent {..........}; class fils : public parent {.........}; class fille : public parent {........}; . . . vector <parent*> tab; tab.push_back(new fils); tab.push_back(new fille);
apres pour utiliser les objets de ton tableau, si tu sais ce que c'est : static_cast, sinon dynamic_cast
Code:

1 2 static_cast<fils*>(tab[0])->methode();
Code:

1 2 3 4 fille* pt; pt = dynamic_cast<fille*>(tab[1]); // je tente la conversion if (pt != NULL) pt->methode(); // ca marche, c'est bien une fille

11/01/2005, 19h27
Hell

Ah d'accord, je pensais pas que ça serait aussi simple
Car j'ai cherché dans les conteneurs si on pouvait mettre plusieurs types (un peu comme un Tobjectlist sous borland) mais j'ai rien trouvé et ça fait quelques heures que je fais ça :D

Merci beaucoup !

au fait, les cast, ne les utilise que si tu veux acceder a une(des) methode(s) qui existe(nt) dans une classe mais pas dans l'autre ;) sinon le virtual fera son office et l'objet saura de lui meme quoi appeller.

exemple:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
#include <iostream>
#include <vector>
using namespace std;
 
class parent {
  public:
    parent () {}
    virtual void heho () =0;
    virtual ~parent () {}
};
 
class fils : public parent {
  public:
    fils () : parent() {}
    virtual void heho () { cout<<"je suis un fils"<<endl; }
};
 
class fille : public parent {
  public:
    fille () : parent() {}
    virtual void heho () { cout<<"je suis une fille"; }
    void snif () { cout << " donc je ne viens pas sur developpez.com" << endl; }
};
 
int main () {
  typedef vector<parent*> v_p;
  v_p famille;
  famille.push_back(new fils);
  famille.push_back(new fille);
  famille.push_back(new fille);
  famille.push_back(new fils);
  famille.push_back(new fils);
  for (v_p::const_iterator it=famille.begin(); it!=famille.end(); ++it) {
    (*it)->heho();
    fille* pt = dynamic_cast<fille*> (*it);
    if (pt != NULL) pt->snif();
  }  
  system("pause");
  return 0;
}

11/01/2005, 20h28
Laurent Gomila

Le downcasting est la plupart du temps à éviter, surtout lorsqu'on peut (comme dans ton cas) utiliser avantageusement le polymorphisme.
11/01/2005, 20h48
Hell

c'est trop compliqué les cast pour moi, je crois que je vais rester avec les méthodes normales :D
11/01/2005, 22h57
Asarnil

Citation:

Envoyé par Loulou24

Le downcasting est la plupart du temps à éviter, surtout lorsqu'on peut (comme dans ton cas) utiliser avantageusement le polymorphisme.

merci de mettre en garde :)

les exemples que je donne sont fonctionnels, donent une implementation possible mais ne sont pas la solution optimale, il faut reflechir sa classe pour le polymorphisme si on sait qu'on en aura besoin.

neanmoins le casting est une chose a connaitre et l'on est parfois amene a l'utiliser.