Logo GNT
Actualités Tests & Guides Bons Plans
Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11
Entraide Développement Développement Langage C++ Acceder a un membre donnée d'une autre classe

Acceder a un membre donnée d'une autre classe

16 réponses
Avatar
Pasletot
Bonjour,

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
Signaler un problème avec ce contenu

10 réponses

Supprimer
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire

Veuillez sélectionner un problème

Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
1 2
Avatar
Olivier Miakinen
Bonjour,
Le 05/07/2017 09:53, Pasletot a écrit :
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;
}

Ok.
// 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();}

Si je comprends bien, la classe A contient un attribut m_x de type int,
et la classe B contient un attribut m_a de type A.
[...]
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) ?

« B b(88) » crée une variable b qui contient elle-même un attribut de
type A. Celui-ci, b.m_a, est différent du a que tu avais initialisé avec
la valeur 55, il est donc normal que les deux puissent avoir des valeurs
différentes.
En bref : a.m_x (qui vaut 55) est différent de b.m_a.m_x (qui vaut 88)
parce que a est différent de b.m_a.
Si tu n'as pas compris, essaye le programme suivant :
int main()
{
A c(11);
A d(22);
B e(33);
A f(44);
B g(55)
c.foo();
d.foo();
e.bar();
f.foo();
g.bar();
c.foo();
return 0;
}
--
Olivier Miakinen
Avatar
pasletot
Le mercredi 05 Juillet 2017 à 09:53 par Pasletot :
Bonjour,
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 Olivier
Tu as parfaitement compris.
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.
Avatar
Olivier Miakinen
Le 06/07/2017 10:30, pasletot m'a répondu :
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 ».(&)

Oui, ok.
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) ».

C'est moi qui ne comprends pas. Tu crées plusieurs objets dont certains
sont des A et d'autres sont des B, chacun de ces objets a une valeur qui
lui est propre, et ils ne sont donc jamais « identiques » (sauf bien sûr
si tu donnes la même valeur à deux d'entre eux).
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 ».

Ouille ouille ouille !
Dans ton exemple, on voit d'abord un objet a de type A, à l'adresse
0x28FF0C, qui contient un entier m_x à la même adresse (puisque c'est
le premier élément de a). On voit ensuite un objet b de type B à
l'adresse 0x28FF08, qui contient un m_a de type A à la même adresse,
lequel contient un entier m_x à la même adresse. Si tu crées un nouvel
objet de type A ou de type B, celui-ci sera à une nouvelle adresse
(très probablement à l'adresse 0x28FF04, puis un autre à l'adresse
0x28FF00, et ainsi de suite, puisque chacun ne contient au final
qu'un entier sur 4 octets).
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.

Mais non, pas une copie ! Chaque instance créée est indépendante des
autres. Et aucun ne s'appelle m_x1, même si tu as au final autant de
m_x que tu as d'instances de A, c'est-à-dire autant que la somme des
instances de A que tu crées directement et de celles que tu crées par
l'intermédiaire d'un B.
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é

Ben...
--
Olivier Miakinen
Avatar
pasletot
Le mercredi 05 Juillet 2017 à 09:53 par Pasletot :
Bonjour,
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 à tous
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.
Merci à vous
Avatar
Olivier Miakinen
Le 07/07/2017 10:11, pasletot a écrit :
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.

Note que je ne remets aucunement en cause le déroulement du programme,
mais l'interprétation que tu en fais.
Par ailleurs, je ne sais pas par quel site web tu accèdes aux groupes
de discussion, mais il doit y avoir un moyen pour que tu répondes aux
articles des uns et des autres plutôt qu'à ton propre premier article.
--
Olivier Miakinen
Avatar
pasletot
Le mercredi 05 Juillet 2017 à 09:53 par Pasletot :
Bonjour,
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 Olivier
Je n’accède à aucun site de discussion. C’est sans doute une habitude que j’ai de me répondre. Elle a l’inconvénient de restreindre ma connaissance du langage et de rendre mes rares échanges difficiles.
J’ai modifié non sans mal le programme de la façon suivante
En B.h : A *m_a ; au lieu de A m_a ;
En B.cpp, constructeur, ajout de : m_a = new A(z) ;
Dans B ::bar() ; return m_a->foo() ; au lieu de return m_a.foo() ;
J’ai obtenu sans surprise les résultats console suivants, dans leur ordre d’apparition :
Appel de A a(22)
Constructeur A , initialisation de « m_x » à 22
Adresse de « m_x » 0x28fefc
Appel de « B b(99)
Constructeur A , réinitialisation de « m_x » à 99………// Pourquoi constructeur A par « B b » ?
Adresse de « m_x » 0x376af8
Constructeur B
Adresse de « m_a » 0x28fef8
Adresse dans « m_a » 0x376af8 ……… // (seconde adresse de « m_x », avant initialisation de « m_a »)
Valeur de « m_a » impossible …………// ( pour moi ?)
Valeur de « m_x » en retour de a.foo() = 22
Valeur de « m_x » en retour de b.bar() = 99
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 ?
Si la réponse est « c’est normal » j’accepterai cette réponse et s’il m’arrive de concevoir un programme j’éviterai de vérifier en double une valeur d’attribut de cette façon. Au final mon intervention n’aura pas été inutile. Mais j’aurais bien aimé savoir si l’appel du constructeur de A par « B b » est…… habituel..
Merci
Avatar
Lucas Levrel
Le 7 juillet 2017, à 12:19, pasletot a écrit :
Le programme sous forme condensée.


Poste le code complet. Ma boule de cristal est chez le garagiste.
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 ?

Une classe n'est qu'un type, comme int, char, float... Tu peux définir
plusieurs int différents, tu peux aussi définir plusieurs instances de la
classe A, de la classe B... m_x semble être un membre de a ou b. Ce n'est
pas une propriété de la classe A, c'est un élément de chaque exemplaire de
type A ou B. Différentes instances, différents éléments...
--
LL
Ἕν οἶδα ὅτι οὐδὲν οἶδα (Σωκράτης)
Avatar
Olivier Miakinen
Le 07/07/2017 19:19, pasletot a écrit :
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) ?


Ce texte, qui est ton article initial, ça fait quatre fois que tu nous
le présentes : une fois sous la forme de texte nouveau, trois fois sous
forme de citation. Cela veut dire que tu réponds toujours à TON propre
message initial, et jamais aux réponses qui te sont faites. Le problème
est que tu ne comprends sûrement pas de quoi je parle, alors que moi je
ne peux pas te l'expliquer mieux parce que je ne sais pas quel moyen
tu utilises pour écrire ici.
En bref. Tu es en train d'écrire sur un média qui s'appelle Usenet,
auquel on accède en principe avec un logiciel de nouvelles qui n'a rien
à voir avec un navigateur web, mais que certains sites tels que Google
groupes y donnent un accès via le web. Je sais que tu ne passes pas par
Google, mais je suppose que tu passes par un site web (via Firefox ou
Internet Exploreur ou Chrome ou un autre navigateur web), ce site
utilisant les services de Giganews pour transformer une page web en
article Usenet.
Alors à mon tour de te poser une question : est-ce que tu peux nous dire
quelle est l'adresse du site en question (un machin qui commence sans
doute par « http:// » ou par « https:// ») ?
Je n’accède à aucun site de discussion.

Que tu en aies conscience ou non, tu accèdes aux forums de discussion
de Usenet, en particulier le groupe fr.comp.lang.c++. Comment fais-tu
pour écrire ces messages ? Un navigateur web ? Une application sur un
smartphone ? Autre ? Mes questions doivent te sembler incongrues parce
que tu ne dois pas imaginer qu'il soit possible d'accéder de plusieurs
façons différentes à ce groupe de discussion, mais j'espère que tu me
répondras quand même.
[...]
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 ?

Lucas Levrel t'a répondu. Je veux bien essayer d'expliquer davantage,
mais d'abord j'aimerais bien que tu répondes à mes propres questions.
--
Olivier Miakinen
Avatar
pasletot
Le mercredi 05 Juillet 2017 à 09:53 par Pasletot :
Bonjour,
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 Olivier
ça prend un tour curieux. Non tes questions ne me semblent pas incongrues. En ce qui me concerne j'ai recherché un site avec forum sur le C++ ouvert à tout intervenant qui s'inscrit, sans plus.
J'accède au net avec firefox, utilise google pour accéder à l'adresse ci-dessous
https://www.generation-nt.com/reponses/acceder-membre-donnee-039-autre-classe-entraide-4271063.html
et une fois connecté j'utilise l'éditeur "postez une réponse " qui est affiché au nom de mon avatar, réponse qui doit être validée avant parution.
Est-ce-que ça répond à ta question ?
J'espère ne pas arriver à user ta patience.
Merci
Avatar
pasletot
Le mercredi 05 Juillet 2017 à 09:53 par Pasletot :
Bonjour,
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 Lucas
Entendons nous bien sur le fond des éclaircissements que je souhaiterais.
J'ai cru comprendre qu'en C++ lors de sa création un objet accède d'emblée à son constructeur.
Pourquoi dans mon exemple "B b" accède d'emblée à celui de la classe "A" ?
De même j'ai cru comprendre que les données membres privées d'une classe étaient accessibles par les méthodes de cette classe.
Pourquoi dans mon exemple l'accession à la seule donnée membre de la clase "A" donne en retour, selon le cas ou selon les modalités d'accès , deux résultats différents. ?
Le reste j'en fais mon affaire au fur et à mesure de ma progression dans le langage avec votre aide si le besoin s'en fait sentir.
Il n’y rien de pire pour un néophyte que de constater que des résultats paraissent, je dis bien paraissent, être en contradiction avec ceux énoncés par les règles de base.
En ce qui concerne ta boule de cristal quelle version de programme souhaites-tu ? Avec ou sans pointeur ou les deux ?
Je donnerai suite à ton choix quand Olivier m'aura donné le bon chemin à emprunter pour poster mes réponses.
Merci
1 2