Discussion :

[deubelte]

Bonjour

J'ai une question simple

J'ai un constructeur qui prend comme argument par défaut un string.
Quand je fais ceci:

Code :

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

CTOR (...., const std::string& bondmnemonic="");

puis implémentation:

Code :

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

CTOR (...., const std::string& bondmnemonic)

ca passe.
Mais quand je fais ceci:

Code :

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

CTOR (...., std::string& bondmnemonic="");

puis implémentation:

Code :

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

CTOR (...., std::string& bondmnemonic)

ce me renvoie comme erreur:

error C2440: 'default argument' : cannot convert from 'const char [1]' to 'std::string &'

Il n'existe pas de constructeur de string non qui peuvent etre construit avec ""?

Merci

[cob59]

Et avec ça ?

Code :

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

CTOR (...., std::string& bondmnemonic=std::string())

(je n'ai pas testé)

[deubelte]

hmm pas idiot comme idée
je vais tester

[Ekleog]

Si tu prends une référence non constante, c'est que tu comptes modifier la valeur passée en argument.
Dès lors, quelle est la logique de mettre un argument par défaut ?

La solution vient donc de la surcharge du constructeur, avec et sans ce dernier paramètre.

[JolyLoic]

C'est normal, et pas lié aux valeurs par défaut :

Code :

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

1
2
void f(int const &i);
void g(int &i)

Tu as le droit d'appeler :

Code :

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

1
2
3
int i = 5;
f(i);
g(i);

Mais par contre :

Code :

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

1
2
f(5);
g(5); // Erreur ici, il veut une référence à une vraie variable

Une référence constante peut référence une variable temporaire crée à partir d'une valeur, une référence non constante a besoin d'une vraie variable.
Et bien là, c'est pareil, comme valeur par défaut, tu peux passer une valeur là où une référence constante est attendue, pas là où un référence est attendue.

[Lintel-oo]

Je pense que cela est tout à fait normal puisque quand tu declares (... std::string &g = "") il s'agit d'une référence non constante et une référence non constante ne peux pas être initialisée par un objet temporaire, ici ton std::string (je ne saurais pas te dire pourquoi mais je sais que cela ne marche pas )
C'est pourquoi tu ne peux ni mettre std::string &g = "" ni std::string &g = std::string("..."), mais tu dois mettre const std::string &g = "" ou const std::string &g = std::string("...").
Et c'est pareil pour les types de base int, double...

Edit : grillé

[Kaamui]

C'est pourquoi tu ne peux ni mettre std::string &g = "" ni std::string &g = std::string("..."), mais tu dois mettre const std::string &g = "" ou const std::string &g = std::string("...").

Edit : grillé

Je ne penses pas que ce soit cela que dise Mr Loïc Joly. il dit que si ton constructeur est :

Code :

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

1
2
3
4
 
CTOR (...., const std::string& bondmnemonic="");
//ou
CTOR (...., std::string& bondmnemonic="");

(d'ailleurs std::string() pour initialiser sera plus Joly )


Dans le premier cas les variables que tu passe en paramètre peuvent ne pas avoir été définies avant.

Dans le deuxième cas, pour que ça marche, il faut faire ceci :

Code :

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

1
2
3
4
5
 
std::string str("blabla");
std::string& r_str = str;
 
CTOR(..., r_str);

(et maintenant je croise les doigts pour ne pas avoir dit de conneries )

[koala01]

Salut,

Je ne penses pas que ce soit cela que dise Mr Loïc Joly. il dit que si ton constructeur est :

Code :

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

1
2
3
4
 
CTOR (...., const std::string& bondmnemonic="");
//ou
CTOR (...., std::string& bondmnemonic="");

(d'ailleurs std::string() pour initialiser sera plus Joly )


Dans le premier cas les variables que tu passe en paramètre peuvent ne pas avoir été définies avant.

Dans le deuxième cas, pour que ça marche, il faut faire ceci :

Code :

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

1
2
3
4
5
 
std::string str("blabla");
std::string& r_str = str;
 
CTOR(..., r_str);

(et maintenant je croise les doigts pour ne pas avoir dit de conneries )

En fait, cela revient au même...

Le langage autorise la création d'une varialbe (anonyme) temporaire, uniquement lorsque l'argument est soit une copie, soit une référence constante.

La raison est simple : ainsi que le dit le terme, une variable temporaire anonyme est... anonyme et temporaire

Comme elle est anonyme, il est impossible de réutiliser cette variable par la suite dans la fonction appelante, et, comme elle est temporaire, elle est détruite dés que l'on quitte la portée de la fonction à laquelle elle est passée en paramètre ( ce qui empêche, à nouveau, d'y avoir accès depuis la fonction appelante ) .

Il n'y a donc aucun sens à permettre qu'une référence sur une variable anonyme puisse etre modifiée dans la fonction appelante, étant donné... que toute modification apportée par la fonction sera d'office perdue

Lorsque tu décides de fournir une valeur par défaut à un argument, c'est comme si tu disais au compilateur :

Tu dois t'attendre à ce que l'on te fournisse un objet de type XXX, mais, si on ne t'en donne pas, tu peux utiliser un objet qui aura été initialisé de cette manière, que tu devras créer toi meme pour l'utiliser dans la fonction.

Ce qui nous met, tu l'auras surement remarqué, exactement dans le cas d'une variable temporaire anonyme

C'est la raison pour laquelle tu peux parfaitement écrire

Code :

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

void foo(un_type & )

ou

Code :

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

void foo(un_type const & )

voir meme

Code :

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

void foo(un_type )

mais que tu ne peux fournir une valeur par défaut que pour les prototypes qui donnent l'assurance soit qu'aucune modification ne risque de devoir se répercuter dans la fonction appelante, à savoir

Code :

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

void foo(un_type const &  arg=... )

ou

Code :

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

void foo(un_type  arg=... )

Est-ce que c'est plus clair, maintenant?