Discussion :

[TomXX]

Hello,

je cherche a avoir un peu d'eclaircissement sur ces 2 notions car c'est un peu flou ds ma tete pour le moment .

Si qq'un peut m'apporter des precisions (a l'aide d'examples) ou m'orienter vers un lien qui pourrait m'etre utile je l'en remercie d'avance .

[bigboomshakala]

Salut,

- un wrapper, c'est une chose qui en enveloppe une autre pour que cette dernière puisse être utilisée dans un certain contexte.

ex : une classe Entier, qui sert à stocker une valeur 'int' est un wrapper. ça "enveloppe" une variable de type int.

- un container, ça sert à contenir (bon ok, bidon comme définition)

ex : std::vector<int> contient des int.

La différence c'est qu'on container est fait pour contenir plusieurs variables d'un certain type qui seront utilisées dans un prog comme étant de ce type, alors qu'un wrapper permet d'envelopper une variable.

Cela dit moi et les définitions claires on est pas toujours potes, alors une bonne alternatives c'est

WRAPPER : programme « enveloppant » l'exécution d'un autre programme, pour lui préparer un environnement particulier. Utilisé par exemple pour sécuriser le fonctionnement de certaines applications en contrôlant très précisément leur interface avec le reste de l'univers connu.

Enjoy yourself !

[TomXX]

Merci,

j'avais fait des recherches sur Google (pendant un peu pres 3h ) ., et ce que j'ai trouve etait soit assez vague , soit lie a un progamme monstrueux .

J'ai donc essaye ici pour avoir une idee plus clair .

Je vais prendre le contexte ds lequel je me trouve afin d'etre plus precis :

J'ai une classe A et ses derivees A1,A2,...

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
 
class A
{
    public:
    virtual double func(double x) const=0; //donc A est abstraite
    virtual A* clone() const=0;//pour cloner
    ...
}
 
class A1 : public A
{
    ...
    virtual double func(double x); 
    virtual A* clone() 
    ...
}
...

Maintenant, disons que je veux garder dans une classe B un objet de type A . Pour ce faire je vais definir :

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
 
class Wrapper_A
{
   private :
   A* myA
   public :
   ....//constructeur de recopie,destructeur,surdefinition de operator * pour
       //renvoyer myA
}
 
// ensuite je peux declarer B ainsi:
 
class B
{
    Wrapper_ A  Inner
    ....
}

La classe Wrapper_A que j'ai defini est bien un wrapper ? Quel est l'interet de la methode que j'ai utiliser ci dessus et y'a t'il d'autres applications ?

Je suis pas sur d'avoir ete super clair mais si qq'un pense pouvoir m'aider thanks .

[TomXX]

SVP qq'un peut il m'eclairer?

[Aurelien.Regat-Barrel]

Pourquoi tu mets pas directement un A dans ton B ?
Pour moi ta classe Wrapper_A fait plutot office de proxy. Généralement, un wrapper sert à utiliser un bout de soft d'un langage donné dans un autre. Donc wrapper du C++ en C++, c'est un peu un non sens. Typiquement, une bibliothèque écrite en C aura son wrapper C++. Une traduction de wrapper que j'affectionne est surcouche. C'est pour ça que surcouche C++ à une bibliothèque C++ ça fait bizarre...
Pour le container : http://c.developpez.com/faq/cpp/?page=STL#STL_container

[TomXX]

En fait , je peux deja pas mettre un membre de type A dans B car ma classe A est abstraite, donc ca compilerai pas . Et puis je vais pas mettre une reference sur A (A&) car je veux que B contienne sa propre version de A et pas que ca depende de l'exterieur (donc pas de reference) .

De plus B ne "doit pas savoir" de quel type est A , ca peut etre n'importe quel derives de A.

Je vais donc mettre un pointeur sur A en tant que membre de B . (et l'initialiser ds le constucteur en clonant l'objet pris en argument , pour avoir ma propre version)

Comme B contient un membre dynamique maintenant (A* MyAPtr) , je vais donc devoir definir un construteur de recopie, un destructeur, et une redefinition de l'operateur = .

Mais si maintenant je sais que + tard je vais avoir a definir d'autres classes comportant un pointeur sur A . Je vais etre oblige a chaque fois de redefinir un operateur =, un constructeur de copie,....

Je definis donc la classe Wrapper_A (defini + haut) qui contient un pointeur sur A et qui s'occupe de toutes ses taches .

Et donc a chaque fois que j'ai besoin d'une classe avec un membre polymorhique de type A, je met a la place un membre Wrapper_A et j'ai + besoin de reecrire tt le temps un constructeur de recopie,etc...
Je pourrais traiter Wrapper_A comme un objet normal

Est ce que ca fait sens ou je me complique la vie pour rien?Je croyais que c'etait un procede plutot standard en language objet (qd on a en esprit de faire un code reutilisable)? Merci a celui qui pourra me donner un avis sur ce que je viens de decrire !

Et c'est pourquoi je cherchais aussi a savoir si il y avait d'autres usages (interne au C++ et pas d'un language a un autre) pour les wrapper .

NB : en fait ce que j'ai decrit ci dessus serait encore + utile si je faisais une class template wrapper selon le type de l'objet membre

[Laurent Gomila]

Ton idée a du sens oui, cela s'appelle un pointeur intelligent. Il existe beaucoup de déclinaisons des pointeurs intelligents, et effectivement mieux vaut les utiliser autant que possible, pour la raison que tu as citée et pour plein d'autres.

La FAQ C++ en parle je crois, ainsi que pas mal de sujets sur ce forum, que tu pourras trouver avec la recherche avancée.

Le must en matière de pointeur intelligent (au niveau réutilisabilité et flexibilité) c'est un pointeur intelligent à base de polices comme ceux décrits par Andrei Alexandrescu, et utilisés dans la bibliothèque Loki.
J'en parle également vite fait dans mes tutoriels.
Ce genre de classe te permettrait d'obtenir ton Wrapper_A en réecrivant seulement ce qui est specifique à tes pointeurs (ie. l'appel à Clone() pour recopier le pointeur), sans recoder de A à Z les mecanismes des pointeurs intelligents.

Je ne suis pas un pro de la terminologie, mais je pense que les pointeurs intelligents sont bien un exemple typique de wrappers ?

[Aurelien.Regat-Barrel]

Si j'ai bien compris tu veux pouvoir ajouter une sémantique de valeur à un objet manipulé par pointeur (c'est à dire que la copie de pointeur implique un clonage).
J'aurais plutot vu ça dans B::Clone() qui au passage fait un A::Clone() de ses A. Tu veux simplifier le boulot via une classe proxy si j'ai bien compris.
C'est proche des smart pointers, sauf que au lieu de gérer un partage de la même ressource toi tu veux dupliquer la ressource a chaque copie. Donc un template oui c'est mieux. Cela dit je me demande si c'est pas moyen de mélanger objets clonables et non clonables.

[TomXX]

Merci bcp . J'avais un vague souvenir du nom Pointeurs intelligent (ou Smart Pointer) ss vraiment savoir ce que c'etait ; et tu as raison c'est effectivement ce que j'ai decrit (en regle general d'apres les recherches que je viens de faire) .

Qd tu dis qu'il faut les utiliser le + souvent possible pour les raisons que j'ai cites et pour plein d'autres ; peux tu me donner une idee de ces autres raisons ?

[Laurent Gomila]

Quelques bonnes lectures :

http://c.developpez.com/faq/cpp/?pag...S_intelligents
http://loulou.developpez.com/tutorie...artie4/#L2.1.2
http://loulou.developpez.com/tutorie.../partie1/#L3.3
http://www.informit.com/articles/article.asp?p=31529

[TomXX]

Desole j'avais pas encore vu le message d'Aurelien qd j'ai ecrit le precedent qui s'adressait a Loulou24 .
Donc vis a vis du message d'Aurelien cette fois :

En fait je n'ai pas de methode clone ds B . Je fais seulement appel a la methode clone de A ds le constructeur de B (qui prend en argument une reference sur un objet de type A .
Donc je comprend pas tres bien ce que tu entends par melanger objet clonables et non clonables .

[Aurelien.Regat-Barrel]

Pour dupliquer des A tu utilises A::Clone().
Pour dupliquer des B tu utilises le constructeur de recopie.
B contient un A qu'il clone dans son constructeur de recopie (si j'ai bien compris).
C'est ça que j'appelle mélanger. Je me demande si c'est pas moyen comme design, dans la mesure où c'est hétérogène (un coup on manipule par pointeur, un coup par valeur).
Note que les pointeurs intelligents ne font pas de Clone(). Si tu recopie un B qui a un pointeur intelligent sur a1, les 2 partageront le même a1...

[TomXX]

Pour etre + precis , dans ma classe B (qui pourrait etre template selon A), il y aurait entre autre :

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
 
class B
{  
   private :
     A* PtrA
 
   public :
   B(const A& inner) //CONSTRUCTEUR
   {  PtrA = inner.clone(); }
 
   B(const B& original) //CONSTRUCTEUR DE RECOPIE
   { if (original.PtrA != 0)
          PtrA = original.PtrA -> clone();
      else PtrA = 0;
   }
   ~B() // DESTRUCTEUR
   { if (PtrA != 0)
      delete PtrA;
   }
...
...
}

Donc B est responsable de l'objet pointe (vis a vis de la gestion memoire) et est detenteur de l'objet pointé a tout moment.
Si on copie B, l'objet pointe est aussi copié, et donc tout objet B a sa propre copie de l'objet pointé .

Qu'est ce qui te convient pas trop ds ce code? Merci d'avance .

[Laurent Gomila]

Note que les pointeurs intelligents ne font pas de Clone(). Si tu recopie un B qui a un pointeur intelligent sur a1, les 2 partageront le même a1...

"Pointeur intelligent" n'est qu'un concept, après libre à nous (ou aux autres d'ailleurs) d'y mettre ce qu'il faut pour gérer correctement le type de ressource concernée, qui ne sera pas forcément un pointeur brut (comme dirait Luc, ça pourrait très bien être des pots de peinture). Le comptage de référence n'est pas systématique non plus. Comme je l'expliquais plus haut, le mieux est sans doute une classe parametrable (via les templates), ainsi on n'a a réécrire que ce qui nous interesse.

Qu'est ce qui te convient pas trop ds ce code? Merci d'avance

Quelques broutilles : le test PtrA != 0 est inutile avant un delete, et il manque l'opérateur d'affectation. A part ça, ça me parait "normal"
B sera ta classe de pointeurs intelligents pour A ?