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
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();}
[...]
Pouvez-vous m’apporter des éléments de réponse sur la raison pour laquelle « B b
» appelle le constructeur de « A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
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
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();}
[...]
Pouvez-vous m’apporter des éléments de réponse sur la raison pour laquelle « B b
» appelle le constructeur de « A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
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
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();}
[...]
Pouvez-vous m’apporter des éléments de réponse sur la raison pour laquelle « B b
» appelle le constructeur de « A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Bonjour,Bonjour Olivier
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
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).
Par contre l’appel du constructeur de « A » par « B b()
» et la réinitialisation d’une « m_x » à
la valeur de « m_a » me désorientent.
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Merci
Bonjour,Bonjour Olivier
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
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).
Par contre l’appel du constructeur de « A » par « B b()
» et la réinitialisation d’une « m_x » à
la valeur de « m_a » me désorientent.
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Merci
Merci pour tes explications. Pour les concrétiser et comprendre comment le
programme se déroule pour en arriver à ces résultats j’ai utilisé ce que
j’appelle des balises à savoir l’instruction « cout » pour visualiser sur
console comment s’exécute le programme.
Dans le Main chaque ligne est précédée d’un « cout » annonciateur de la ligne à
venir, et dans chacun des constructeurs, ils affichent le nom du constructeur et
les adresses respectives de « m_x » et de « m_a ».(&)
Ce mode opératoire m’a permis de comprendre pourquoi les résultats différent
lorsque « m_x » et « m_a » sont initialisées par paramètres, comme ici, et
pourquoi ils sont identiques lorsque « m_x » est initialisée sous la forme «
m_x(55) ».
Par contre je ne m’explique pas pourquoi « B b » appelle le constructeur de « A
» avant même d’appeler celui de « B », ce qui a pour effet de donner à une « m_x
» une autre adresse que celle d’origine , adresse qui s’avère par la suite être
celle de « m_a ».(vérifiée lorsque « m_a » est initialisée par son constructeur)
et par suite d’être initialisée à la valeur de « m_a ».
Dans l’exemple tel que ci-dessus, tout se passe comme si le programme créait
sous l’identité « m_x » , une copie de « m_a », disons « m_x1 », sans
modification de la valeur d’initialisation d’origine de « m_x », d’où les
résultats.
Si tu pouvais éclairer ma lanterne sur cet appel du constructeur de « A » par «
B », tu ferais d’un débutant perplexe un débutant assuré
Merci pour tes explications. Pour les concrétiser et comprendre comment le
programme se déroule pour en arriver à ces résultats j’ai utilisé ce que
j’appelle des balises à savoir l’instruction « cout » pour visualiser sur
console comment s’exécute le programme.
Dans le Main chaque ligne est précédée d’un « cout » annonciateur de la ligne à
venir, et dans chacun des constructeurs, ils affichent le nom du constructeur et
les adresses respectives de « m_x » et de « m_a ».(&)
Ce mode opératoire m’a permis de comprendre pourquoi les résultats différent
lorsque « m_x » et « m_a » sont initialisées par paramètres, comme ici, et
pourquoi ils sont identiques lorsque « m_x » est initialisée sous la forme «
m_x(55) ».
Par contre je ne m’explique pas pourquoi « B b » appelle le constructeur de « A
» avant même d’appeler celui de « B », ce qui a pour effet de donner à une « m_x
» une autre adresse que celle d’origine , adresse qui s’avère par la suite être
celle de « m_a ».(vérifiée lorsque « m_a » est initialisée par son constructeur)
et par suite d’être initialisée à la valeur de « m_a ».
Dans l’exemple tel que ci-dessus, tout se passe comme si le programme créait
sous l’identité « m_x » , une copie de « m_a », disons « m_x1 », sans
modification de la valeur d’initialisation d’origine de « m_x », d’où les
résultats.
Si tu pouvais éclairer ma lanterne sur cet appel du constructeur de « A » par «
B », tu ferais d’un débutant perplexe un débutant assuré
Merci pour tes explications. Pour les concrétiser et comprendre comment le
programme se déroule pour en arriver à ces résultats j’ai utilisé ce que
j’appelle des balises à savoir l’instruction « cout » pour visualiser sur
console comment s’exécute le programme.
Dans le Main chaque ligne est précédée d’un « cout » annonciateur de la ligne à
venir, et dans chacun des constructeurs, ils affichent le nom du constructeur et
les adresses respectives de « m_x » et de « m_a ».(&)
Ce mode opératoire m’a permis de comprendre pourquoi les résultats différent
lorsque « m_x » et « m_a » sont initialisées par paramètres, comme ici, et
pourquoi ils sont identiques lorsque « m_x » est initialisée sous la forme «
m_x(55) ».
Par contre je ne m’explique pas pourquoi « B b » appelle le constructeur de « A
» avant même d’appeler celui de « B », ce qui a pour effet de donner à une « m_x
» une autre adresse que celle d’origine , adresse qui s’avère par la suite être
celle de « m_a ».(vérifiée lorsque « m_a » est initialisée par son constructeur)
et par suite d’être initialisée à la valeur de « m_a ».
Dans l’exemple tel que ci-dessus, tout se passe comme si le programme créait
sous l’identité « m_x » , une copie de « m_a », disons « m_x1 », sans
modification de la valeur d’initialisation d’origine de « m_x », d’où les
résultats.
Si tu pouvais éclairer ma lanterne sur cet appel du constructeur de « A » par «
B », tu ferais d’un débutant perplexe un débutant assuré
Bonjour,Bonjour à tous
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
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).
Par contre l’appel du constructeur de « A » par « B b()
» et la réinitialisation d’une « m_x » à
la valeur de « m_a » me désorientent.
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Merci
Bonjour,Bonjour à tous
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
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).
Par contre l’appel du constructeur de « A » par « B b()
» et la réinitialisation d’une « m_x » à
la valeur de « m_a » me désorientent.
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Merci
Gardez en mémoire que je suis débutant et que je ne cherche ni à justifier ni à
expliquer les résultats obtenus sur console je les livre tels qu’ils sont
apparus à l’écran. Il vous est loisible de vous en assurer. Le programme se
déroule de la façon que j’ai mentionnée et je n’y suis pour rien.
Gardez en mémoire que je suis débutant et que je ne cherche ni à justifier ni à
expliquer les résultats obtenus sur console je les livre tels qu’ils sont
apparus à l’écran. Il vous est loisible de vous en assurer. Le programme se
déroule de la façon que j’ai mentionnée et je n’y suis pour rien.
Gardez en mémoire que je suis débutant et que je ne cherche ni à justifier ni à
expliquer les résultats obtenus sur console je les livre tels qu’ils sont
apparus à l’écran. Il vous est loisible de vous en assurer. Le programme se
déroule de la façon que j’ai mentionnée et je n’y suis pour rien.
Bonjour,Bonjour Olivier
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
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).
Par contre l’appel du constructeur de « A » par « B b()
» et la réinitialisation d’une « m_x » à
la valeur de « m_a » me désorientent.
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Merci
Bonjour,Bonjour Olivier
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
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).
Par contre l’appel du constructeur de « A » par « B b()
» et la réinitialisation d’une « m_x » à
la valeur de « m_a » me désorientent.
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Merci
Le programme sous forme condensée.
Appel de A a(22)
Appel de « B b(99)
Valeur de « m_x » en retour de a.foo() = 22
Valeur de « m_x » en retour de b.bar() = 99
Comment l’accès, de deux façon différentes, à un même attribut de classe
peut-il, selon le cas, retourner des valeurs différentes ?
Le programme sous forme condensée.
Appel de A a(22)
Appel de « B b(99)
Valeur de « m_x » en retour de a.foo() = 22
Valeur de « m_x » en retour de b.bar() = 99
Comment l’accès, de deux façon différentes, à un même attribut de classe
peut-il, selon le cas, retourner des valeurs différentes ?
Le programme sous forme condensée.
Appel de A a(22)
Appel de « B b(99)
Valeur de « m_x » en retour de a.foo() = 22
Valeur de « m_x » en retour de b.bar() = 99
Comment l’accès, de deux façon différentes, à un même attribut de classe
peut-il, selon le cas, retourner des valeurs différentes ?
Le mercredi 05 Juillet 2017 à 09:53 par Pasletot :Bonjour,
Débutant C++ circonspect.
[...]
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Je n’accède à aucun site de discussion.
[...]
Je n’ai pas des connaissances en C++ suffisantes pour expliquer de moi-même. Je
ne peux que vous faire part des résultats console, de mon étonnement. et vous
demander de me dégrossir..
Comment l’accès, de deux façon différentes, à un même attribut de classe
peut-il, selon le cas, retourner des valeurs différentes ?
Le mercredi 05 Juillet 2017 à 09:53 par Pasletot :
Bonjour,
Débutant C++ circonspect.
[...]
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Je n’accède à aucun site de discussion.
[...]
Je n’ai pas des connaissances en C++ suffisantes pour expliquer de moi-même. Je
ne peux que vous faire part des résultats console, de mon étonnement. et vous
demander de me dégrossir..
Comment l’accès, de deux façon différentes, à un même attribut de classe
peut-il, selon le cas, retourner des valeurs différentes ?
Le mercredi 05 Juillet 2017 à 09:53 par Pasletot :Bonjour,
Débutant C++ circonspect.
[...]
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Je n’accède à aucun site de discussion.
[...]
Je n’ai pas des connaissances en C++ suffisantes pour expliquer de moi-même. Je
ne peux que vous faire part des résultats console, de mon étonnement. et vous
demander de me dégrossir..
Comment l’accès, de deux façon différentes, à un même attribut de classe
peut-il, selon le cas, retourner des valeurs différentes ?
Bonjour,Bonjour Olivier
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
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).
Par contre l’appel du constructeur de « A » par « B b()
» et la réinitialisation d’une « m_x » à
la valeur de « m_a » me désorientent.
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Merci
Bonjour,Bonjour Olivier
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
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).
Par contre l’appel du constructeur de « A » par « B b()
» et la réinitialisation d’une « m_x » à
la valeur de « m_a » me désorientent.
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Merci
Bonjour,Bonjour Lucas
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
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).
Par contre l’appel du constructeur de « A » par « B b()
» et la réinitialisation d’une « m_x » à
la valeur de « m_a » me désorientent.
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Merci
Bonjour,Bonjour Lucas
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
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).
Par contre l’appel du constructeur de « A » par « B b()
» et la réinitialisation d’une « m_x » à
la valeur de « m_a » me désorientent.
Pouvez-vous m’apporter des éléments de réponse sur
la raison pour laquelle « B b » appelle le constructeur de «
A » et réinitialise « m_x » lorsque c’est
possible ( « x » non int) ?
Merci