reference anomyme en parametre de fonction

Salut,

Y a t il une astuce pour faire fonctionner le code suivant sans passer par une variable temporaire, donc en gardant la variable temporaire anomyme :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

#include <iostream> #include <string>   using namespace std;   void takeRef( string & ref);   int main() {   //pas de temp ? //string temp("hello");   takeRef( static_cast<string &>(string("Hello")) ); // marche pas takeRef( string("Hello") ); // marche pas   }   void takeRef( string & ref) { cout << ref << endl; }

---

et avec un const, ça échoue aussi?

ca passe en mettant takeRef( const string % ref );
et en castant avec le const.

C est pas tt a fait ce que je veux.
J ai simplifie dans cet exemple et le string et en realite une autre classe.

Voici un exemple qui represente un peut plus ma problematique (sans les string).
admetons que les class "iterat" et "aClass" ne soient pas a moi :

using namespace std;
class iterat
{
public:
int num;
iterat():num(0){}
iterat(int x):num(x){}
};

class aClass
{
iterat it;
public:
aClass(){}
aClass(int x):it(x){}

iterat giveIter(){return it;}
};

void takeRef( iterat & ref );

int main() {

aClass obj;

//pas de temp ?
iterat lclIt = obj.giveIter();
takeRef( lclIt ); // OK, mais passage par une variable locale

takeRef( static_cast< iterat &>( obj.giveIter() )); // marche pas
takeRef( obj.giveIter() ); // marche pas

}

void takeRef( iterat & ref)
{
cout << ref.num << endl;
}

et voici l erreur g++ 4.0.2:

In function ‘int main()’:
42: error: invalid static_cast from type ‘iterat’ to type ‘iterat&’
43: error: invalid initialization of non-const reference of type ‘iterat&’ from a temporary of type ‘iterat’
32: error: in passing argument 1 of ‘void takeRef(iterat&)’

Si iterat prend en paramètre une référence non constante, c'est qu'il veut modifier ce paramètre. Si tu lui passe une variable temporaire, tu n'auras aucun moyen d'accèder à cette valeur modifiée, c'est pourquoi le compilateur interdit ce genre de code, qui est souvent signe d'erreur.

En l'occurence, ton problème est que la fonction takeRef est mal définie : Si elle n'a pas pour rôle de modifier son argument, pourquoi le prendre par référence non constante ?

Citation:

---

Envoyé par GCC

invalid initialization of non-const reference of type ‘iterat&’ from a temporary of type ‘iterat’

---

En quoi l'ajout de const n'est-il pas "tout à fait ce que tu veux" ?
Il est normal que le C++ n'accepte pas une référence non-constante sur un objet temporaire: les modifications seraient perdues de toute façon, ce serait plus une source de bugs qu'autre chose...

PS: Je viens de tester: Avec const, ça marche avec et sans cast:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

#include <iostream> using namespace std;   //--- classes --- class iterat { public: int num; iterat():num(0){} iterat(int x):num(x){} };   class aClass { iterat it; public: aClass(){} aClass(int x):it(x){}   iterat giveIter(){return it;} };   //--- Fonctions --- void takeRef( iterat const & ref );     /* M A I N   ------- */ int main() { aClass obj;   //pas de temp ? iterat lclIt = obj.giveIter(); takeRef( lclIt ); // OK, mais passage par une variable locale   takeRef( static_cast< iterat const &>( obj.giveIter() )); //ça marche takeRef( obj.giveIter() ); //ça marche aussi   return 0; }     /* Fonction test utilisant une référence   ------------------------------------- */ void takeRef( iterat const & ref) { cout << ref.num << endl; }

---

Edit: Ah, post croisé.

Citation:

---

Envoyé par Médinoc

Il est normal que le C++ n'accepte pas une référence non-constante sur un objet temporaire: les modifications seraient perdues de toute façon, ce serait plus une source de bugs qu'autre chose...

---

Je comprends bien la logique, mais pourquoi n'est-elle pas poussée jusqu'au bout? Si on a

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

struct s { void f(); // non const   s g(); on peut faire Code: g().f(); mais pas };   void f(s&);   s g();

---

on peut faire

Code:

---

g().f();

---

mais pas

Code:

---

f(g());

---

et j'ai du mal à voir pourquoi le premier serait plus sûr que le second. (A noter qu'il fut un temps où le second était admis; certain compilateur que j'utilise ne mets d'ailleurs qu'un warning).

Ok merci,
Je comprend que mon temporaire anonyme soit un const,

Mais maintenant imaginons que cet iterateur iterat (temporaire) dans takeRef() manipule un autre object, dont il a acces en interne, qui lui est permanent et ne serra pas detruit avec l iterateur temporaire a la sortie de la fonction takeRef().

De plus takeRef() veux effectuer des operations d'ecritures sur cet object permanent et le modifier. L iterateur iterat doit-il rester "const" pour cela ?

Sinon comment faire ?