réinitialisation d'un membre donnée d'une classe Résolu/Fermé

Question

Débutant C++ circonspect.

Hypothèse :  obtenir en retour de « a.foo() » et de « b.bar() » une seule valeur  de « m_x ».

Valeurs obtenues  en retour de a.foo() et de b.bar()   :    m_x = 55 ; et  m_x =88 .

Le programme sous forme condensée.

int main()
{
  A a(55);                     // m_x
  B b(88);                     // m_a
  a.foo();
  b.bar();
  return 0;
}

// Classe A                                      // attribut « int m_x ; »

A::A(int x): m_x(x)  {}                      // x = 55 d'origine dans Main
int A::foo() const {  return m_x; }

// Classe B                                          // attribut  « A m_a ; »

B::B(int z) : m_a(z)   {}                      // z = 88
int B::bar() const { return m_a.foo();}

Résultats partiels obtenus sur console .

A a ;                                      // Création objet  A
Constructeur de m_x ;          // oui
Valeur de « m_x » = 55 ;
Adresse de m_x et de « a »     0x28FF0C

B b ;                                       // Création objet  B
Constructeur de m_x ;           //   ??
Valeur de « m_x »  = 88
Adresse de m_x  et de « b »     0x28FF08
Constructeur de m_a
Adresse de m_a  dans B ::B()   0x28FF08

La réinitialisation de « m_x » sous forme de copie de « m_x » lors de l’appel de « B b » explique (pour moi) les résultats obtenus, y compris lorsque « m_x » est initialisé par int « m_x(int) » (retours de la même valeur).
Ce que je n’arrive pas à m’expliquer c’est l’appel du constructeur de « A » par « B b() » et la réinitialisation  d’une « m_x » à la valeur de « m_a ». ?

Pouvez-vous m’apporter les éléments utiles à ma compréhension ?

Merci

mamiemando · Answer

Bonjour,

Tes méthodes foo et bar retournent une recopie du m_x correspondant. Il faudrait dans ton cas utiliser des références ou des pointeurs.

#include <iostream>

struct A {
    int & m_x;

A(int x):m_x(x){}
    inline const int & get_x() const { return m_x; } 
    inline       int & get_x()       { return m_x; } 
};

struct B {
    int & m_x;

B(int x):m_x(x){}
    inline const int & get_x() const { return m_x; } 
    inline       int & get_x()       { return m_x; } 
};

int main() {
    int x = 7;
    A a(x);
    B b(x);

int & y = a.get_x();
    y = 8;
    std::cout << "a.get_x() = " << a.get_x() << std::endl
              << "b.get_x() = " << b.get_x() << std::endl;

int & z = b.get_x();
    z = 9;
    std::cout << "a.get_x() = " << a.get_x() << std::endl
              << "b.get_x() = " << b.get_x() << std::endl;

return 0;
}

Ce qui donne :

a.get_x() = 8b.get_x() = 8a.get_x() = 9b.get_x() = 9

Bonne chance

pasletot · Answer

Bonjour 

J’ai obtenu confirmation d’un intervenant plus enclin à répondre aux demandes d’aide qu’ à ânonner des préceptes et à postuler que celui qui demande aide n’y comprend rien. Merci à lui.

Je réédite mon exemple en partiel et adapté pour ceux qui prendraient connaissance du sujet :                                    
                                                    class A
                                                    {
                                                                A :: A(int x) : m_x(x)    {  }
                                                                int A::foo(){ return m_x; }
                                                     
                                                      private :
                                                                  int m_x ;
                                                      } ;

et                                                 class B
                                                    {
                                                         
                                                          B::B() : m_a(99)
                                                          int B::bar(){ return m_a.foo();}
                                                 	private :
                                                          A m_a ;
                                                        } ;
                                                     Main
                                                   {
                                                       A a(22);
                                                        B b;
                                                        a.foo();
                                                        b.bar();
 Résultats console:

Appel A a;
     Constructeur de A.
Appel B b;
    Constructeur de A            // là c’est clair
    Constructeur de B
Appel a.foo() ;
-----------------------
Résultats a.foo() = 22  et b.bar() = 99

Je laisse au lecteur éventuel le soin d’en tirer ses propres conclusions.

Pour ma part je retiens l’appel d’emblée du constructeur de « A » par « B », et dans les conditions énoncées, que les retours d’ accès à un même  membre donnée peuvent être différents de la valeur effective de ce membre.

Merci encore, pour moi ce sujet est clos, je retourne à mon étude laborieuse personnelle, sans prétention mais pas sans intérêt..

mamiemando · Answer

Disons que la réponse qu'il t'a proposée est sensiblement différente, personnellement je n'avais pas compris la questions comme ça.

- Dans la question de départ je pensé que A et B devaient référencer un même m_x. N'ayant pas la déclaration de la classe B dans ton message initial c'était la manière dont j'avais compris ta question, même si le fait que B stocke un membre m_a aurait dû me mettre la puce à l'oreille.
- Dans la réponse de ton intervenant, tu stockes m_x dans A, et tu imbriques un A dans un B.

Merci en tout cas pour ton retour.

pasletot · Answer

Bonjour mamiemando

Pas de souci, inutile de te justifier. Je n'ai pas pour ambition de devenir programmeur. Si je me fie à ton pseudo tu devrais être en mesure d'approcher la raison qui m'incite à aborder un langage de programmation. C'est un sujet qui peut être bénéfique.
 Le fait que sur un certain site, connu pour enseigner des langages de programmation, les intervenants se comportent comme des intégristes du C++, ce qui semble abolir chez eux la moindre capacité à appréhender une question posée et les inciter même à nier des résultats, n'enlève rien à la qualité sincère et instructive de ton intervention. 
Ce que je cherchais c'était la confirmation de ce que je constatais. Ce n'est pas la première fois que je me heurte à l'opinion de spécialistes(?) imbus d'eux mêmes, convaincus que leur spécialisation leur donne droit de généraliser et de considérer que ceux qui ne partagent pas n'y entendent rien.
Encore merci

Réinitialisation d'un membre donnée d'une classe

4 réponses

Discussions similaires