Constructeur avec un string par défaut.

Bonjour

J'ai une question simple

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

Code:

---

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

---

puis implémentation:

Code:

---

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

---

ca passe.
Mais quand je fais ceci:

Code:

---

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

---

puis implémentation:

Code:

---

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

Et avec ça ?

Code:

---

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

---

(je n'ai pas testé)

hmm pas idiot comme idée
je vais tester

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. ;)

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

Code:

---

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

---

Tu as le droit d'appeler :

Code:

---

1 2 3

int i = 5; f(i); g(i);

---

Mais par contre :

Code:

---

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.

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 :mouarf:)
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é :mrgreen:

Citation:

---

Envoyé par Lintel-oo

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é :mrgreen:

---

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

Code:

---

1 2 3 4

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

---

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


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:

---

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 :mouarf:)

Salut,

Citation:

---

Envoyé par Kaamui

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

Code:

---

1 2 3 4

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

---

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


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:

---

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 :mouarf:)

---

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 :D

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 :D ) .

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 :

Citation:

---

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:

---

void foo(un_type & )

---

ou

Code:

---

void foo(un_type const & )

---

voir meme

Code:

---

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:

---

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

---

ou

Code:

---

void foo(un_type arg=... )

---

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