C++

STL: conteneur hétérogène

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : STL: conteneur hétérogène

joek-mel

Je souhaite faire un conteneur hétérogène. Dans mon cas, il s'agit d'une pile.

Voic mes classes:

Code :

class cRoot; // classe vide
class cNumber: public cRoot; // un nombre
class cString: public cRoot; // un string

1ère tentative:

Code :

stack<cRoot *> s;
s.push(new cString("bonjour!" ));
s.push(new cNumber(3.1415926535));
s.top()->Disp(); s.pop();
s.top()->Disp(); s.pop();

Résultat:
3.1415926535bonjour!
ça marche. Seulement, il m'a fallu appeler l'opérateur new une fois par élément ajouté. Dans mon cas, c'est inacceptable.

2ème tentative:

Code :

stack<cRoot> s;
s.push(cString("bonjour!" ));
s.push(cNumber(3.1415926535));
s.top().Disp(); s.pop();
s.top().Disp(); s.pop();

Au début ça ne compilait pas. J'ai muni les classes cString et cNumber un constructeur de copie, ainsi que l'opérateur =.
À présent ça compile, mais ça ne fonctionne pas (Bleme).
Source exact (que vous pouvez tester):

Code :

#include <stack>
#include <iostream>
#include <string>
using namespace std;
class cRoot
{
public:
virtual void Disp() { cout<<"Bleme";};
};
class cNumber : public cRoot
{
public:
double n;
cNumber() { n=0; }
cNumber(double n_) { n=n_; }
cNumber(const cNumber &n_) { n=n_.n; }
cNumber & operator= (cNumber &n_)
{
n=n_.n;
return (*this);
}
void Disp() { cout<<n; }
};
class cString : public cRoot
{
public:
string str;
cString() { str=""; }
cString(string str_) { str=str_; }
cString(const cString &str_) { str=str_.str; }
cString & operator= (cString &s)
{
str=s.str;
return *this;
}
void Disp() { cout<<str; }
};
void main()
{
stack<cRoot> s;
s.push(cString("bonjour" ));
s.push(cNumber(3.1415926535));
(&s.top())->Disp(); s.pop();
(&s.top())->Disp(); s.pop();
puts("" );
}

Je me doute que les constructeurs bien de copie cNumber et cString ne sont même pas invoqués. Comment palier cela ?

Publicité

theShockWave

I work at a firm named Koslow

si tu veux du polymorphisme, tu es forcé de passer par des pointeurs ou des références ...

joek-mel

theShockWave a écrit :

si tu veux du polymorphisme, tu es forcé de passer par des pointeurs ou des références ...

Dans ce cas, je repose ma question différemment: est-il possible en C++ de faire appel à un constructeur, ou a un constructeur de copie sur un emplacement spécifique de la mémoire?

Exemple (qui ne marche pas systématiquement):

Code :

#define MAXSIZE 4096
class MyStack
{
public:
char *tmp;
int tmp_;
MyStack();
~MyStack();
void Push(cRoot *r); // empile physiquement l'objet
void Pop();
cRoot * Top();
};
MyStack::MyStack()
{
tmp=new char[MAXSIZE];
tmp_=MAXSIZE;
}
MyStack::~MyStack()
{
delete tmp;
}
void MyStack::Push(cRoot *r)
{
cRoot *t;
tmp_-=r->size();
t=(cRoot *)&tmp[tmp_]; //cast violent
(*t)=(*r); // je fais appel à l'opérateur=, ça ne marche pas systématiquement (par exemple avec STL string)
}
void MyStack::Pop()
{
cRoot *t;
t=(cRoot *)&tmp[tmp_];
tmp_+=t->size();
}
cRoot *MyStack::Top()
{
cRoot *t;
t=(cRoot *)&tmp[tmp_];
return t;
}
void main()
{
MyStack s;
s.Push(&cString("bonjour" ));
s.Push(&cNumber(3.1415926535));
s.Top()->Disp(); s.Pop();
s.Top()->Disp(); s.Pop();
}

C'est tordu, mais ça m'éviterait de faire des new.

Taz

bisounours-codeur

new (emplacement) T

après c'est toi qui te fous des limites à la con : j'aime bien le "c'est inacceptable" ... quand on voit la daube que tu veux utiliser en tentative de remplacement ... allez, commence par mettre des warnings à ton compilateurs et reviens jouer plus tard.

NB : c'est la pire daube que j'ai jamais vu, je sais pas comment tu oses dire que ça marche.

theShockWave

I work at a firm named Koslow

cRoot n'a pas la taille d'un char, donc déjà, quand tu stockes un CRoot à l'emplacement tmp[1], tu écrases une partie des données de tmp[0] (c'est typiquement ce qui se passe quand tu mets ton cNumber dans ta pile après avoir mis ta cString)
enfin bon, dans le principe, tu dois être forcé de faire des new pour allouer tes objets, oui. (évidemment, passer tmp au type cRoot ne résoudrait pas les problèmes puisque tu écraserais les portions des objets qui sont spécifiques aux classes cNumber et cString)

=> tu passes ton tmp en cRoot *, tu lui alloues la taille pour stocker tes 4096 pointeurs sur cRoot et tu passes des objets construits par new dans tes fonctions ... je pense que c'est ce qu'il y a de mieux à faire

Taz

bisounours-codeur

euh non, c'est pas pire, mais pas vraiment meilleur. c'est un problème insoluble. Soit tu fais du polymorphisme, ce qui est génial, soit tu maintiens 3 conteneurs pour tes 3 types, soit tu réécris un allocateur mémoire ce qui serait complètement stupide mais pourtant tu essaies d'en bricoler un.

theShockWave

I work at a firm named Koslow

Taz a écrit :

j'ai foiré ma double étoile .... Je voulais dire de passer tmp en " cRoot ** " (vu le reste de la phrase, c'est assez clair, remarque) ce qui revient à faire un conteneur et utiliser le polymorphisme.

(Edit : l'idée de l'allocateur m'avait traversé l'esprit, mais je ne suis pas encore assez à l'aise pour en parler :whistle: )

Message édité par theShockWave le 03-04-2005 à 19:05:55

Taz

bisounours-codeur

faudrait arrêter la branlette intellectuelle quand -- à ce que je vois, -- y a des bases niveau pointeurs qui sont manquantes.

Reprenons depuis le début.

Pourquoi 'inacceptable' ?

joek-mel

Taz a écrit :

faudrait arrêter la branlette intellectuelle quand -- à ce que je vois, -- y a des bases niveau pointeurs qui sont manquantes.

Reprenons depuis le début.

Pourquoi 'inacceptable' ?

Tout d'abord, t'es pas obligé de me pourrir la gueule lorsque tu réponds

Bon je raconte mon histoire.
J'ai réalisé une machine virtuelle. Ma pile<pRoot> (pRoot= smart pointer sur cRoot*) peut contenir des cString, cNumber, cFunction, cLValue etc... Le tout est 100% objet, malloqué en temps réel, et utilisant les smart pointer ainsi que les STL.
Seul problème: ça rame.

En regardant de plus près, je me suis aperçu que c'était essentiellement du à la fonction pop() de ma pile "système". En effet, push() et pop() utilisent directement ou non new et delete. Moralité: je fais en moyenne 1 à 2 new et 1 delete par cycle instruction. Je tourne à peu près à 50 000 cycle/s (en release) ce qui est très faible, même si mon Athlon 1.2 GHz commence à se faire vieux.

Je me suis dit qu'on pourrait gagner en vitesse en copiant physiquement les objets dans la pile. En effet, dans ce cas précis, pas besoin d'utiliser new et delete puisqu'on est capable de prévoir quand et où un objet doit être construit/détruit. Dans les autres cas, on peut continuer à utiliser new et delete, car ils sont beaucoup moins souvent utilisés.

Pour ceux qui ont déjà réalisé des moteurs en C, le problème ne se pose pas puisqu'on utilise des structures, et que push() et pop() peuvent s'écrire avec des macros du genre:

Code :

#define PUSH(valeur) (*pile++)=valeur
#define POP() (*--pile)

En revanche, en C , on se trimbale des struct {char type, union{ valeurs }} , des switch(type), et pleins d'autres trucs pas vraiment sexy.

Bref, j'avais vu que STL stack<> n'utilisait pas d'opérateur new et remplissait la pile en faisant des affectations (constructeur de copie). Je me suis dit que mon problème pouvait être résolu en utilisant le STL stack<>.

Apparemment je vais devoir gruger en utilisant explicitement le constructeur de copie (et le detructeur), sur l'emplacement mémoire de mon choix, en écrivant un truc du style (par exemple pour cString):

Code :

void CopyTo(cString *s, char *ptr)
{
((cString*)ptr)->cString::cString(*s);
}

TAZ: Je vais voir si new(emplacement)T va résoudre mon problème.
Merci quand même et promets d'être un peu plus poli la prochaine fois

Shockwave: C'est pour ça que j'incrémente en faisant tmp+=size() (size étant une fonction à moi retournant le sizeof de la classe courante).

Message édité par joek-mel le 03-04-2005 à 20:46:04

theShockWave

I work at a firm named Koslow

tu ne voudrais pas faire une méthode push template, plutôt ?

Edit : mouais, en fait, ca ne résoudrait pas tous les pbs ...

Message édité par theShockWave le 03-04-2005 à 20:51:28

Publicité

joek-mel

theShockWave a écrit :

tu ne voudrais pas faire une méthode push template, plutôt ?

Edit : mouais, en fait, ca ne résoudrait pas tous les pbs ...

Je sais pas encore comment je vais implémenter tout ça. Le void CopyTo est un exemple, mais bon, c'est pas très "classe" d'utiliser ça comme ça

De même qu'il faut que je regarde comment se comporte new(emplacement)T : si celui-ci ne fait qu'appeler le constructeur de copie sans chercher à allouer une seconde fois cet emplacement, alors ça peut être cool. Et inversement, si le delete associé ne se contente que d'appeler le destructeur sans chercher à libérer cet emplacement, alors ça peut être doublement cool

Vala.

TAZ: t'as autre chose à ajouter? (poliment )

Message édité par joek-mel le 03-04-2005 à 21:10:39

++fab

victime du syndrome IH

Si le bottle-neck est l'allocation / destruction (et que tu en es sur), peut etre peux tu envisager de manipuler l'allocateur standard directement.

Mais bon, Taz n'a pas tord, ton C++ est maladroit, et je ne suis pas convaincu qu'il n'y ait rien d'autre à optimiser que l'allocation.

theShockWave

I work at a firm named Koslow

ton void CopyTo me fait plus penser à un problème de conception qu'à autre chose, en fait.
Tu mets en place une interface pour manipuler tes variables empilables et au final, tu ne peux pas l'utiliser à 100%

Lam's

Profil: bas.

++fab a écrit :

Si le bottle-neck est l'allocation / destruction (et que tu en es sur), peut etre peux tu envisager de manipuler l'allocateur standard directement.

Dans ces cas là, Google est son ami.

Nan, pas Google le moteur de recherche: Google la société.
http://sourceforge.net/projects/goog-perftools/

Taz

bisounours-codeur

t'as le droit d'écrire un allocateur pour tes objets si tu trouves que ça rame. Ou de faire un cache (c'est à dire que plutot que de désallouer tes instances, tu en gardes quelques une sous la main). Genre trash stack.

Mais vu ton aisance avec les pointeurs, j'ai quand même bien envie de pencher pour un problème d'algorithmie ou de conception, en premier lieu.

Pour moi ton problème, c'est que tu veux jouer au warrior, sauf que ça prend pas. Tout problème peut se résoudre élégemment. Et avec de l'abstraction. Tu crois que le problème c'est l'allocation mémoire physique de tes objets, alors que c'est plus un problème de durée de vie.

(cString*)ptr)->cString::cString(*s);

je comprends même qpas ce que ça veut dire tellement c'est affreux.

new (ptr) cString(*s); c'est pourtant pas compliqué !

et puis je comprends ton obsession avec la pile. déjà que t'es entrain de nous montrer comment faire des pointeurs sur des variables temporaires ... La pile c'est plus rapide pour allouer, c'est tout. Une fois que tu as ton allocateur (même basé sur un pauvre vector) et ben ça fait la même performance à priori.

Il faudrait vraiment que tu apprennes un peu le C++, sinon ça va être un carnage vu tes notions sur les pointeurs et la POO en C++. Tu veux un exercice ? commence par écrire

template<typename T>
T** make(size_t d1, size_t d2);

qui alloue une matrice d1 x d2 de manière contigüe. C'est formatteur comme exercice.

Suis mon conseil : utilise un allocateur type pool (y en a chez boost) ou fais un petit cache.

Message édité par Taz le 04-04-2005 à 01:27:42

red faction

juste un petite question... la machine virtuelle est censée interpreter quoi ?

joek-mel

Taz a écrit :

red faction: ma machine virtuelle est de type lisp. Les mots clés sont codés par d'autres personnes, qui me fournissent des DLLs. Tout ça pour dire que mon programme est très court, est qu'il ne fait qu'empiler, dépiler, et appeler des fonctions compilées.

Taz, Lam's: Je veux éviter au maximum les 3rd parties. Car si je les utilise, la personne qui développe une DLL devra les utiliser aussi (puisqu'on partage les mêmes piles, donc les mêmes données).

Taz:

La différence entre ton new propre et mon constructeur de copie sale est que ton new propre impose d'écrire des opérateur new & delete au sein de la classe. C'est peut être ce que je devrais faire. Je regarde ça...
T'as déjà écrit un interpréteur?

Joel F

Real men use unique_ptr

joek-mel a écrit :

red faction:
Taz, Lam's: Je veux éviter au maximum les 3rd parties. Car si je les utilise, la personne qui développe une DLL devra les utiliser aussi (puisqu'on partage les mêmes piles, donc les mêmes données).

mouais enfin BOOST c'est du STL like hein ...

joek-mel a écrit :

red faction:

T'as déjà écrit un interpréteur?

Ouais en 15mn montre en main avec :
http://www.boost.org/libs/spirit/index.html

mais bon , c'est vrai c'est du Third Party [:everything4free] reinventez la roue c'est tellement plus hype [:joel f]

Taz

bisounours-codeur

joek-mel a écrit :

La différence entre ton new propre et mon constructeur de copie sale est que ton new propre impose d'écrire des opérateur new & delete au sein de la classe. C'est peut être ce que je devrais faire. Je regarde ça...
T'as déjà écrit un interpréteur?

1) non
2) oui

frenchkiss

gniarf gniarf

Code :

#include <stack>
#include <iostream>
#include <string>
using namespace std;
class cRoot
{
public:
cRoot* subthis; //arf
virtual void Disp() { //cout<<"Bleme";
subthis->Disp();};
void visit()
{
subthis->iamvisited();
}
virtual void iamvisited() { cout<< " visiting croot " <<endl;}
};
class cNumber : public cRoot
{
public:
double n;
cNumber() { n=0; subthis=this;}
cNumber(double n_) { n=n_; subthis=this;}
cNumber(const cNumber &n_) { n=n_.n; subthis=this;}
cNumber & operator= (cNumber &n_)
{
n=n_.n;
subthis=this;
return (*this);
}
void iamvisited() { cout<< " visiting cnumber " <<endl;}
void Disp() { cout<<n; }
};
class cString : public cRoot
{
public:
string str;
cString() { str=""; subthis=this;}
cString(string str_) { str=str_; subthis=this;}
cString(const cString &str_) { str=str_.str; subthis=this;}
cString & operator= (cString &s)
{
subthis=this;
str=s.str;
return *this;
}
void iamvisited() { cout<< " visiting cstring " <<endl;}
void Disp() { cout<<"string ["<<str<<"]"; }
};
void main()
{
stack<cRoot> s;
s.push(cString("bonjour" ));
s.push(cNumber(3.1415926535));
(&s.top())->Disp(); s.pop();
(&s.top())->Disp(); s.pop();
puts("" );
}

Taz

bisounours-codeur

je quitte se topic, j'ai jamais vu autant de bêtises en si peu de code.

frenchkiss

Moi je trouve ca rigolo. salut grognon.

frenchkiss

oh est puis quoi j ai rate le premier avril alors j'me ratrappe

blackgoddess

vive le troll !

:heink:

---------------
-( BlackGoddess )-

joek-mel

Taz a écrit :

je quitte se topic, j'ai jamais vu autant de bêtises en si peu de code.

Merci pour les conseils. Quant à moi, je crois que je vais retourner à l'école

Publicité

FORUM HardWare.fr

Programmation

C++

STL: conteneur hétérogène

Sujets relatifs
[STL] warning génants avec borland	Inserer une image dans un conteneur SWING
Ecrire un conteneur STL dans une mémoire partagée	[CSS] Positionnement flottant, hauteur du conteneur
N ème plus grand élément d'un conteneur sequentiel avec la STD lib	STL C++ mise à jour
[C++] STL list	Utilisation de la STL avec Compaq Visual
[C++] conteneur stl & éléments-objets "thread-safe"
Plus de sujets relatifs à : STL: conteneur hétérogène

Page générée en 0.109 secondes