Polymorphisme + New

Version imprimable

Polymorphisme + New

Les classes:
J'ai une classe abstraite Individu puis deux classes héritant de cette classe Individu, Homme et Femme.

Maintenant j'ai une classe listIndividu et j'ai envie de créer une fonction
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class listIndividu { public: Individu * list; Individu * new_individu_size(Individu * ind,int n) { return list = new ???[ n]; // la je veux créer n femmes ou hommes //selon la liason du pointeur dynamique } }; int main() { Femme* f; listIndividu list; list.new_individu_size(f,3); }
Comment faire???

13/12/2006, 15h09
vincho

Est-ce assez clair???
13/12/2006, 15h22
Cheps
Citation:

Envoyé par vincho

Est-ce assez clair???

Pas vraiment, tu veux faire quoi exactement? Une liste chaînée d'individus?

Remarque que pour utiliser le polymorphisme avec un tableau, tu es obligé d'utiliser un tableau de pointeurs:
Code:

1 2 3 4 Individu *tab[2]; tab[0] = new Femme(); tab[1] = new Homme();
Pour t'aider plus précisément il faudrait plus d'informations sur ce que tu essaies de faire...
13/12/2006, 15h35
vincho

Je veux créer une liste d'individu correspondant au pointeur de la liaison dynamique de l'argument de la fonction new_individu_size.

En vérité, je travaille en traitement d'images, et je voudrais créer une image qui est une liste de voxel sachant que les voxels peuvent être différents.
donc:
une fonction new_voxel_size quelques soient le voxel
13/12/2006, 15h52
vincho

Et à la compilation je ne sais pas quel type de voxel ou d'individu (Homme ou femme), la liste va contenir.

C'est à l'éxécution que la lister va créer une liste de femme ou d'homme...

c'est pourquoi je veux faire appel à une fonction:
new_individu_size(Individu * ind,int n)
et selon le lien dynamique creer le bon type
13/12/2006, 15h58
Feriaman
Citation:

Envoyé par vincho

Comment faire???

Tu peux faire ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 class listIndividu { public: Individu * list; template<typename T> Individu * new_individu_size(T* ind,int n) { return list = new T[ n]; // ici tu remplis ton tableau } }
Mais ton code est bizare, on peut imaginer un cas dans lequel ce conteneur que tu fais ait un sens, mais il s'agit d'un cas tout de même assez alambiqué.

Le code que j'ai écris ci-dessus compile et peut marcher, si tu sais VRAIMENT ce que tu fais. Mais c'est pas très joli joli.

Si tu débutes en C++ et que tu veux utiliser un tableau de taille variable, tu devrais te documenter ici
plutot que d'essayer d'en faire un toi-même.
13/12/2006, 16h01
Cheps

Ton image tu connais sa taille, elle a par exemple m*n voxels? Dans ce cas, comme j'ai fais plus haut, tu pourrais faire un tableau de pointeurs de taille m*n.

De toute évidence c'est ton instance qui va savoir si elle est un homme ou une femme ; c'est donc à elle qu'il va falloir demander de créer des instances du même type. C'est en quelque sorte une extension du design pattern du clone.

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
class Individu
{
public :
 
    virtual Individu* Clone(int Count) = 0;
};
 
class Homme : public Individu
{
public :
 
    virtual Individu* Clone(int Count) {return new Homme[Count];}
};
 
class Femme : public Individu
{
public :
 
    virtual Individu* Clone(int Count) {return new Femme[Count];}
};
 
Individu * new_individu_size(Individu * ind, int n)
{
    if (ind)
        return ind->Clone(n);
    else
        return NULL;
}

13/12/2006, 16h09
vincho

Merci de vos réponses:

Je vais garder la solution de Feriaman car elle me permet de ne pas définir pour chaque class Homme, Femme, enfants, chiens, cochons... la fonction clone que me propose Laurent Gomila.

Encore Merci,
Ca compile, Youpi!!!!!!!!!!
13/12/2006, 16h13
Feriaman

J'aurais mieux fait de me taire.

Citation:

Le code que j'ai écris ci-dessus compile et peut marcher, si tu sais VRAIMENT ce que tu fais. Mais c'est pas très joli joli.

Ma "solution" n'est pas bonne, et elle va poser un certain nombre de problèmes par la suite.

Notament, tu vas devoir caster ta liste avant de t'en servir.
Tu ne dois pas utiliser cette solution.
13/12/2006, 16h23
Feriaman

J'explicite : ta variable list "croit" qu'elle pointe sur un tableau de A, alors qu'elle pointe sur un tableau de B, elle n'est donc pas capable de retrouver ses propres éléments, du coup, ce code :

Code:

list[1];

renvoie n'importe quoi et surtout pas le second élément du tableau.

Le premier élément du tableau serait renvoyé par exemple par :

Code:

((Femme*)list)[1];

si c'est un tableau de femmes.

C'est très moche comme solution.
13/12/2006, 16h40
vincho

Merci, je vais donc implanter clone dans chacune des classes!!!!

Je croyai que la force de C++ était de pouvoir s'abstenir d'écrire n fois la même fonction; ici clone.
J'aurai du rester au C pure ;)
13/12/2006, 16h58
Feriaman
Avec tout le respect que je dois à Laurent Gomila, cela ne changera rien du tout.

Le problème vient du fait que tu stockes un tableau de "Homme" dans un pointeur de "Individu"... quel que soit la façon dont tu génère ton tableau, le problème de l'adressage restera le même.

Ce que je te propose (si vraiment tu ne veux pas utiliser les conteneurs de la stl comme mentionné plus haut), c'est de faire quelque chose comme ça :
Code:

1 2 3 4 5 6 class listIndividu { public: Individu ** list; }
Après, tu peux créer ton tableau selon la méthode de Laurent ou en utilisant la méthode template décrite plus haut.
(quelque chose comme :
Code:

1 2 3 4 5 6 7 8 ... template<typename T> Individu * new_individu_size(T* ind,int n) { return list = new T*[ n]; // ici tu remplis ton tableau } ...
à noter : le new T*[n] qui crée non pas un tableau d'éléments, mais un tableau de pointeurs)

La différence réside dans le fait que ta liste n'est plus une liste d'individus, mais une liste de pointeurs d'individus.

Or tous les pointeurs ont la même taille, donc ton tableau saura repérer son contenu. Et donc :

Code:

list[1];

retournera bien un pointeur du second élément.

Attention quand même, si tu fais ceci, il te faut faire des new et des delete pour chaque élément de ton tableau.
13/12/2006, 18h21
vincho

Comment faire si l'on veut que list soit de type vector de la librairie stl
13/12/2006, 20h27
Laurent Gomila

Tu lis les bonnes Q/R dans la FAQ C++, les tutoriels STL que l'on héberge, tu suis les liens donnés dans la FAQ vers les docs de référence, et/ou en dernier recours tu appelles ton ami Google.

Bref il y a largement de quoi faire.

Je lis plein de trucs bizarre.
Reprennons.
Tu veux :
a- une liste d'individus (hommes et femmes mélangés)
b- ou alors une liste d'hommes seulement ou de femmes seulement ?

a- => std::vector<individu*> (le "*" est très important)

b- Plus compliqué. Je verrais bien un truc du genre
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 struct ListeIndividus : boost::noncopyable { virtual Individu & operator[](int p) = 0; virtual Individu const& operator[](int p) const = 0; ... à compléter en fonction des besoins }; template <class TypeIndividu> struct Liste : ListeIndividus { virtual TypeIndividu & operator[](int p) { return m_liste[p]; } ... private: std::vector<TypeIndividu> m_liste; }; .... boost::scoped_ptr<ListeIndividus> liste; switch (QuoiFaire) { case hommes: liste.reset( new Liste<Homme>(...) ); break; case femmes: liste.reset( new Liste<Femme>(...) ); break; default: assert( ! "Choisir homme ou femme"); } // switch Individu & i = (*liste)[41]; i -> manger(pain);
Il y a dans ces quelques lignes, une quantité abominable de problèmes que j'ai réussi à masquer -- et encore, j'ai pu en louper.
Cela sent furieusement le moisi.

Tu es sûr d'avoir besoin d'un polymorphisme résolu dynamiquement (i.e. à l'exécution) ? Si tu réponds "non", en virant à 100% templates, il y a moyen d'avoir un design propre qui soit exploitable je pense. Et potentiellement plus rapide par élimination des virtuals.

(Au fait, j'ai vu qu'adobe.GIL a été accepté dans boost -> bibliothèque de manipulations d'images)

14/12/2006, 01h28
JolyLoic

Je pense qu'une des premières question à se poser est si la structure de classe avec individu/homme/femme a du sens, par rapport à l'alternative qui serait une classe individu avec une donnée membre sexe. Si non, ça doit encore simplifier les choses.
14/12/2006, 16h05
vincho

Pour la question pourquoi pas mettre une instance sexe, je dis que l'exemple choisi avais juste la volonté de clarifier mon problème.... ( ce que je veux faire, c'est un tableau, image générique où l'on peut ranger les n objets d'une classe quelqu'on que).

Ou en d'autre mots:

Pour toute Class T,
je veux créer un tableau qui est une collection d'objet de la class T
tableau = (objet1,....,objetn)/{pout tout objet i appartient à T}

Ce tableau sera fixe une fois créer, en revanche je veux pour voir saisir n'importe que élément. C'est pourquoi je voulai faire appel à vector.

En revanche, faire appel à un tableau de pointeur qui pointe vers chaque objet ou voxel est pour moi une perte de mémoire.
Taille occupé de mémoire = n*(size(pointeur)+size(objet))

Or mon travail est fait sur des images 3D de taille 1024*1024*1024.

En C, je faisai pour le type int par exemple ( int * x= (int*) malloc(sizeof(int)*n) )

A la question résoudre à la compilation ou l'exécution, je dis que j'ai une librairie de traitement d'image en C qui repose sur deux uniques notions
- Pouvoir parcourir l'ensembles des points/objets de l'espace
- Pouvoir obtenir les points/objets associées au voisinage d'un point.

Les espaces digitales répondant à ces deux contraintes sont par exemplet un graph,un maillage pavé ou héxagonale....

Ce qui m'embéter en c, c'est que pour chaque type/espace, je devais réecrire l'ensemble des fonctions.

C'est pourquoi j'ai pensé au C++.
Avoir deux modules:
1:librairie de traitement d'image reposant sur voisinage et pour tout point
2:espace

Lors de l'appel de la fonction voisinage d'un point dans la librairie de traitement d'image, on sait(je pense) avant l'éxecution quel est l'espace car on donne le lien dynamique Space * unSpace.
ListdePoint = unSpace->voisinage( unSpace->Point(4) )

Merci si vous pouvez me répondre
14/12/2006, 16h19
Cheps
Citation:

Envoyé par vincho

En revanche, faire appel à un tableau de pointeur qui pointe vers chaque objet ou voxel est pour moi une perte de mémoire.
Taille occupé de mémoire = n*(size(pointeur)+size(objet))

Or mon travail est fait sur des images 3D de taille 1024*1024*1024.

Une taille pareil ça te fait un millard d'elément, t'espères pas tout stocker un RAM j'espère? Si chaque élément est un int par exemple, certainement codé avec 4 octets (c'est assez classique), ça te fait déjà 4Go :?
Et comme tu parles d'objets, c'est certainement encore plus complexe qu'un simple int, donc encore plus gros en mémoire?

Citation:

Envoyé par vincho

Pour toute Class T,
je veux créer un tableau qui est une collection d'objet de la class T
tableau = (objet1,....,objetn)/{pout tout objet i appartient à T}

Pour ton problème, si chaque objet est de même type, qu'est ce qui t'empêche de faire un bête tableau?

Code:

MaClass tableau[nombreElements];

Par contre si tu veux faire du polymorphisme avec ton tableau, je me permets de réitérer mon code de ci-dessus:
Code:

1 2 3 Individu *tab[2]; tab[0] = new Femme(); tab[1] = new Homme();
Où Femme et Homme sont des sous-class de Individu.
14/12/2006, 16h27
vincho

Pour le problème de mémoire, le laboratoire où je suis à une station de travail de possédant 16 giga de mémoires vives.

Pour ton truc, je veux faire appel à vector mais le problème est ???
vector<type_individu>
14/12/2006, 16h38
Cheps

Ok, mais pourquoi tu veux utiliser un Vector? C'est une structure de données dynamique, alors que toi tu as un tableau statique (sa taille de 1024*1024*1024 ne change pas)?

Et que contient un de tes objets? Je réitère mon histoire de mémoire: 16Go ça parait beaucoup, mais avec un millard d'elément ça ne te laisse 16octets par objet.
14/12/2006, 22h05
Luc Hermitte

<mode coup de gueule>
Mais c'est dingue ça!
Suite à un nombre grandissant de personnes qui m'envoient des MPs, je recorrige ma signature pour bien signifier que non, je ne répondrais pas. Et ben non. Je continue de recevoir des MPs sur des sujets techniques, pire des copier coller exacts de ce que l'on lit ici.
Mais ce n'est pas possible. Si on ne répond pas dans la journée aux posts sur les forums, c'est qu'il y a une raison bon sang de bon soir!

Tiens, du coup je répondrais peut-être plus tard.
</>
14/12/2006, 22h11
loufoque

C'est le statut d'expert, ça attire les foules.
14/12/2006, 22h16
Luc Hermitte

Et quand on sait comment on l'obtient... Pfff, c'est dingue.
J'aime bien ton status courant de "provisoirement toléré". Petit veinard va. Profites-en bien. :mouarf:
15/12/2006, 00h36
Luc Hermitte

@OP. Tu veux factoriser du code (compilation), ou bien charger un biniou dont le type sera déterminé à la lecture d'un fichier (p.ex.) et appliquer ensuite (exécution) ce qui va bien en conséquence ?

Sinon, je lis des choses qui me font penser à ce que j'ai entr'apperçu dans adobe.GIL (bientôt boost.GIL, donc).
NB: je ne suis pas un spécialiste du domaine.

Citation:

Envoyé par Cheps

Ok, mais pourquoi tu veux utiliser un Vector? C'est une structure de données dynamique, alors que toi tu as un tableau statique (sa taille de 1024*1024*1024 ne change pas)?

Pour précser le vocabulaire. "tableau statique" == "buffer dans la pile". Ce ne tiendra jamais.
Si tu veux juste dire que cela ne serait jamais redimensionné, avec les vecteurs, il ne devrait pas payer ce qu'il n'utilisera pas. Ceci dit, il est vrai qu'il existe des structures matricielles 100 fois plus adaptées. On les trouve p.ex. chez boost, voire chez adobe pour ce qui est des images.
15/12/2006, 10h01
Feriaman

Citation:

Envoyé par Cheps

Ok, mais pourquoi tu veux utiliser un Vector? C'est une structure de données dynamique, alors que toi tu as un tableau statique (sa taille de 1024*1024*1024 ne change pas)?

Tu as parfaitement raison : il n'a pas besoin d'un tableau dynamique.

Cependant, il me semble plus intelligent, lorsque l'on n'a pas forcément une maitrise parfaite du c++ comme la tienne, d'utiliser un conteneur tout fait.

Ce n'est pas plus rapide à l'exécution, ce n'est peut-être pas optimum en mémoire, ce n'est pas aussi "class" que de faire son propre conteneur, mais c'est plus sur et cela lui évitera plein d'ennuis, comme la gestion d'un tableau de pointeurs, les Individus**, la gestion de sa mémoire...

Après, je t'accorde qu'il existe d'autres conteneurs plus adaptés comme ceux que propose "Luc Hermitte", reste à savoir si ce problème mérite le fait d'inclure une librairie additionelle (fut-ce boost) , ce qui n'est pas forcément évident quand on ne maitrise pas son ide / compilateur.
15/12/2006, 10h02
Cheps

Je n'ai jamais utilisé des tableaux d'un milliard d'elément, mais j'ai une applic avec un tableau de 400*400*400 int et qui tourne parfaitement. Tu veux dire quoi par "Ce ne tiendra jamais." ? Niveau stabilité ou niveau performances?

Code:

1
2
3
4
5
6
7
8
9
void f() {
   int t[TROPGROSPASSERAPAS];
   std::cin >> t[0];
}
 
int main() {
    f();
    return EXIT_SUCCESS;
}

=> core dump

Moi je fais un truc du genre:

Code:

1
2
3
4
5
6
7
8
9
10
11
 
int *tab;
 
try
{
    tab = new int[GROSTABLEAU];
}
catch(std::bad_alloc &e)
{
    "Aïe aïe aïe"
}

15/12/2006, 11h53
Jean-Marc.Bourguet

J'ai pas bien compris le probleme. Je ne suis pas sur en particulier que la difference ait ete faite entre le probleme et la solution envisagee. Je n'ai pas non plus compris pourquoi une solution pure template est a rejeter car ca me semble etre la meilleure solution au probleme que j'ai compris.

En admettant qu'il faille etre plus dynamique, avoir les objets qui ont des membres virtuels me semble a eviter. Donc on se retrouve a decoupler les objets de leur comportement. Ca fait penser aux patterns Flyweight, Prototype, Strategy et Template Method du bouquin du GoF. Peut-etre encapsule dans des templates qui pour fournir une interface type safe a une interface de plus bas niveau.
15/12/2006, 16h11
vincho

Je suis débutant en C++ et d'un bon niveau en C++.

J'ai une librairie de traitement d'image en c normal qui au fur et à mesure devient affreuse car pour chaque nouveau type ajouté, je dois réecrire tous les opérateurs avec le nouveau type....et d'autres problèmes.
Je me suis dit pourquoi pas le C++???
C'est que j'essaye.
Etant débutant en C++, je ne suis pas très familier avec tous ses concepts. C'est pourquoi tu dois avoir surement raison dans ta critique.

Citation:

Je n'ai pas non plus compris pourquoi une solution pure template est a rejeter car ca me semble etre la meilleure solution au probleme que j'ai compris.

Le plus simple serait plutôt que j'expose ce que je veux faire conceptuellement. Puis des personnes éclairés dans le domaine comme toi Jean-Marc, me dise: dans ton cas: il faut utiliser pure template!!!!

Dans un long message juste avant, j'explique ce que je souhaîte faire.
Si tu veux m'aider ca serait cool et si tu as besoin de plus d'infos pas de probleme