Discussion :

[Panaméen]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
class A
{
     B *ObjetDeB;
};

.h de B

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class B
{
     public :
                 void loooool ( ) ;
};

dans le cpp de A

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
A::A()  // Constructeur
{
    ObjetDeB = new B ; 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
B A :: getmonB()    // getter de l'attribut
{
    return *ObjetDeB ;
}

main () :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Matthieu Brucher]

Déjà au niveau des types, ce n'est pas bon. Tu retournes une copie du B interne et tu le mets dans un B*, ça ne peut pas fonctionner...

[Panaméen]

Ca ne peut pas fonctionner , pourtant ca fonctionne ...
Que faire alors ?

[Matthieu Brucher]

Retourner le pointeur directement (B*), et non un B, et ça marchera.

[Panaméen]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
B A :: getmonB()    // getter de l'attribut
{
    return *ObjetDeB ;
}

je retourne pas le pointeur directement là ?

[Matthieu Brucher]

Ben non, tu retournes une nouvelle instance de B par valeur, c'est juste une copie de l'objet pointé par ObjetDeB.

[Panaméen]

Si je retourne pas un pointeur , ca compile pas , cest pour ca que jlai mi sans trop comprendre.

Jvois pas quoi faire si ca marche pas sans le pointeur.

[nikko34]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
B A :: getmonB()    // getter de l'attribut
{
    return *ObjetDeB ;
}

je retourne pas le pointeur directement là ?

non, tu renvoies une copie B.

si tu veux renvoyer ton pointeur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
B* A::getmonB()
{
    return ObjetDeb;
}
 
int main()
{
    //...
    MonB = MonA.getmonB();
}

MAIS

si A crée l'objet B dans son constructeur et le détruit dans son destructeur ( à ne pas oublier... ), pourquoi en faire un pointeur?

tu peux faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
class A
{
    B ObjetDeB;
};

( construction et destruction automatique, tu n'as pas à faire de new ou de delete )

et renvoyer une référence (&) sur ton objet ( pas un pointeur ):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
B & getMonB()
{
    return ObjetDeB;
}

et l'utiliser comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
int main()
{
    monA.getMonB().looool();
 
    // ou alors:
 
    B & monB = monA.getMonB();
    monB.looool();
 
    return 0;
}

En C++ le concept de références est important ( plus que celui de pointeur pour débuter ) .

Effectivement, quand on a pas encore bien compris les pointeurs et qu'on rajoute par dessus les références, je conçois bien ça ne doit pas être clair du tout ce que je raconte.

[Panaméen]

non, tu renvoies une copie B.

si tu veux renvoyer ton pointeur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
B* A::getmonB()
{
    return ObjetDeb;
}
 
int main()
{
    //...
    MonB = MonA.gettonB();
}

MAIS

si A crée l'objet B dans son constructeur et le détruit dans son destructeur ( à ne pas oublier... ), pourquoi en faire un pointeur?

tu peux faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
class A
{
    B ObjetDeB;
};

( construction et destruction automatique, tu n'as pas à faire de new ou de delete )

et renvoyer une référence (&) sur ton objet ( pas un pointeur ):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
B & getMonB()
{
    return ObjetDeB;
}

et l'utiliser comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
int main()
{
    monA.getMonB().looool();
 
    // ou alors:
 
    B & monB = monA.getMonB();
    monB.looool();
 
    return 0;
}

En C++ le concept de références est important ( plus que celui de pointeur pour débuter ) .

Effectivement, quand on a pas encore bien compris les pointeurs et qu'on rajoute par dessus les références, je conçois bien ça ne doit pas être clair du tout ce que je raconte.

Oui cest vrai pourquoi utiliser un pointeur .... ? bonne question ....
Là avec un pointeur et un new on cré dans la pile alors quavec lautre facon on crée dans le tas , cest ca ?

Jai preferé opter pour le 1er mais bon ... Vous trouvez ca nul ? ( vous pouvez le dir si ca l'est ? )

Pointeur et référence .... ouai pas evident au debut ....

jai pas compris 1eremment , pourquoi tu fais dans le 1er cas ,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
B* A::getmonB()
{
    return ObjetDeb;
}

puis le 2eme cas , construction et destruction auto, là n'en parlons pas , cest la 1ere fois que je vois ça

Si ca te derange pas d'expliquer plus en detail ...

Merci

[Matthieu Brucher]

Je te conseille de lire un cours de C++ http://bruce-eckel.developpez.com/livres/cpp/ticpp/v1/ (la version française arrivera sous peu )

[[Hugo]]

La version française est dispo : http://bruce-eckel.developpez.com/livres/cpp/ticpp/

[Panaméen]

Bon jai feuilleté ce livre , assez dur a lire surtout en pdf , bref passons ,
ca ne m'a pas plus avancé dans la comprehension de l'explication donnée par nikko34

merci pour vos liens , mais ça n'a pas eclairé mon pb exposé ci dessus

[nikko34]

Bon jai feuilleté ce livre , assez dur a lire surtout en pdf , bref passons ,
ca ne m'a pas plus avancé dans la comprehension de l'explication donnée par nikko34

merci pour vos liens , mais ça n'a pas eclairé mon pb exposé ci dessus

J'imagine que tu connais les différents types de passage de paramètre des fonctions? Par valeur et par référence.

Par valeur c'est une copie du paramètre.
Par référence tu modifies le paramètre.

En C++, ça se traduit comme ça:

passage par valeur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
void maFonction( A objetA )
{
    objetA.qqchose();
}
 
int main()
{
    A objetA;
    maFunction( objetA );
}

Dans la fonction maFunction on travaille sur une copie de objetA.

Maintenant le passage par référence:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void maFonction( A & objetA )
{
    objetA.qqchose();
}

int main()
{
    A objetA;
    maFunction( objetA );

    return 0;
}

Cette fois ci, on travaille directement sur l'objet A définit dans le main, il n'y a pas de copie.

Généralement, on passe les objets par référence parce qu'une copie peut être lourde ( imagine si tu passes une image en paramètre, tu n'as peut être pas envie de faire une copie à chaque appel de fonction ).

Pour les type de base ( ou POD pour Plain Old Data: int, float, double, char...) on utilise le passage par valeur parce que la copie de ces types n'est pas un problème, au contraire.

Maintenant tu vas me dire, et si je ne veux pas que mon objet soit modifié par la fonction mais que je veux éviter de faire une copie?

Là rentre en compte le mot-clé qualificateur "const". Const indique que l'objet passé en paramètre ne sera pas modifié. (lecture seule )
Mais il faut quand même pouvoir appeller les méthodes de cet objet.
C'est au programmeur créateur de la classe d'indiquer quelles méthodes ne modifient pas l'objet et peuvent être appellé dans ce cas: on rajoute le mot-clé const à la fin de la méthode.

exemple:

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 A
{
public:
    void qqchose() const 
    { 
        std::cout << "qq chose" << std::endl; 
    }
};

void maFonction( const A & objetA )
{
    objetA.qqchose();
}

int main()
{
    A objetA;
    maFonction( objetA );

    return 0;
}

Et pour les valeurs de retour des méthodes/fonctions, cela marche exactement de la même façon:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
A maFonction(); // renvoie une copie de A
A & maFonction(); // renvoie une référence
const A & maFonction(); // renvoie une référence non modifiable

Tu peux t'en servir de cette façon:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class A
{
public:
 
    const B & getMonB() const
    {
         return this->objetB_;
    }
 
private:
 
    B objetB_;
};

"const" peut donc apparaitre 3 fois dans une méthode avec un sens différent:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
const B & A::getB( const C & c ) const;

Si tu veux un exemple plus concret, on peut utiliser par exemple une classe Eleve qui a deux attributs, son nom utilisant un objet std::string et son age utilisant un int.

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
#include <string>
#include <iostream>
 
class Eleve
{
public:
    void setNom( const std::string & nom )
    { 
        nom_ = nom; 
    }
 
    void setAge( int age )
    { 
        age_ = age; 
    }
 
    const std::string & getNom() const
    {
        return this->nom_;
    }
 
    int getAge() const
    {
        return this->age_;
    }
private:
 
    std::string nom_;
    int age_;
};
 
void afficheEleve( const Eleve & eleve )
{
    std::cout << eleve.getNom() << "  " << eleve.getAge() << std::endl;
}
 
int main()
{
    Eleve toto;
    toto.setNom( "toto" );
    toto.setAge( 3 );
 
    afficheEleve( toto );
}

Tu as pu le remarquer, il n'y a pas de pointeurs dans cet exemple. Pourtant std::string est un objet ( comme le B dans ton programme ). Il est créé automatiquement par Eleve et détruit quand Eleve est détruit.

Maintenant, si tu veux appeller un constructeur de ton objet std::string lors de la construction de l'objet Eleve et initialiser ses attributs, tu peux rajouter un constructeur à Eleve:

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
class Eleve
{
public:
    Eleve( const std::string & nom, int age )
    : nom_( nom ),  // appel au constructeur de std::string
      age_( age )    // initialisation de variable
    {}
 
    const std::string & getNom() const
    {
        return this->nom_;
    }
private:
   std::string nom_;
   int age_;
};
 
int main()
{
    Eleve toto( "toto", 3 );
 
    // tu peux créer une variable de type référence où bon te semble
    // ( en tant qu'attribut de classe aussi )
    // par contre elle doit obligatoirement réferencer quelque chose
    // ( ce n'est pas un pointeur qui peut pointer sur NULL )
    // et bien sûr tu peux décider si elle est const ou non
    const std::string & nom = toto.getNom(); // ça marche
    std::cout << nom << std::endl;
 
    std::cout << toto.getNom() << std::endl; // ça marche aussi
 
    std::string copieNom = toto.getNom(); // ça marche mais c'est une copie
    copieNom = "tata";
 
    std::string & refNom = toto.getNom(); // ça compile pas, je pourrais modifier refNom
    return 0;
}

d'ailleurs, dans le premier exemple, il aurait été judicieux d'initialiser l'âge à 0 dans le constructeur par défaut d'Eleve:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
class Eleve
{
   Eleve()
   : age_( 0 )
   {}
};

mais pourquoi ne pas faire la même chose pour nom_? Simplement parce que si l'objet possède un constructeur par défaut, il sera automatiquement appellé. On est donc sûr que le nom étant un std::string, il est construit correctement ( une chaîne vide ). "int" n'étant pas un objet, il faut l'initialiser.


Et pourquoi je raconte tout ça déjà?
Oui c'est pour expliquer qu'il faut être clair dans sa tête et savoir quelle classe est responsable de la création/destruction d'une autre.

Tu peux utiliser des pointeurs et faire des new et des delete où bon te semble, dans deux classes différentes par exemple. Mais c'est vouloir se tirer une balle dans le pied parce qu'après tu ne sais plus où tu en es.

Avec ce système de création/destruction automatique plus le renvoie de référence modifiables ou non modifiables, tu peux clairement exprimer dans ton code que telle classe appartient à celle là, que c'est donc celle là qui la construit et qui en est responsable. Et telle classe peut décider d'exposer un de ces attributs mais peut aussi décider qu'il n'est qu'en lecture seule.


Pour bien comprendre ce mécanisme, tu peux t'amuser à mettre des traces dans les constructeurs/destructeurs de tes classes.

par exemple:

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
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
#include <iostream>
#include <string>
 
class B
{
public:
    //constructeur
    B( int id )
    : id_( id )
    {
        std::cout << "B " << id_ << " construit" << std::endl; 
    }
 
    //destructeur
    ~B()
    {
        std::cout << "B " << id_ << " detruit" << std::endl;
    }
private:
    int id_;
};
 
class A
{
public:
 
    //constructeur
    A( int id )
    : id_( id ),
      b_( id )
    {
        std::cout << "A " << id_ << " construit" << std::endl; 
    }
 
    //destructeur
    ~A()
    {
        std::cout << "A " << id_ << " detruit" << std::endl;
    }
 
    // constructeur particulier dit "de copie"
    // dans la plupart des cas peut être créé automatiquement si les 
    // attributs de la classe ont un mécanisme de copie.
    // ici on en crée un nouveau pour cet exemple qui ne fait pas vraiment
    // de copie mais met les id à -1
    A( const A & a )
    : id_( -1 ),
      b_( -1 )
    {
        std::cout << "A " << id_ << " copie" << std::endl;
    }
private:
    int id_;
    B b_;
};
 
void functionCopie( A a )
{
    std::cout << "copie de a" << std::endl;
}
 
void functionRef( A & a )
{
    std::cout << "pas de copie" << std::endl;
}
 
int main()
{
    A a( 3 );
 
    functionCopie( a );
    functionRef( a );
    return 0;
}

[Panaméen]

Ok !!! Merci pour cette explication du passage par référence en C++ , qui nest pas evidente du tout , nous connaissions juste le passage par adresse ou par référence mais en C , ce qui est différent.

Voila , jai un autre petit souci , ...

Comment savoir , comment on doit instancier ou tel ou tel objet ? ( par un new , donc un delete pour la destruction , ou creation et destruction auto )

c'est une question , a laquelle je narrive pas a metre de reponse

Merchiii

[nikko34]

je dirais:

par défaut sans pointeur

[Matthieu Brucher]

Ca dépend complètement de ce qui doit être fait. La meilleure solution est d'acquérir de l'expérience pour trouver soi-même le meilleur choix.
En revanche, je te conseille tout de même de lire un ouvrage dédié au C++ pour avoir plus de recul.

[babar63]

Bon jai feuilleté ce livre , assez dur a lire surtout en pdf

C'est vrai que la version PDF est assez difficile... (Sans vouloir offenser personnes) Par contre la version anglaise est plutôt sympathique et si vraiment tu ne supporte pas l'anglais , le "méga-cours" est assez complet http://cpp.developpez.com/cours/

[bdeuu]

Ca dépend complètement de ce qui doit être fait. La meilleure solution est d'acquérir de l'expérience pour trouver soi-même le meilleur choix.

Si tu peux me donner un exemple ou l'allocation dynamique est preferable a l'allocation dans la pile, franchement tu as toute mon admiration.

[screetch]

lorsque l'instance doit être partagée.... ce n'est pas le meme but, entre une allocation sur la pile et une allocation dynamique.

[corrector]

Ca ne peut pas fonctionner , pourtant ca fonctionne ...
Que faire alors ?

Commencer par apprendre le B-A-BA de l'usage des pointeurs avant d'essayer d'écrire des programmes avec des pointeurs.

Ne pas compiler avant d'avoir compris.

Tester son programme pour vérifier qu'on a compris.