int vs const int&

En C++, il est très courant de ce que je considère comme un anti-modèle qui utilise const T& comme une façon intelligente de dire T lorsque vous traitez avec des paramètres. Toutefois, une valeur et une référence (peu importe si const ou non) sont deux choses complètement différentes et toujours et aveuglément à l'aide de références à la place des valeurs peut conduire à des bogues subtils.

La raison en est que lorsque vous traitez avec des références vous devez tenir compte de deux questions qui ne sont pas présents avec des valeurs: vie et aliasing.

Comme un exemple d'un endroit où cet anti-modèle est appliqué est le standard de la bibliothèque elle-même, où std::vector<T>::push_back accepte comme paramètre une const T& au lieu d'une valeur, ce qui peut mordre le dos par exemple dans le code comme:

std::vector<T> v;
...
if (v.size())
    v.push_back(v[0]); //Add first element also as last element

Ce code est une bombe à retardement, car std::vector::push_back veut const référence mais faire la push_back peut exiger une réaffectation et si cela se produit signifie que, après la réaffectation de référence reçu ne serait plus valide (vie question) et vous entrez dans le Comportement Indéfini royaume.

Aliasing questions sont également une source de problèmes subtils si const références sont utilisées à la place des valeurs. J'ai été mordu par exemple par le code de ce genre:

struct P2d
{ 
    double x, y;
    P2d(double x, double y) : x(x), y(y) {}
    P2d& operator+=(const P2d& p) { x+=p.x; y+=p.y; return *this; }
    P2d& operator-=(const P2d& p) { x-=p.x; y-=p.y; return *this; }
};

struct Rect
{
    P2d tl, br;
    Rect(const P2d& tl, const P2d& br) : tl(tl), bt(br) {}
    Rect& operator+=(const P2d& p) { tl+=p; br+=p; return *this; }
    Rect& operator-=(const P2d& p) { tl-=p; br-=p; return *this; }
};

Le code semble à première vue assez sûr, P2d est une bidimensionnelle point, Rect est un rectangle et en ajoutant ou en supprimant un point signifie transformer le rectangle.

Si toutefois de traduire le rectangle de retour à l'origine que vous écrivez myrect -= myrect.tl; le code ne fonctionnera pas parce que la traduction de l'opérateur a été défini en acceptant une référence (en l'occurrence) fait référence à un membre de la même instance.

Cela signifie que, après la mise à jour de la topleft avec tl -= p; la topleft sera (0, 0) comme il se doit, mais aussi p deviendra en même temps (0, 0) parce que p est juste une référence vers le haut-membre de gauche et donc la mise à jour de coin en bas à droite ne fonctionne pas car il va le traduire par (0, 0) donc faire à peu près rien.

S'il vous plaît ne vous laissez pas berner en pensant que const référence, c'est comme une valeur à cause de la parole const. Ce mot n'existe que pour vous donner des erreurs de compilation si vous essayez de modifier l'objet référencé à l'aide de cette référence, mais cela ne signifie pas que l'objet référencé est constante. Plus précisément l'objet référencé par un const ref peut changer (par exemple, en raison de aliasing), et peuvent même sortir de l'existence pendant que vous l'utilisez (vie question).

Dans const T& le mot const exprime une propriété de la référence, pas de la objet référencé: c'est la propriété qui rend impossible de l'utiliser pour modifier l'objet. Probablement readonly aurait été un meilleur nom que const a de l'OMI, l'effet psychologique de pousser l'idée que l'objet va être constante pendant que vous utilisez la référence.

Vous pouvez bien sûr obtenir impressionnant la vitesse à l'aide de références au lieu de copier les valeurs, en particulier pour les grandes classes. Mais vous devriez toujours penser à l'aliasing et la durée de vie des problèmes lors de l'utilisation de références, car sous le capot, ils sont juste des pointeurs vers d'autres données.
Pour les "indigènes" des types de données (entiers, des doubles, des pointeurs) références sont cependant, en réalité, va être plus lent que les valeurs et il n'y a rien à gagner à les utiliser à la place des valeurs.

Également const référence signifiera toujours des problèmes pour l'optimiseur que le compilateur est forcé d'être paranoïaque et chaque fois qu'un inconnu code est exécuté, il doit l'assumer que tous les objets référencés peuvent avoir une valeur différente (const pour une référence signifie absolument RIEN pour l'optimiseur; ce mot est-il que pour aider les programmeurs à - personnellement, je suis pas si sûr, c'est d'une grande aide, mais c'est une autre histoire).

int & et int ne sont pas interchangeables! En particulier, si vous renvoyer une référence à une pile locale variable, le comportement est indéfini, par exemple:

int &func()
{
    int x = 42;
    return x;
}

Vous peut renvoyer une référence à quelque chose qui ne sera pas détruite à la fin de la fonction (par exemple, un statique, ou un membre de la classe). C'est donc valide:

int &func()
{
    static int x = 42;
    return x;
}

et le monde extérieur, a le même effet que le retour de la int directement (à l'exception que vous pouvez maintenant le modifier, c'est pourquoi vous voyez const int & beaucoup).

L'avantage de la référence est qu'aucune copie n'est nécessaire, ce qui est important si vous faites affaire avec de grands objets de la classe. Cependant, dans de nombreux cas, le compilateur peut optimiser ce que l'écart; voir, par exemple,http://en.wikipedia.org/wiki/Return_value_optimization.

Au lieu de "penser" c'est optimisé par le compilateur, pourquoi ne pas vous obtenez l'assembleur d'inscription et de trouver pour vous?

indésirable.c++:

int my_int()
{
    static int v = 5;
    return v;
}

const int& my_int_ref()
{
    static int v = 5;
    return v;
}

Généré assembleur de sortie (élidée):

_Z6my_intv:
.LFB0:
    .cfi_startproc
    .cfi_personality 0x3,__gxx_personality_v0
    movl    $5, %eax
    ret
    .cfi_endproc

...

_Z10my_int_refv:
.LFB1:
    .cfi_startproc
    .cfi_personality 0x3,__gxx_personality_v0
    movl    $_ZZ10my_int_refvE1v, %eax
    ret

La movl des instructions dans les deux sont très différents. Le premier se déplace 5 en EAX (qui se trouve être le registre traditionnellement utilisé pour les valeurs de retour en x86 code C) et le second se déplace l'adresse d'une variable (détails gommés pour plus de clarté) dans EAX. Cela signifie que la fonction d'appel dans le premier cas peut juste utiliser directement registre des opérations sans frapper la mémoire à utiliser la réponse tandis que dans le second, il a frappé la mémoire à travers le pointeur retourné.

Donc, on dirait que c'est pas optimisé loin.

C'est plus que les autres réponses que vous avez été donné ici d'expliquer pourquoi T et const T& ne sont pas interchangeables.