Signaler

Réinitialisation d'un membre donnée d'une classe [Résolu]

Posez votre question pasletot 4Messages postés lundi 3 juillet 2017Date d'inscription 11 juillet 2017 Dernière intervention - Dernière réponse le 11 juil. 2017 à 20:30 par mamiemando
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
Utile
+0
plus moins
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() = 8
b.get_x() = 8
a.get_x() = 9
b.get_x() = 9


Bonne chance
Donnez votre avis
Utile
+0
plus moins
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..
Donnez votre avis
Utile
+0
plus moins
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.
Donnez votre avis
Utile
+0
plus moins
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
mamiemando 27935Messages postés jeudi 12 mai 2005Date d'inscription ModérateurStatut 12 septembre 2017 Dernière intervention - 11 juil. 2017 à 20:30
Ah ok ça me rassure, à un moment j'ai eu peur que tu parles de moi :-) Je me demandais ce que je pouvais avoir dit de vexant et je ne comprenais pas trop ! Les remarques désobligeantes m'affectent peu, mais c'est plutôt la crainte de blesser quelqu'un involontairement qui m'inquiète !

En tout cas j'espère que la communauté CCM te réservera un meilleur accueil. Si tu rencontres d'autres difficultés, n'hésite pas à me faire signe.
Répondre
Donnez votre avis

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !