 |
C++Talk.NET C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Marc G Guest
|
Posted: Mon Oct 23, 2006 9:19 pm Post subject: initialisation d'une référence constante comme paramètre de |
|
|
bonjour,
est-il possible d'écrire par exemple
void f(std::string const& name="")
{
//...
}
ie d'initialiser une référence constante à un objet
je crois que oui dans la mesure ou "" n'est pas du type std::string et
qu'une conversion est nécessaire
alors que
void f(std::string const& name=std::string())
{
//...
}
devrait être interdit (mais mon compilateur l'accepte)
je ne trouve pas de réponse "certaine" à ma question sur internet , ni dans
mes docs.
Merci à vous |
|
| Back to top |
|
 |
Jean-Marc Bourguet Guest
|
Posted: Mon Oct 23, 2006 9:29 pm Post subject: Re: initialisation d'une reference constante comme parametre |
|
|
"Marc G" <mgueguen (AT) metrica (DOT) fr> writes:
| Quote: | bonjour,
est-il possible d'écrire par exemple
void f(std::string const& name="")
{
//...
}
ie d'initialiser une référence constante à un objet
|
Oui.
| Quote: | je crois que oui dans la mesure ou "" n'est pas du type std::string et
qu'une conversion est nécessaire
alors que
void f(std::string const& name=std::string())
{
//...
}
devrait être interdit (mais mon compilateur l'accepte)
|
Je ne vois pas pourquoi ça devrait être interdit. Dans les deux cas, on
lie une référence constante à un temporaire.
A+
--
Jean-Marc
FAQ de fclc++: http://www.cmla.ens-cachan.fr/~dosreis/C++/FAQ
C++ FAQ Lite en VF: http://www.ifrance.com/jlecomte/c++/c++-faq-lite/index.html
Site de usenet-fr: http://www.usenet-fr.news.eu.org |
|
| Back to top |
|
 |
Marc G Guest
|
Posted: Mon Oct 23, 2006 10:23 pm Post subject: Re: initialisation d'une reference constante comme parametre |
|
|
| Quote: | Je ne vois pas pourquoi ça devrait être interdit. Dans les deux cas, on
lie une référence constante à un temporaire.
|
je croyais que si on écrit
std::string const& ref=std::string("test");
ref référence un temporaire détruit par la suite ? |
|
| Back to top |
|
 |
kanze Guest
|
Posted: Mon Oct 23, 2006 10:34 pm Post subject: Re: initialisation d'une reference constante comme parametre |
|
|
Marc G wrote:
| Quote: | Je ne vois pas pourquoi ça devrait être interdit. Dans les
deux cas, on lie une référence constante à un temporaire.
je croyais que si on écrit
std::string const& ref=std::string("test");
ref référence un temporaire détruit par la suite ?
|
Certainement, mais dans le cas précis où le temporaire a servi à
directement initialisé une référence (qui ne peut être que
const), « la suite », c'est quand la référence cesse
d'exister, et non à la fin de l'expression complète, comme
d'habitude.
--
James Kanze (GABI Software) email:james.kanze (AT) gmail (DOT) com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34 |
|
| Back to top |
|
 |
meow Guest
|
Posted: Tue Oct 24, 2006 9:12 am Post subject: Re: initialisation d'une reference constante comme parametre |
|
|
Je me permets de m'immiscer dans la discussion. Je comprends la
question (qui m'intéresse), mais je ne suis pas certain de comprendre
la réponse.
Si je comprends bien ce que dit Marc :
std::string const& ref=std::string("test");
std::cout<<ref<<std::endl;
à la première ligne j'initialise ma référence avec un
"temporaire"... Du coups, ref est un pointeur déréférencé vers une
plage mémoire déjà "libérée" à la seconde ligne. Avec un peu de
bol il y restera quelque chose de cohérent, mais ce n'est pas garanti.
Et si je comprends bien ce que dit Kanze :
Le compilateur est intelligent, il sait repérer lorsqu'on initialise
une référence avec un temporaire, du coup il fait du temporaire une
sorte de "variable locale orpheline"; Et la portée de cette variable
est celle de la référence. |
|
| Back to top |
|
 |
James Kanze Guest
|
Posted: Wed Oct 25, 2006 9:11 am Post subject: Re: initialisation d'une référence constante comme paramètre |
|
|
Lahsen wrote:
| Quote: | Marc G a écrit :
est-il possible d'écrire par exemple
void f(std::string const& name="")
{
//...
}
ie d'initialiser une référence constante à un objet
je crois que oui dans la mesure ou "" n'est pas du type
std::string et qu'une conversion est nécessaire
alors que
void f(std::string const& name=std::string())
{
//...
}
devrait être interdit (mais mon compilateur l'accepte)
je ne trouve pas de réponse "certaine" à ma question sur
internet , ni dans mes docs.
La référence est un alias d'un objet et pas un pointeur.
|
Mais en tant que paramètre ou valeur de retour, un pointeur est
à peu près la seule implémentation possible.
| Quote: | L'instruction:
T t = u;
est une initialisation par le constructeur de copie ( à ne pas
confondre avec affectation. En dépit de la présence du signe
=, l'instruction T t = u; n'appelle pas T::operateur=() )
|
C'est une initialisation de type copie. Le compilateur a le
droit (mais pas l'obligation) d'appeler le constructeur de
copie ; peu le font. (Qu'il appelle le constructeur de copie ou
non, il faut qu'il y en ait un d'accessible.)
| Quote: | Il est préférable d'employer une initialisation de type T t(u).
|
Selon les goûts. Certains préfère la forme avec =, parce qu'elle
ne prète pas à l'ambiguïté quand l'initialisateur est un
temporaire du genre MaClasse(x) (mais il y a d'autres façons à
enlever l'ambiguïté).
| Quote: | Dans ta fonction
f(std::string const& name=std::string())
name est un alias (référence constante ) d'un objet string construit par
copie
|
Ou non. Tous les compilateurs que je connais liera la référence
directement à la chaîne créée par l'invocation de string(), sans
faire de copie. Ce que tu dis est vrai dans l'abstrait, mais il
y aura bien des programmeurs qui instrumenteront le constructeur
de copie, et ensuite se posera la question pourquoi il n'est pas
appelé.
| Quote: | et transmis à la fonction f. Elle a une durée de vie dans la
portée de f.
|
Non. Elle a la durée de vie de l'expression complète d'où est
appelée la fonction. La règle spéciale qui concerne la durée de
vie d'un temporaire lié à une référence ne peut pas raccourcir
sa vie, seulement la rallonger. Quelque chose comme le suivant
est légal :
std::string const* ps ;
void
ugly( std::string const& s )
{
ps = &s ;
}
int
main()
{
ugly( "doh" ), std::cout << *ps << std::endl ;
return 0 ;
}
(Évidemment, légal ou non, ce n'est pas une chose à faire.)
--
James Kanze (GABI Software) email:james.kanze (AT) gmail (DOT) com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34 |
|
| Back to top |
|
 |
|
|
You cannot post new topics in this forum You cannot reply to topics in this forum You cannot edit your posts in this forum You cannot delete your posts in this forum You cannot vote in polls in this forum
|
|