question simple pour aujourd´hui :

quand une fonction retourne une class

par exemple :

class MaClass
{
public:
int GetNb();
private:
int Nb;
}
int MaClass::GetNb()
{
return Nb;
}

puis :
MaClass addition(MaClass,MaClass);

et qu´on fait un return à la fin de la fonction, qu´est ce uq´elle renvoie ? toute les données membre de la classe que je mets dans le return sont copiées, ou alors ça ne marche qu´avec des pointeurs ?

Hmm je comprends pas trop ta question..

" quand une fonction retourne une class"
tu parles d une instance je suppose

" puis :
MaClass addition(MaClass,MaClass);
et qu´on fait un return à la fin de la fonction, qu´est ce uq´elle renvoie ? toute les données membre de la classe que je mets dans le return sont copiées, ou alors ça ne marche qu´avec des pointeurs ? "

Hein?
ok quelques exemples:

class Test
{
public:
int a, b;
};

Test test1()
{
Test a;
return a;
}

Test& test2()
{
static Test1 a;
return a;
}

class Test_b
{
public:
int a,b;
private:
Test_b& operator=( const Test_b& ) ;
};

Test_b marchepas()
{
Test_b a;
return a;
}

int main()
{
Test a = test1(); / / object copie
Test& b = test2(); / / reference
Test_b c = test_marchepas(); / / compile pas
}

comme kUfa, j´ai pas tout saisi :/

ou alors p-e qu´il faut comprendre la question comme " que fait le constructeur par copie par défaut", ce que à quoi je répondrai qu´effectivement, toutes les données de l´instance sources sont dupliquées ( appel de ctor par copie pour chaque membre, à un niveau d´indirection : un pointeur vers une zone mémoire se copie en un nouveau pointeur vers la meme zone mémoire).

faut aussi voir qu´en utilisant un polymorphisme sur valeur de retour, toutes les données de l´instance peuvent ne pas etre copiées... bref, faudrait éclaircir la question :-?

le question est telle que tu l´a compris LGV.

qu´est ce qui se passe quand une fonction renvoie une instance de class ( pour utiliser du bon vocabulaire) ?

parce qu´avec des tests, j´ai vu que les données membres étaient copiées, mais je me demandais si le mécanisme en cause était plus subtil, ou s´il y avait des trucs particuliers à savoir dessus.

ben pour " renvoyer" l´objet ( donc ni une & ni un *, qu´on soit bien d´accord), c´est le ctor de copie qui est appelé. Le méchanisme du ctor de copie trivial ( fourni par le compilo) est assez simpliste : dupliquer les types primitifs, et appeler les ctor de copie des autres membres de ton objet ( appel en chaine de ctor par copie donc)
pour bien voir ce qui se passe, je te conseille d´écrire la forme canonique d´une classe et de foutre des breakpoints partout : tu verras bien qu´est-ce qui est appelé, et où.

ex. basique de proto d´une telle forme :

class Foo
{
public:
Foo(); / / default ctor
Foo(const Foo &); / / copy ctor
const Foo & =(const Foo &); / / assignment op.
~Foo(); / / dtor
};

petite note : à l´évidence, si tu un membre de type * dans un objet, et qu´en le copiant tu ne veux PAS que les deux instances partagent la meme zone mémoire ( copie brute de la valeur du pointeur..), tu DOIS redefinir le ctor de copie pour générer une nouvelle zone mémoire.

d´accord, merci, je vais essayer de faire joujou avec ça pour comprendre.