.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
CPoint& operator= (const CPoint&);
void Set(int nx, int ny);
void Affiche(void);
};
voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
int main()
{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la surgarge
de =, aie la encore rien ne s'affiche)
.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
CPoint& operator= (const CPoint&);
void Set(int nx, int ny);
void Affiche(void);
};
voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
int main()
{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la surgarge
de =, aie la encore rien ne s'affiche)
.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
CPoint& operator= (const CPoint&);
void Set(int nx, int ny);
void Affiche(void);
};
voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
int main()
{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la surgarge
de =, aie la encore rien ne s'affiche)
giova wrote:
salut,.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
CPoint& operator= (const CPoint&);
ou alors :
CPoint& operator= (CPoint);void Set(int nx, int ny);
void Affiche(void);
void Affiche();};voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
int main()
[ contrairement au C ou le fait de faire int main() voudrait dire que main
peut recevoir un nombre indeterminé de paramètres (en clair on ne précise
rien sur les arguments) le C++ dit que int main() ou alors void Affiche()
signifie que ces deux fonctions ne recoivent aucun paramètres, donc
pourquoi se fatiguer à écrire void ? :-) ]{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la surgarge
de =, aie la encore rien ne s'affiche)
Il devrait y avoir les étapes suivantes :
1 - Construction de l'objet tempraire CPoint(1,2);
2 - Appel du constructeur de copie CPoint(const CPoint&);
3 - Destruction de l'objet temporaire
Or dans ce cas, rien dans la norme (à ma connaissance) n'oblige le
compilateur à passer par un objet temporaire et appeler le constructeur de
copie. Il me semble donc qu'en règle général aucun ne le fera. (je viens de
tenter avec g++ en lui enlevant toute optimisation et rien à faire...)
Par contre ceci l'appelera :
CPoint t1(1,2);
CPoint t2 = t1;
Dans ce cas, il y a construction de t1 puis appel du constructeur de copie
pour construire t2.
L'opérateur = ne sera appelé quant à lui que dans le cas :
CPoint t1(1,2), t2;
t2 = t1;
En effet tous les cas précédents sont des cas de construction. Même si tu y
mets un =, on reste dans la construction et c'est le constructeur de copie
qui est appelé.
Dans le cas qui nous interesse ici donc le CPoint t1 = CPoint(1,2); je pense
que c'est juste une optimisation du compilateur qui le fait éviter le
passage par un objet temporaire. Encore une fois je ne connais pas la norme
par coeur mais je ne pense pas qu'un compilateur soit forcé à passer par un
objet temporaire dans ce cas, il ne le fait donc pas. (et je ne crois pas
qu'à l'inverse il y soit obligé)
Le passage par un objet temporaire se fera par contre pour :
CPoint t1;
t1 = CPoint(1,2); (1)
qui aura pour conséquence dans (1) :
1 - Construction de CPoint avec deux paramètres
2 - Appel de operator= (const CPoint&)
3 - Destruction de l'objet temporaire
Bonnes révisions,
Anthony
En effet toutes tes explications semblent justifier le résultat obtenu,
t1 = CPoint(1,2);
giova wrote:
salut,
.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
CPoint& operator= (const CPoint&);
ou alors :
CPoint& operator= (CPoint);
void Set(int nx, int ny);
void Affiche(void);
void Affiche();
};
voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
int main()
[ contrairement au C ou le fait de faire int main() voudrait dire que main
peut recevoir un nombre indeterminé de paramètres (en clair on ne précise
rien sur les arguments) le C++ dit que int main() ou alors void Affiche()
signifie que ces deux fonctions ne recoivent aucun paramètres, donc
pourquoi se fatiguer à écrire void ? :-) ]
{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la surgarge
de =, aie la encore rien ne s'affiche)
Il devrait y avoir les étapes suivantes :
1 - Construction de l'objet tempraire CPoint(1,2);
2 - Appel du constructeur de copie CPoint(const CPoint&);
3 - Destruction de l'objet temporaire
Or dans ce cas, rien dans la norme (à ma connaissance) n'oblige le
compilateur à passer par un objet temporaire et appeler le constructeur de
copie. Il me semble donc qu'en règle général aucun ne le fera. (je viens de
tenter avec g++ en lui enlevant toute optimisation et rien à faire...)
Par contre ceci l'appelera :
CPoint t1(1,2);
CPoint t2 = t1;
Dans ce cas, il y a construction de t1 puis appel du constructeur de copie
pour construire t2.
L'opérateur = ne sera appelé quant à lui que dans le cas :
CPoint t1(1,2), t2;
t2 = t1;
En effet tous les cas précédents sont des cas de construction. Même si tu y
mets un =, on reste dans la construction et c'est le constructeur de copie
qui est appelé.
Dans le cas qui nous interesse ici donc le CPoint t1 = CPoint(1,2); je pense
que c'est juste une optimisation du compilateur qui le fait éviter le
passage par un objet temporaire. Encore une fois je ne connais pas la norme
par coeur mais je ne pense pas qu'un compilateur soit forcé à passer par un
objet temporaire dans ce cas, il ne le fait donc pas. (et je ne crois pas
qu'à l'inverse il y soit obligé)
Le passage par un objet temporaire se fera par contre pour :
CPoint t1;
t1 = CPoint(1,2); (1)
qui aura pour conséquence dans (1) :
1 - Construction de CPoint avec deux paramètres
2 - Appel de operator= (const CPoint&)
3 - Destruction de l'objet temporaire
Bonnes révisions,
Anthony
En effet toutes tes explications semblent justifier le résultat obtenu,
t1 = CPoint(1,2);
giova wrote:
salut,.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
CPoint& operator= (const CPoint&);
ou alors :
CPoint& operator= (CPoint);void Set(int nx, int ny);
void Affiche(void);
void Affiche();};voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
int main()
[ contrairement au C ou le fait de faire int main() voudrait dire que main
peut recevoir un nombre indeterminé de paramètres (en clair on ne précise
rien sur les arguments) le C++ dit que int main() ou alors void Affiche()
signifie que ces deux fonctions ne recoivent aucun paramètres, donc
pourquoi se fatiguer à écrire void ? :-) ]{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la surgarge
de =, aie la encore rien ne s'affiche)
Il devrait y avoir les étapes suivantes :
1 - Construction de l'objet tempraire CPoint(1,2);
2 - Appel du constructeur de copie CPoint(const CPoint&);
3 - Destruction de l'objet temporaire
Or dans ce cas, rien dans la norme (à ma connaissance) n'oblige le
compilateur à passer par un objet temporaire et appeler le constructeur de
copie. Il me semble donc qu'en règle général aucun ne le fera. (je viens de
tenter avec g++ en lui enlevant toute optimisation et rien à faire...)
Par contre ceci l'appelera :
CPoint t1(1,2);
CPoint t2 = t1;
Dans ce cas, il y a construction de t1 puis appel du constructeur de copie
pour construire t2.
L'opérateur = ne sera appelé quant à lui que dans le cas :
CPoint t1(1,2), t2;
t2 = t1;
En effet tous les cas précédents sont des cas de construction. Même si tu y
mets un =, on reste dans la construction et c'est le constructeur de copie
qui est appelé.
Dans le cas qui nous interesse ici donc le CPoint t1 = CPoint(1,2); je pense
que c'est juste une optimisation du compilateur qui le fait éviter le
passage par un objet temporaire. Encore une fois je ne connais pas la norme
par coeur mais je ne pense pas qu'un compilateur soit forcé à passer par un
objet temporaire dans ce cas, il ne le fait donc pas. (et je ne crois pas
qu'à l'inverse il y soit obligé)
Le passage par un objet temporaire se fera par contre pour :
CPoint t1;
t1 = CPoint(1,2); (1)
qui aura pour conséquence dans (1) :
1 - Construction de CPoint avec deux paramètres
2 - Appel de operator= (const CPoint&)
3 - Destruction de l'objet temporaire
Bonnes révisions,
Anthony
En effet toutes tes explications semblent justifier le résultat obtenu,
t1 = CPoint(1,2);
.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
void Set(int nx, int ny);
void Affiche(void);
};
--------------------------------------------
je ne vais pas gaver ce mail en vous mettant le cpp, disons simplement
que dans chaque fonctions, j'affiche dans la console quelle fonction
vient d'etre lancée.
voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la surgarge
de =, aie la encore rien ne s'affiche)
.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
void Set(int nx, int ny);
void Affiche(void);
};
--------------------------------------------
je ne vais pas gaver ce mail en vous mettant le cpp, disons simplement
que dans chaque fonctions, j'affiche dans la console quelle fonction
vient d'etre lancée.
voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la surgarge
de =, aie la encore rien ne s'affiche)
.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
void Set(int nx, int ny);
void Affiche(void);
};
--------------------------------------------
je ne vais pas gaver ce mail en vous mettant le cpp, disons simplement
que dans chaque fonctions, j'affiche dans la console quelle fonction
vient d'etre lancée.
voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la surgarge
de =, aie la encore rien ne s'affiche)
Anthony Fleury wrote:L'opérateur = ne sera appelé quant à lui que dans le cas :
CPoint t1(1,2), t2;
t2 = t1;
En effet tous les cas précédents sont des cas de construction. Même si tu
y mets un =, on reste dans la construction et c'est le constructeur de
copie qui est appelé.
y a juste un point qui me chiffone, c'est quand tu dis que :
CPoint t1(1,2), t2; (1)
t2 = t1; (2)
fait appel au constructeur de recopie, car pour moi en (1) il y a appel
du constructeur a 2 param pour t1,et constructeur sans param pour t2
et en (2) il y a appel de la surcharge de =.
Donc POUR RESUMER, a confirmer tout de meme, mais ca a vraiment l'air
d'etre ca :
il y a une optimisation du compileur,lorsque qu'un objet est défini et
initialisé sur une meme instruction avec pour valeur d'initalisation un
"objet temporaire", le compilateur ne construit pas l'objet temporaire
mais construit directement l'objet souhaité. ainsi on peut dire que :
CPoint t1= CPoint (1,2);
une fois optimisé par le compilo reviens a un :
CPoint t1(1,2);
Anthony Fleury wrote:
L'opérateur = ne sera appelé quant à lui que dans le cas :
CPoint t1(1,2), t2;
t2 = t1;
En effet tous les cas précédents sont des cas de construction. Même si tu
y mets un =, on reste dans la construction et c'est le constructeur de
copie qui est appelé.
y a juste un point qui me chiffone, c'est quand tu dis que :
CPoint t1(1,2), t2; (1)
t2 = t1; (2)
fait appel au constructeur de recopie, car pour moi en (1) il y a appel
du constructeur a 2 param pour t1,et constructeur sans param pour t2
et en (2) il y a appel de la surcharge de =.
Donc POUR RESUMER, a confirmer tout de meme, mais ca a vraiment l'air
d'etre ca :
il y a une optimisation du compileur,lorsque qu'un objet est défini et
initialisé sur une meme instruction avec pour valeur d'initalisation un
"objet temporaire", le compilateur ne construit pas l'objet temporaire
mais construit directement l'objet souhaité. ainsi on peut dire que :
CPoint t1= CPoint (1,2);
une fois optimisé par le compilo reviens a un :
CPoint t1(1,2);
Anthony Fleury wrote:L'opérateur = ne sera appelé quant à lui que dans le cas :
CPoint t1(1,2), t2;
t2 = t1;
En effet tous les cas précédents sont des cas de construction. Même si tu
y mets un =, on reste dans la construction et c'est le constructeur de
copie qui est appelé.
y a juste un point qui me chiffone, c'est quand tu dis que :
CPoint t1(1,2), t2; (1)
t2 = t1; (2)
fait appel au constructeur de recopie, car pour moi en (1) il y a appel
du constructeur a 2 param pour t1,et constructeur sans param pour t2
et en (2) il y a appel de la surcharge de =.
Donc POUR RESUMER, a confirmer tout de meme, mais ca a vraiment l'air
d'etre ca :
il y a une optimisation du compileur,lorsque qu'un objet est défini et
initialisé sur une meme instruction avec pour valeur d'initalisation un
"objet temporaire", le compilateur ne construit pas l'objet temporaire
mais construit directement l'objet souhaité. ainsi on peut dire que :
CPoint t1= CPoint (1,2);
une fois optimisé par le compilo reviens a un :
CPoint t1(1,2);
Soit je fais une classe cannonique ultra basique :
.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
void Set(int nx, int ny);
void Affiche(void);
};
--------------------------------------------
je ne vais pas gaver ce mail en vous mettant le cpp, disons simplement
que dans chaque fonctions, j'affiche dans la console quelle fonction
vient d'etre lancée.
voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la
surgarge de =, aie la encore rien ne s'affiche)
ce qui est amusant c'est que b se voit bien affecté les valeurs 1 et
2, donc soit un constructeur de recopie est appellé soit l'opérateur
=, le probleme c'est que pour chacune de ces fonctions, j'ai (comme
précisé plus haut) demander a afficher ce qui se passe dans la
console, hors rien n'apparait comme si c'est l'operateur = par defaut
qui etait appellé.
quelqu'un pourrait il m'expliquer le pourquoi de tout ca?
Soit je fais une classe cannonique ultra basique :
.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
void Set(int nx, int ny);
void Affiche(void);
};
--------------------------------------------
je ne vais pas gaver ce mail en vous mettant le cpp, disons simplement
que dans chaque fonctions, j'affiche dans la console quelle fonction
vient d'etre lancée.
voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la
surgarge de =, aie la encore rien ne s'affiche)
ce qui est amusant c'est que b se voit bien affecté les valeurs 1 et
2, donc soit un constructeur de recopie est appellé soit l'opérateur
=, le probleme c'est que pour chacune de ces fonctions, j'ai (comme
précisé plus haut) demander a afficher ce qui se passe dans la
console, hors rien n'apparait comme si c'est l'operateur = par defaut
qui etait appellé.
quelqu'un pourrait il m'expliquer le pourquoi de tout ca?
Soit je fais une classe cannonique ultra basique :
.h------------------------------------------
class CPoint
{
int x,y;
public:
CPoint();
CPoint(int nx, int ny);
~CPoint();
CPoint(const CPoint& ref);
CPoint& operator = (CPoint & ref);
void Set(int nx, int ny);
void Affiche(void);
};
--------------------------------------------
je ne vais pas gaver ce mail en vous mettant le cpp, disons simplement
que dans chaque fonctions, j'affiche dans la console quelle fonction
vient d'etre lancée.
voici un petit main.cpp de test :
--------------------------------------------
#include "Point.h"
#include <iostream>
using namespace std;
void main(void)
{
CPoint tata = CPoint(1,2);
tata.Affiche();
}
--------------------------------------------
et voici ce que j'obtiens lors de l'execution :
Constructeur avec2 params
X : 1
Y : 2
et la vraiment je ne comprends pas pourquoi j'obtiens ce résultat.
voici ce que j'imaginais a l'origine et qui est mis en cause par le
résultat obtenu :
1)construction d'un objet temporaire de type CPoint (appel du
constructeur avec 2 parametres, ca colle avec le résultat a l'ecran)
2)construction de l'objet tata de type CPoint (appel du constructeur
sans parametres, aie la ca ne colle plus avec le résultat a l'ecran)
3)affectation de l'objet temporaire vers l'objet b (appel de la
surgarge de =, aie la encore rien ne s'affiche)
ce qui est amusant c'est que b se voit bien affecté les valeurs 1 et
2, donc soit un constructeur de recopie est appellé soit l'opérateur
=, le probleme c'est que pour chacune de ces fonctions, j'ai (comme
précisé plus haut) demander a afficher ce qui se passe dans la
console, hors rien n'apparait comme si c'est l'operateur = par defaut
qui etait appellé.
quelqu'un pourrait il m'expliquer le pourquoi de tout ca?
