C++ , relations entre classes
Bonjour voila ,
On a un projet a faire ... nous avons bloqué sur quelque chose , " l'agrégation " entre le main ( ) et une autre classe ...
"L'autre classe" appellée A est celle qui a instancier l'objet de la classe B
.h de A
Code:
1
2
3
4
| class A
{
B *ObjetDeB;
}; |
.h de B
Code:
1
2
3
4
5
| class B
{
public :
void loooool ( ) ;
}; |
dans le cpp de A
Code:
1
2
3
4
| A::A() // Constructeur
{
ObjetDeB = new B ;
} |
Code:
1
2
3
4
| B A :: getmonB() // getter de l'attribut
{
return *ObjetDeB ;
} |
main () :
Code:
1
2
3
4
5
6
7
8
9
10
| int main()
{
A MonA ;
B *MonB ;
*MonB = MonA.getmonB() ;
MonB->loooool();
return 0 ;
} |
Pouvez me dire , si ce qui est au dessus est correct ? Merci davance
En fait , ce que nous recherchons a faire , cest de pouvoir utiliser l'instance de B crée par A via son adresse dans le main ( )
Cordialement
shared_ptr, allocations dynamiques et pédagogie
Disclaimer: Ami débutant en C++, tous les exemples de code de ce message sont faux, archi-faux. Ne viens pas me dire que tu n'étais pas prévenu.
Citation:
Envoyé par
bdeuu
Et il est préférable d'utiliser assez rapidement les auto_ptr et les shared_ptr qui permettent d'alléger la gestion de l'allocation dynamique de mémoire
Oui, mais pas trop vite : j'ai observé (ici) que certains commencent à utiliser shared_ptr avant d'avoir compris ce qu'est l'allocation dynamique, d'où des horreurs du type :
Code:
1
2
3
| shared_ptr<A> p;
A a;
p.reset (&a); |
Le problème, AMA, est que shared_ptr est présenté comme la baguette magique qui fait qu'on n'a plus à s'embêter à comprendre l'allocation dynamique, et comme un GC intégré au langage (comme si avec les smart pointers C++ devenait Java); alors qu'au contraire, je ne vois pas comment on peut comprendre shared_ptr sans comprendre l'usage correct de delete.
Le discours : "laisser les shared_ptr gérer les désallocations tous seuls" peut, mal interprété, devenir "je n'ai plus à besoin de comprendre comment ça marche", et conduire à :
Code:
1
2
3
| shared_ptr<A> p, q;
p = blah blah;
q.reset (q.get ()); |
Comme quoi, l'absence de conversion implicite (A* -> shared_ptr<A> et shared_ptr<A> -> A*) n'effraie pas certains : ils invoquent plusieurs fonctions membres nommée, pour "convertir" shared_ptr<A> en A* en shared_ptr<A>. (Si ils voulaient "convertir" un A en B, et que la seule fonction qui renvoie un B et prennent A s'appelle A::I_want_to_get_a_B_and_then_die_an_horrible_death(), ils feraient b = a.I_want_to_get_a_B_and_then_die_an_horrible_death(). :evilred:)
