Discussion :

[seb9999]

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 :

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

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;
}

[Médinoc]

et avec un const, ça échoue aussi?

[seb9999]

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.

[seb9999]

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&)’

[JolyLoic]

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 ?

[Médinoc]

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 :

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

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é.

[Jean-Marc.Bourguet]

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 :

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

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 :

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

g().f();

mais pas

Code :

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

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

[seb9999]

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 ?