Discussion :

[deubelte]

Bonjour
Il me semble qu'il y a aucune différence entre int et int&.
Par exemple, ces deux fonctions sont identiques:

Code :

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

1
2
3
void f(int o); 
et
void f(int&o);

En gros, pour les types primaires, cela ne sert à rien de passer une variable par référence ou par valeur.
(Donc autant ne faire passer que des int).
Idem pour cette fonction:

Code :

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

1
2
int f(void);
int& f(void);

Mais je ne me rappelle plus pourquoi.

Merci

[3DArchi]

int et int& sont 2 types radicalement différents. Le premier est un entier, le second est une référence vers un entier. Le comportement n'est pas le même :

Code :

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

1
2
3
4
5
6
7
f(int&);
int main()
{
   int i=0;
   f(i);//ok
   f(3);// erreur
}

Code :

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

1
2
3
4
5
6
7
f(int );
int main()
{
   int i=0;
   f(i);//ok
   f(3);// ok
}

Code :

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

1
2
3
4
5
6
7
8
9
10
f(int&o)
{
   ++o;
}
int main()
{
   int i=0;
   f(i);//ok
   assert(1==i);
}

Code :

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

1
2
3
4
5
6
7
8
9
10
f(int o)
{
   ++o;
}
int main()
{
   int i=0;
   f(i);//ok
   assert(0==i);
}

Quand à la valeur retour :
int f(); retourne une valeur par copie
int& f(); retourne une référence. L'objet a intérêt d'exister après le retour de la fonction et tant que la référence est liée. Sinon, undefined behaviour (dans ce cas, c'est souvent un plantage).

Cette question indique la nécessité de se replonger dans les premiers cours pour débutant.

[deubelte]

je me doute bien que si on a :

int f(int&) et qu'on fait f(4), ca va planter.

mais moi, je me restreint au cas où:

Code :

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

1
2
3
int f(int& a)
{...
}

Code :

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

1
2
3
 
int a=4;
f(a)

et

Code :

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

1
2
3
int f(int a)
{...
}

Code :

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

1
2
3
 
int a=4;
f(a)

sont, ils me semblent identiques, dans l'appel de la fonction f.

[screetch]

bah non, comme 3darchi l'a pointé:

Code :

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

1
2
3
4
5
6
7
8
9
10
f(int o)
{
   ++o;
}
int main()
{
   int i=0;
   f(i);//ok
   assert(0==i);
}

Code :

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

1
2
3
4
5
6
7
8
9
10
f(int&o)
{
   ++o;
}
int main()
{
   int i=0;
   f(i);//ok
   assert(1==i);
}

[deubelte]

oui, mais ce que je voulais dire, c'est que quand tu fais f(Obj o), tu appelles le constructeur par copie, ici, non: f(Obj &o) alors que pour un type primaire, f(int o) ou f(int &o) c'est la même chose, pas d'appel au constructeur par copie.

Vous voyez?

[screetch]

tout s'eclaire si tu dis const int& au lieu de int&pour un entier, non, ca ne change pas grand chose, souvent les compilateurs passent ca dans les registres si ils peuvent.
Pour un type plus complexe effectivement, sans passer des références const, ca fait une copie, ce qui est chiant (vas y que je te copie une list ou un vector...)