retour d'objet par référence...
bonjour à tous,
voilà après avoir arpenté la faq et consulté les quelques post qui traitaient le sujet, j'ai toujours quelques doutes dans ce dommaine. Donc je m'en remets à vous pour éclaircir tout ça. :ave: :hola: :ave:
Pour ce qui est de l'utilisation des références en paramètes de fonctions, c'est tout simple :
Code:
1
2
3
4
5
6
7
8
9
10
|
MaClasse::use_param_ref_const(const UneAutreClasse& a) // lecture seule
{
// code...
}
MaClasse::use_param_ref(UneAutreClasse& a) // lecture et écriture
{
// code...
} |
mais pour le retour, y-a-t'il une différence entre :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
|
const UneAutreClasse&
MaClasse::return_param_ref_const(void)
{
// code...
}
// et
UneAutreClasse&
MaClasse::return_param_ref(void)
{
// code...
} |
sachant que l'on peut écrire (je crois) :
Code:
1
2
3
|
UneAutreClasse UneClasse = objMaClasse.return_param_ref_const();
UneAutreClasse UneClasse = objMaClasse.return_param_ref(); |
et pour ce qui est de l'objet retourné sachant qu'un :
Code:
1
2
3
4
5
6
7
8
|
(const) UneAutreClasse&
MaClasse::return_param_ref(void)
{
UneAutreClasse tmp;
// code...
return tmp;
} |
ne fera que planté le prog puisque qu'un objet local sera détruit en fin de fonction (contraitement aux types prédéfinis, ex. : int, long, unsigned...., soit dit en passant je vois pas pourquoi eux aussi ne seraient pas détruits, peut être que je mélange tout...)
pour pallier à tout ce mic-mac, j'ai recensé plusieurs solutions (mais y-en-t'il d'autres ??) :
- utilisé une reférence sur un objet static :
Code:
1
2
3
4
5
6
7
8
|
(const) UneAutreClasse&
MaClasse::return_param_ref(void)
{
static UneAutreClasse tmp;
// code...
return tmp;
} |
le hic, c'est que je ne sais pas si mon static existera pour toutes mes instances de la classe MaClasse, ou bien si chaque instance de MaClasse aura son propre static. De plus sa durée de vie serait-elle équivalente à celle de sa classe qui le contient ou à tout le programme ?? :pleure:
- ensuite, utilisé un objet dynamic
Code:
1
2
3
4
5
6
7
8
|
(const) UneAutreClasse&
MaClasse::return_param_ref(void)
{
UneAutreClasse tmp = new UneAutreClasse ;
// code...
return *tmp;
} |
bon, problème évident c'est que ce sera à la fonction appelante de se charger du delete, pas pratique du tout :twisted:...
- et enfin, placé la référence en param
Code:
1
2
3
4
5
6
|
void
MaClasse::modify_param_ref(UneAutreClasse& a)
{
// code qui modifie a...
} |
à part que ça n'a plus trop une tête d'accesseur :?, ça le mérite de fonctionner...
voilà exposer mes doutes, j'aimerais connaître vos opinions sur le sujet et savoir quelles solutions vous utilisez...
Re: retour d'objet par référence...
Citation:
Envoyé par sas
y-a-t'il une différence entre :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
|
const UneAutreClasse&
MaClasse::return_param_ref_const(void)
{
// code...
}
// et
UneAutreClasse&
MaClasse::return_param_ref(void)
{
// code...
} |
oui il y a une différence.
dans le 1er cas tu renvoie une référence sur une copie et tu ne peux pas utiliser la fonction comme une lvalue (car constance).
dans le 2è cas tu renvoie une référence sur la variable du return. là tu peux utiliser la fonction comme une lvalue, mais tu dois t'assurer que la variable du return n'est pas locale à la fonction.
Citation:
et pour ce qui est de l'objet retourné sachant qu'un :
Code:
1
2
3
4
5
6
7
8
|
(const) UneAutreClasse&
MaClasse::return_param_ref(void)
{
UneAutreClasse tmp;
// code...
return tmp;
} |
ne fera que planté le prog puisque qu'un objet local sera détruit en fin de fonction (contraitement aux types prédéfinis, ex. : int, long, unsigned...., soit dit en passant je vois pas pourquoi eux aussi ne seraient pas détruits, peut être que je mélange tout...)
oui tu mélanges tout. sans le &, il s'agit d'un retour par valeur. c'est-à-dire que la variable locale est copiée et que la copie est retournée, et la variable locale est supprimée à la fin de la fonction. dans le cas d'un retour par référence, il s'agit d'une référence sur la variable du return. ça ne pose pas de problème si c'est une donnée membre puisqu'elle existera encore, par contre si c'est une variable locale, alors la référence renvoie sur rien puisque la variable est détruite.
