Passage par Référence / Valeur en C++

Je pense que beaucoup de confusion est généré par le fait de ne pas faire ce que l'on entend par passé par référence. Quand certaines personnes disent passer par référence ils signifient généralement pas l'argument lui-même, mais plutôt l'objet référencé. Certains autres disent que le passage par référence signifie que l'objet ne peut pas être modifié dans le destinataire de l'appel. Exemple:

struct Object {
    int i;
};

void sample(Object* o) { //1
    o->i++;
}

void sample(Object const& o) { //2
    //nothing useful here :)
}

void sample(Object & o) { //3
    o.i++;
}

void sample1(Object o) { //4
    o.i++;
}

int main() {
    Object obj = { 10 };
    Object const obj_c = { 10 };

    sample(&obj); //calls 1
    sample(obj) //calls 3
    sample(obj_c); //calls 2
    sample1(obj); //calls 4
}

Certaines personnes prétendent que le 1 et le 3 sont passer par référence, tandis que 2 serait le passage par valeur. Un autre groupe de gens disent tous, mais le dernier est le passage par référence, parce que l'objet lui-même n'est pas copié.

Je voudrais attirer une définition de ce là ce que je demande à être passer par référence. Un aperçu général sur il peut être trouvé ici: Différence entre les passer par référence et le passage par valeur. La première et la dernière sont le passage par valeur, et les deux du milieu sont passer par la référence:

    sample(&obj);
       //yields a `Object*`. Passes a *pointer* to the object by value. 
       //The caller can change the pointer (the parameter), but that 
       //won't change the temporary pointer created on the call side (the argument). 

    sample(obj)
       //passes the object by *reference*. It denotes the object itself. The callee
       //has got a reference parameter.

    sample(obj_c);
       //also passes *by reference*. the reference parameter references the
       //same object like the argument expression. 

    sample1(obj);
       //pass by value. The parameter object denotes a different object than the 
       //one passed in.

Je vote pour la définition suivante:

Un argument (1.3.1) est passé par référence si et seulement si le paramètre correspondant de la fonction appelée est le type de référence et le paramètre de référence se lie directement à l'argument de l'expression (8.5.3/4). Dans tous les autres cas, nous avons à faire avec le passage par valeur.

Cela signifie que suivant est le passage par valeur:

void f1(Object const& o);
f1(Object()); //1

void f2(int const& i);
f2(42); //2

void f3(Object o);
f3(Object());     //3
Object o1; f3(o1); //4

void f4(Object *o);
Object o1; f4(&o1); //5

1 est le passage par valeur, car il n'est pas directement lié. La mise en œuvre peut copier le temporaire et le lier ensuite que temporaire à la référence. 2 est le passage par valeur, parce que la mise en œuvre initialise une temporaire de la littéralité et se lie alors à la référence. 3 est le passage par valeur, parce que le paramètre n'a pas de type de référence. 4 est le passage par valeur pour la même raison. 5 est le passage par valeur, parce que le paramètre n'a pas de type de référence. Les cas suivants sont passage par référence (par les règles de 8.5.3/4 et autres):

void f1(Object *& op);
Object a; Object *op1 = &a; f1(op1); //1

void f2(Object const& op);
Object b; f2(b); //2

struct A { };
struct B { operator A&() { static A a; return a; } };
void f3(A &);
B b; f3(b); //passes the static a by reference

Merci beaucoup à tous pour tous ces commentaires!

J'ai cité cette phrase à partir d'un cours en ligne:
http://www.cs.cornell.edu/courses/cs213/2002fa/lectures/Lecture02/Lecture02.pdf

la première page le 6 diapositive

"
Le passage par VALEUR
La valeur d'une variable est transmise à la fonction
Si la fonction modifie la valeur, les modifications restent au sein de l'
la portée de cette fonction.

Passage par RÉFÉRENCE
Une référence à la variable est transmise à la fonction
Si la fonction modifie la valeur, les modifications apparaissent également
dans le cadre de l'appel de la fonction.

"

Merci beaucoup encore une fois!

Comme je l'analyser, ces mots sont faux. Il faut lire "Si la fonction modifie la valeur, les modifications apparaissent également dans le champ d'application de la fonction d'appel lorsque le passage par référence, mais pas lors du passage par valeur".