Bonjour
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference. Comme je fais
des allocations dynamiques de tableaux dans Classe2 le tableau a été
effacé par appel du destructeur de Classe2 en fin de fonction "foo",
et celui ci n'est plus disponible dans le programme principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
Actuellement je contourne le probleme en passant des arguments par
references avec une fonction void foo(Classe2& objetClasse2), mais
c'est moins pratique, et mon code est plus lourd car je dois créer au
préalable une variable avant d'appeler la fonction.
J'ai acheté (et pas encore tout lu) le dernier "Le langage C++" par
Stroustrup mais tout ce que j'ai trouvé p 164 sur "return" n'indique
rien de particulier.
Merci d'avance à ceux qui aurait une petite idée sur la question.
Bonjour
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference. Comme je fais
des allocations dynamiques de tableaux dans Classe2 le tableau a été
effacé par appel du destructeur de Classe2 en fin de fonction "foo",
et celui ci n'est plus disponible dans le programme principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
Actuellement je contourne le probleme en passant des arguments par
references avec une fonction void foo(Classe2& objetClasse2), mais
c'est moins pratique, et mon code est plus lourd car je dois créer au
préalable une variable avant d'appeler la fonction.
J'ai acheté (et pas encore tout lu) le dernier "Le langage C++" par
Stroustrup mais tout ce que j'ai trouvé p 164 sur "return" n'indique
rien de particulier.
Merci d'avance à ceux qui aurait une petite idée sur la question.
Bonjour
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference. Comme je fais
des allocations dynamiques de tableaux dans Classe2 le tableau a été
effacé par appel du destructeur de Classe2 en fin de fonction "foo",
et celui ci n'est plus disponible dans le programme principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
Actuellement je contourne le probleme en passant des arguments par
references avec une fonction void foo(Classe2& objetClasse2), mais
c'est moins pratique, et mon code est plus lourd car je dois créer au
préalable une variable avant d'appeler la fonction.
J'ai acheté (et pas encore tout lu) le dernier "Le langage C++" par
Stroustrup mais tout ce que j'ai trouvé p 164 sur "return" n'indique
rien de particulier.
Merci d'avance à ceux qui aurait une petite idée sur la question.
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
Classe1 Temp2(); //constructeur par defaut
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
Classe1 Temp2(); //constructeur par defaut
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
Classe1 Temp2(); //constructeur par defaut
On 27 Oct 2003 05:16:03 -0800, (rotophil) wrote:Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
Non, déclaration de fonction.
Pour créer un objet avec le constructeur par défaut il faut écrire
Classe2 temp1;Classe1 Temp2(); //constructeur par defaut
Idem, encore une déclaration de fonction.
On 27 Oct 2003 05:16:03 -0800, pv@chez.com (rotophil) wrote:
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
Non, déclaration de fonction.
Pour créer un objet avec le constructeur par défaut il faut écrire
Classe2 temp1;
Classe1 Temp2(); //constructeur par defaut
Idem, encore une déclaration de fonction.
On 27 Oct 2003 05:16:03 -0800, (rotophil) wrote:Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
Non, déclaration de fonction.
Pour créer un objet avec le constructeur par défaut il faut écrire
Classe2 temp1;Classe1 Temp2(); //constructeur par defaut
Idem, encore une déclaration de fonction.
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference.
Comme je fais des allocations dynamiques de tableaux dans Classe2 le
tableau a été effacé par appel du destructeur de Classe2 en fin de
fonction "foo", et celui ci n'est plus disponible dans le programme
principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference.
Comme je fais des allocations dynamiques de tableaux dans Classe2 le
tableau a été effacé par appel du destructeur de Classe2 en fin de
fonction "foo", et celui ci n'est plus disponible dans le programme
principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference.
Comme je fais des allocations dynamiques de tableaux dans Classe2 le
tableau a été effacé par appel du destructeur de Classe2 en fin de
fonction "foo", et celui ci n'est plus disponible dans le programme
principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
"rotophil" a écrit dans le message de
news:Bonjour
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference. Comme je fais
des allocations dynamiques de tableaux dans Classe2 le tableau a été
effacé par appel du destructeur de Classe2 en fin de fonction "foo",
et celui ci n'est plus disponible dans le programme principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
Actuellement je contourne le probleme en passant des arguments par
references avec une fonction void foo(Classe2& objetClasse2), mais
c'est moins pratique, et mon code est plus lourd car je dois créer au
préalable une variable avant d'appeler la fonction.
J'ai acheté (et pas encore tout lu) le dernier "Le langage C++" par
Stroustrup mais tout ce que j'ai trouvé p 164 sur "return" n'indique
rien de particulier.
Merci d'avance à ceux qui aurait une petite idée sur la question.
tu dis faire des allocations dynamiques de tableaux ; as-tu redéfinis le
constructeur de copie de l'opérateur d'affectation pour dupliquer ces zones
mémoires (à supposer que tu aies des pointeurs en tant que données membres
de tes classes) ?
"rotophil" <pv@chez.com> a écrit dans le message de
news:2bc79a67.0310270516.44aa7ad2@posting.google.com...
Bonjour
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference. Comme je fais
des allocations dynamiques de tableaux dans Classe2 le tableau a été
effacé par appel du destructeur de Classe2 en fin de fonction "foo",
et celui ci n'est plus disponible dans le programme principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
Actuellement je contourne le probleme en passant des arguments par
references avec une fonction void foo(Classe2& objetClasse2), mais
c'est moins pratique, et mon code est plus lourd car je dois créer au
préalable une variable avant d'appeler la fonction.
J'ai acheté (et pas encore tout lu) le dernier "Le langage C++" par
Stroustrup mais tout ce que j'ai trouvé p 164 sur "return" n'indique
rien de particulier.
Merci d'avance à ceux qui aurait une petite idée sur la question.
tu dis faire des allocations dynamiques de tableaux ; as-tu redéfinis le
constructeur de copie de l'opérateur d'affectation pour dupliquer ces zones
mémoires (à supposer que tu aies des pointeurs en tant que données membres
de tes classes) ?
"rotophil" a écrit dans le message de
news:Bonjour
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference. Comme je fais
des allocations dynamiques de tableaux dans Classe2 le tableau a été
effacé par appel du destructeur de Classe2 en fin de fonction "foo",
et celui ci n'est plus disponible dans le programme principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
Actuellement je contourne le probleme en passant des arguments par
references avec une fonction void foo(Classe2& objetClasse2), mais
c'est moins pratique, et mon code est plus lourd car je dois créer au
préalable une variable avant d'appeler la fonction.
J'ai acheté (et pas encore tout lu) le dernier "Le langage C++" par
Stroustrup mais tout ce que j'ai trouvé p 164 sur "return" n'indique
rien de particulier.
Merci d'avance à ceux qui aurait une petite idée sur la question.
tu dis faire des allocations dynamiques de tableaux ; as-tu redéfinis le
constructeur de copie de l'opérateur d'affectation pour dupliquer ces zones
mémoires (à supposer que tu aies des pointeurs en tant que données membres
de tes classes) ?
"rotophil" a écrit dans le message de
news:Bonjour
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference. Comme je fais
des allocations dynamiques de tableaux dans Classe2 le tableau a été
effacé par appel du destructeur de Classe2 en fin de fonction "foo",
et celui ci n'est plus disponible dans le programme principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
Actuellement je contourne le probleme en passant des arguments par
references avec une fonction void foo(Classe2& objetClasse2), mais
c'est moins pratique, et mon code est plus lourd car je dois créer au
préalable une variable avant d'appeler la fonction.
J'ai acheté (et pas encore tout lu) le dernier "Le langage C++" par
Stroustrup mais tout ce que j'ai trouvé p 164 sur "return" n'indique
rien de particulier.
Merci d'avance à ceux qui aurait une petite idée sur la question.
tu dis faire des allocations dynamiques de tableaux ; as-tu redéfinis le
constructeur de copie de l'opérateur d'affectation pour dupliquer ces zones
mémoires (à supposer que tu aies des pointeurs en tant que données membres
de tes classes) ?
"rotophil" <pv@chez.com> a écrit dans le message de
news:2bc79a67.0310270516.44aa7ad2@posting.google.com...
Bonjour
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference. Comme je fais
des allocations dynamiques de tableaux dans Classe2 le tableau a été
effacé par appel du destructeur de Classe2 en fin de fonction "foo",
et celui ci n'est plus disponible dans le programme principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
Actuellement je contourne le probleme en passant des arguments par
references avec une fonction void foo(Classe2& objetClasse2), mais
c'est moins pratique, et mon code est plus lourd car je dois créer au
préalable une variable avant d'appeler la fonction.
J'ai acheté (et pas encore tout lu) le dernier "Le langage C++" par
Stroustrup mais tout ce que j'ai trouvé p 164 sur "return" n'indique
rien de particulier.
Merci d'avance à ceux qui aurait une petite idée sur la question.
tu dis faire des allocations dynamiques de tableaux ; as-tu redéfinis le
constructeur de copie de l'opérateur d'affectation pour dupliquer ces zones
mémoires (à supposer que tu aies des pointeurs en tant que données membres
de tes classes) ?
"rotophil" a écrit dans le message de
news:Bonjour
J'ai un probleme avec une fonction membre d'une classe "Classe1" qui
renvoie une variable d'un type que l'on appellera "Classe2". Voici
l'implémentation de la fonction
Classe2 Classe1::foo()
{
Classe2 Temp1(); //constructeur par defaut
//traitements sur Temp1 ...
return Temp1;
}
Dans le programme principal je l'appel avec:
Classe1 Temp2(); //constructeur par defaut
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
Or je me suis apercu que Temp3 et Temp1 pointe vers la meme adresse.
Cela voudrait donc dire que "return" ne fait pas une copie de Temp1
avant de le renvoyer, mais fait plutot une reference. Comme je fais
des allocations dynamiques de tableaux dans Classe2 le tableau a été
effacé par appel du destructeur de Classe2 en fin de fonction "foo",
et celui ci n'est plus disponible dans le programme principal.
Ayant fait un petit tour sur le groupe de discussion j'ai vu que cela
pouvait venir d'une optimisation du compilateur. (La variable
temporaire est crée dans l'espace précédent dans la pile des appels).
Comme je ne connait pas son s*nom sous mon compilateur (VS .NET) j'ai
desactivé toutes les optimisations. Mais de toutes facons elles sont
desactivées en mode DEBUG....
Actuellement je contourne le probleme en passant des arguments par
references avec une fonction void foo(Classe2& objetClasse2), mais
c'est moins pratique, et mon code est plus lourd car je dois créer au
préalable une variable avant d'appeler la fonction.
J'ai acheté (et pas encore tout lu) le dernier "Le langage C++" par
Stroustrup mais tout ce que j'ai trouvé p 164 sur "return" n'indique
rien de particulier.
Merci d'avance à ceux qui aurait une petite idée sur la question.
tu dis faire des allocations dynamiques de tableaux ; as-tu redéfinis le
constructeur de copie de l'opérateur d'affectation pour dupliquer ces zones
mémoires (à supposer que tu aies des pointeurs en tant que données membres
de tes classes) ?
Classe2 Temp1(); //constructeur par defaut
Pas du tout. Déclaration d'une fonction.//traitements sur Temp1 ...
return Temp1;
Ce qui doit provoquer une erreur ici. L'utilisation du nom d'une
fonction sans les () renvoie l'adresse de la fonction. Et ça
m'étonnerait que tu as une conversion implicite de Classe2 (*)() en
Classe2.
Je suppose qu'en fait, ce n'est pas comme ça dans ton code réel.Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
De quel genre ?
Est-ce que Classe2 a un constructeur de copie accessible ? (Mais sinon,
ta fonction Classe1::foo n'aurait pas dû compiler non plus.)
Classe2 Temp1(); //constructeur par defaut
Pas du tout. Déclaration d'une fonction.
//traitements sur Temp1 ...
return Temp1;
Ce qui doit provoquer une erreur ici. L'utilisation du nom d'une
fonction sans les () renvoie l'adresse de la fonction. Et ça
m'étonnerait que tu as une conversion implicite de Classe2 (*)() en
Classe2.
Je suppose qu'en fait, ce n'est pas comme ça dans ton code réel.
Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
De quel genre ?
Est-ce que Classe2 a un constructeur de copie accessible ? (Mais sinon,
ta fonction Classe1::foo n'aurait pas dû compiler non plus.)
Classe2 Temp1(); //constructeur par defaut
Pas du tout. Déclaration d'une fonction.//traitements sur Temp1 ...
return Temp1;
Ce qui doit provoquer une erreur ici. L'utilisation du nom d'une
fonction sans les () renvoie l'adresse de la fonction. Et ça
m'étonnerait que tu as une conversion implicite de Classe2 (*)() en
Classe2.
Je suppose qu'en fait, ce n'est pas comme ça dans ton code réel.Classe2 Temp3=Temp2.foo();
Cela me provoque une erreur.
De quel genre ?
Est-ce que Classe2 a un constructeur de copie accessible ? (Mais sinon,
ta fonction Classe1::foo n'aurait pas dû compiler non plus.)