C++, valeur de Retour, référence, référence const

Pouvez-vous m'expliquer la différence entre le retour de la valeur de référence de la valeur, et const référence à la valeur?

Valeur:

Vector2D operator += (const Vector2D& vector)
{
    this->x += vector.x;
    this->y += vector.y;
    return *this;
}

Non-const référence:

Vector2D& operator += (const Vector2D& vector)
{
    this->x += vector.x;
    this->y += vector.y;
    return *this;
}

Const référence:

const Vector2D& operator += (const Vector2D& vector)
{
    this->x += vector.x;
    this->y += vector.y;
    return *this;
}

Quel est l'avantage de cette? Je comprends le sens derrière const référence en passant à la fonction que vous voulez vous assurer de ne pas modifier cette valeur de référence est de pointage à l'intérieur d'une fonction. Mais je suis confus par le sens du retour de la const de référence. Pourquoi le retour de référence est mieux que de retourner de la valeur, et pour lesquelles le retour de const référence est mieux que de retourner de non-const de référence?

  • double possible de votre C++ livre
InformationsquelleAutor Majak | 2014-02-14
  1. 20

    Il n'y a pas de différence, sauf si vous écrivez quelque chose de bizarre comme

    (v1 += v2) = v3;

    Dans le premier cas, la cession sera temporaire, et l'effet global sera v1 += v2.

    Dans le second cas, la cession sera à v1, de sorte que l'effet global sera v1 = v3.

    Dans le troisième cas, la cession ne sera pas autorisée. C'est probablement la meilleure option, car une telle étrangeté est presque certainement une erreur.

    Pourquoi le retour de référence est mieux que de retourner de la valeur?

    C'est potentiellement plus efficace: vous n'avez pas à faire une copie de l'objet.

    et pourquoi le retour de const référence est mieux que de retourner de non-const de référence?

    Vous empêcher étrangeté, comme l'exemple ci-dessus, tout en permettant encore moins bizarre chaînage comme 

    v1 = (v2 += v3);

    Mais, comme indiqué dans les commentaires, cela signifie que votre type ne prend pas en charge les mêmes formes de (ab)utilisation en tant que types intégrés, que d'aucuns considèrent comme souhaitable.

    • Je pense qu'il est discutable de savoir si const est mieux que les non-const, vous ne pouvez pas appeler une méthode qui est non-const sur le résultat de +=. Qu'en est (v1 += v2).non_const_fun();. Je sais qu'il est d'avis, et je donne à qui il peut paraître un peu bizarre, mais il n'a plus de sens que de (v1+=v2)=v3. Est-il vraiment un point dans l'interdire?
    • Je peux voir beaucoup de logique dans l'interdire, mais... le haut- += renvoie une modifiables lvalue, et le retour d'un non-const de référence est la chose la plus proche que dans un type défini par l'utilisateur. Ainsi, le principe de moindre surprise---définis par l'utilisateur les opérateurs devraient imiter le construit-en - - -,-dit-non-const de référence.
    • Cependant, const& empêche v1 = std::move(v2 += v3) de se déplacer. Vous ne savez pas si c'est intéressant ou pas.
    • En effet, il existe diverses opinions sur ce type de multi-effet des expressions doivent être autorisés. Je serais probablement de retour void, pour éviter toute mauvaise surprise, sauf s'il y a une exigence particulière pour permettre l'obscurcissement.
    • C'est vraiment bien rédigé point j'ai essayé de faire dans ma réponse. Une telle syntaxe que cette maquette exemple (v1+=v2)=v3 est prévu pour travailler. Et bien au moins, je m'attends à ce qu'il fonctionne car il pourrait fonctionner pour les types intégrés. Je me demande simplement d'une raison pour l'interdire. Est-ce seulement pour éventuellement rattraper "stupide" erreurs?
    • Juste pour être clair, je pense que c'est un très bon point, que vous pouvez modifier attendus/permis de syntaxe. Il pourrait être en vaut la peine. Je considère que c'est un "compromis". J'ai demandé des avis, parce que vous (tous les commentateurs ici) ont de loin supérieur de l'expérience que je fais.
    • v2) = v3 devrait être un comportement indéfini pour les construit dans le type (au moins, avant C++11---je ne suis pas sûr maintenant). La motivation (donc j'ai été dit par des gens qui connaissent) est de soutenir des choses comme int& func() { ... return x += y; } (en Supposant que x a suffisamment de vie). Je ne suis pas convaincu, et je les utilise régulièrement deux déclarations là-bas. Mais d'autres semblent avoir (ou au moins d'avoir eu) un avis différent.

    InformationsquelleAutor Mike Seymour
  2. 10

    Valeur:

    Retour par valeur signifie que vous êtes de retour une copie d'un objet. Cela met les exigences de la classe (il doit être copiable ou mobiles). Cela signifie que pour l'objet de certaines classes, retour par valeur peut être coûteux (dans un cas où RVO ou NRVO ne fonctionne pas ou est éteint). Cela signifie également que le nouvel objet est indépendant (sous réserve de sa conception) à partir d'autres objets et est une valeur qui lui est propre. C'est ce que vous devriez probablement de retour à partir de nombreux opérateurs binaires comme +, -, * et ainsi de suite.

    Non-const référence:

    Vous vraiment revenir un alias pour un autre objet. L'alias non const vous permet de modifier l'alias de l'objet. C'est ce que vous devriez retour de certains unaire oprators comme préfixe ++ et --, et * (déréférencement) comme vous voulez avoir la possibilité de modifier l'objet retourné.

    Est retourné par l'opérateur>>, et l'opérateur<< surchargé pour les cours d'eau. Cela permet de chaîner des opérateurs:

    cout << 5 << "is greater then" << 1 << endl;
cin >> myInt >> myFloat;

    Vous pouvez également référence à *ce mode lorsque vous voulez permettre le chaînage de méthodes ordinaires comme ceci:

    object.run().printLastRunStatistics();

    Const référence:

    Comme ci-dessus, mais vous NE pouvez pas modifier un alias de l'objet. Peut être utilisé au lieu de retourner en valeur lorsque l'objet retourné est cher pour copier et quand vous pouvez vous assurer de son existence après votre retour de la fonction.

    C'est ce que l'opérateur= renvoie généralement à permettre à plusieurs affectations dans un façon standard les types de les soutenir:

    a = b = c;

    Const-référence utilisée dans l'opérateur= empêche ce genre d'utilisation (non pris en charge par type standard, comme je me souviens bien):

    ++(a = b);

    qui devrait être admis s'il est normal de référence a été utilisé.

    InformationsquelleAutor Tomek
  3. 5

    C'est exactement la même que la transmission d'argument à la fonction.

    Vous voulez retourner un const de référence lorsque vous revenez d'une propriété d'un objet, que vous ne voulez pas être modifiés en dehors de ça. Par exemple: lorsque votre objet a un nom, vous pouvez le faire en suivant la méthode const std::string& get_name(){ return name; };. Qui est la plupart de façon optimale. Vous permettre une "lecture seule" l'accès à une propriété interne, avec copie-sur-retour.

    Lorsque vous êtes à la surcharge des opérateurs vous êtes censé renvoyer un objet qui est mutable, sinon certains de certains de la syntaxe qui est généralement attendu à l'emploi de produire des erreurs. Il est très important lorsque vous essayez un peu bizarre de chaînage.

    Par exemple l'option 3 ne fonctionnera pas avec quelque chose comme (v1 += v2).non_const_method(), Alors, ce qui suit:

    v1+=v2;
v1.non_const_method();
    • Ok il n'était pas propre pour moi. Donc "const" a en effet directement pour le retour de l'objet, donc on ne peut pas appeler cascade de fonctions sur elle. Si nous avions attribué objet renvoyé à notre objet, il n'est pas const plus. Merci à vous tous!
    InformationsquelleAutor luk32
  4. 4

    La différence entre retour par valeur et retour par référence prend effet au cours de l'exécution:

    Lorsque vous revenez d'un objet par valeur, le constructeur par copie est appelée, et une instance temporaire est créé sur la pile.

    Lorsque vous revenez d'un objet par référence, tous les ci-dessus ne prend pas de place, qui conduit à l'amélioration de la performance.

    La différence entre retour par référence et retour-en-constant-référence a aucun moment de l'exécution, et il est simplement là pour vous protéger contre l'écriture de code erroné.

    Par exemple, avec Vector2D& operator += (const Vector2D& vector), vous pouvez le faire:

    (x+=y)++ ou (x+=y).func() où func est un non-const fonction dans la classe Vector2D.

    Mais avec const Vector2D& operator += (const Vector2D& vector), le compilateur génère une erreur pour toute tentative semblable.

    InformationsquelleAutor barak manos
  5. 1

    Comme l'a souligné mais luk32 c'est juste pour s'assurer qu'aucune modification n'est permise pour les objets retournés par cette fonction.
    Cela peut fondamentalement vous aider à trouver votre logique erreurs au moment de la compilation.
    Supposons que vous êtes sûr de ne pas modifier un objet, et que votre code est modification de l'objet, il peut être suivi. Il peut être pensé à une bonne pratique de codage.

    InformationsquelleAutor 51k