Discussion :

[harsh]

Bonjour,

Une confusion atroce m assaille

Y a t il une difference entre

TypeObjet nomObjet (param);

et

TypeObjet nomObjet = new TypeObjet (param);

Si oui, la portee de la seconde ligne depasse t elle le bloc auquelle elle appartient (mes souvenir me disent ke le new met l objet dans le tas donc lui accorde une vie en dehors du bloc...)?

Si non, comment creer un objet dans une fonction et renvoyer sa reference sans utiliser de pointeur?

Vaut il mieux retourner une reference sur un objet créé dans une fonction ou alors l'objet lui meme (et surtout pkoi)?

Merci

[swirtel]

La première est une instance d'un élément.

La seconde, tu alloues une zone mémoire pour accueillir une instance d'une nouvelle classe et tu as un pointeur pointant sur cette instance.

[Mast3rMind]

Y a t il une difference entre
TypeObjet nomObjet (param);
et
TypeObjet nomObjet = new TypeObjet (param);

Oui, la première déclaration crée un objet local, c'est-à-dire qu'à la sortie de la fonction cet objet sera détruit. La seconde déclaration crée un objet dynamique, cet objet ne sera détruit que lors d'un "delete nomObjet".

Si non, comment creer un objet dans une fonction et renvoyer sa reference sans utiliser de pointeur?

Vaut il mieux retourner une reference sur un objet créé dans une fonction ou alors l'objet lui meme (et surtout pkoi)?

Bien que le compilateur permette de retourner l'adresse d'un objet local dans une fonction, cela est une erreur de le faire, puisque l'objet sera détruit aussitôt après le "return", et l'adresse sera donc invalide.

[harsh]

Merci pour vos reponses.

Quand je parle de retourner un objet creé dans une fonction, je parle a ce momment la d'un objet dont l'espace viens d'etre alloué dynamiquement dans le tas par un new, donc non detruit a la sortie de la fonction.

Est il preferable de retourner l'objet ou sa reference, y at il rellement une difference entre:

typeObjet mafonction ()
{
typeObjet monObjet = new typeObjet ();
return monObjet;
}

et

typeObjet & mafonction ()
{
typeObjet monObjet = new typeObjet ();
return monObjet;
}

Dans les deux cas, la fonction ne retourne t elle pas une adresse? ou alors dans le premier cas, une copie est elle crée?

[vdumont]

Avec le & tu t'évite une copie virtuelle de ton objet car tu retournes une référence, ce qui sauve des ressources. Sans le & tu retourne une copie de l'objet.

N'oublie pas cependant que tout ce qui est créer avec un new nécessite une destruction explicite avec delete (ou delete [] si c'étais un array)

[harsh]

Merci,

juste une precision avant de marquer le sujet resolu:

Si je retourne une copie virtuelle, je perd la main sur l'objet créé donc g une fuite memoire, on est d'accord?

[vdumont]

Tu auras exactement le même objet puisqu'il s'agit d'une copie conforme de l'objet.

Si tu retournes par référence, le fait de modifier l'objet obtenu par référence modifiera également l'objet que tu as alloué avec new.

Ce ne sera parcontre pas le cas avec une copie (sans le &)


Si c'est un objet d'une taille asser considérable il est beaucoup mieux d'utiliser le & (car supposons une fonction qui retourne un objet énorme par copie qui est appelée 7000 fois dans un programme? -> lenteur!)

Si tu ne veux pas modifier l'objet tu peux retourner un const & au lieu de simplement &, ce qui te préviendras de modifier l'objet.

[diogene]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
typeObjet mafonction ()
{
typeObjet monObjet = new typeObjet ();
return monObjet;
}

Je ne pense pas que ce code soit correct : monObjet doit être un type typeObjet * :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
typeObjet * mafonction ()
{
typeObjet * monObjet = new typeObjet ();
return monObjet;
}

Le code suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
typeObjet  mafonction ()
{
typeObjet * monObjet = new typeObjet ();
return *monObjet;
}

retourne une copie ce qui ne permettra pas la destruction de l'objet créé par new.
ce code n'est pas correct non plus

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
typeObjet & mafonction ()
{
typeObjet monObjet = new typeObjet ();
return monObjet;
}

mais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
typeObjet & mafonction ()
{
typeObjet *monObjet = new typeObjet ();
return *monObjet;
}

Dans ce cas, l'appel devra se faire par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
typeObjet & obj=mafonction();
....
delete &obj;

et non pas par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

typeObjet  obj=mafonction();

car une copie sera faite dans obj et l'objet créé par new ne peut plus être détruit