Quels sont les cas d'utilisation pour qu'une fonction renvoie une valeur const pour un type non intégré ?

Question

Récemment, j'ai lu qu'il est logique, lors du retour par valeur d'une fonction, de qualifier le type de retour const pour les types non intégrés, par exemple :

 const Result operation() {
    //..do something..
    return Result(..);
}

J'ai du mal à comprendre les avantages de cela, une fois que l'objet a été renvoyé, c'est sûrement le choix de l'appelant de décider si l'objet renvoyé doit être const?

Answer 1

C'est parfois utile. Voir cet exemple :

 class I
{
public:
    I(int i)                   : value(i) {}
    void set(int i)            { value = i; }
    I operator+(const I& rhs)  { return I(value + rhs.value); }
    I& operator=(const I& rhs) { value = rhs.value; return *this; }

private:
    int value;
};

int main()
{
    I a(2), b(3);
    (a + b) = 2; // ???
    return 0;
}

Notez que la valeur renvoyée par operator+ serait normalement considérée comme temporaire. Mais il est clairement en train d'être modifié. Ce n'est pas exactement souhaité.

Si vous déclarez le type de retour de operator+ comme const I , la compilation échouera.

Answer 2

Il n'y a aucun avantage à retourner par valeur. Cela n'a pas de sens.

La seule différence est qu'il empêche les gens de l'utiliser comme une lvalue :

 class Foo
{
    void bar();
};

const Foo foo();

int main()
{
    foo().bar(); // Invalid
}