¿Cuáles son los casos de uso para tener un retorno de función por valor de const para tipo no incorporado?

Question

Recientemente he leído que tiene sentido al volver por el valor de una función para calificar el tipo de retorno const de tipos no incorporadas, por ejemplo:

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

estoy luchando para entender los beneficios de esto, una vez que el el objeto ha sido devuelto, seguramente es la elección de quienes llaman para decidir si el objeto devuelto debe ser const?

Answer 1

Básicamente, hay un ligero problema de idioma aquí.

std::string func() { 
    return "hai"; 
} 

func().push_back('c'); // Perfectly valid, yet non-sensical 

Devolución de const rvalues ​​es un intento de evitar dicho comportamiento. Sin embargo, en realidad, hace mucho más daño que bien, porque ahora que las referencias rvalue están aquí, vas a evitar la semántica de movimiento, lo cual es una mierda, y el comportamiento anterior probablemente se evitará mediante el uso juicioso de rvalue y lvalue *this sobrecarga. Además, tendrías que ser un poco idiota para hacer esto de todos modos.

Answer 2

No hay ningún beneficio al devolver por valor. No tiene sentido.

La única diferencia es que se evita que la gente se lo emplea como valor-I:

class Foo 
{ 
    void bar(); 
}; 

const Foo foo(); 

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

Answer 3

Ocasionalmente es útil. Vea este ejemplo:

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; 
} 

Tenga en cuenta que el valor devuelto por operator+ normalmente sería considerado un temporal. Pero está siendo claramente modificado. Eso no es exactamente deseado.

Si declara el tipo de devolución de operator+ como const I, no se compilará.

Answer 4

Como nadie lo ha señalado aún, es bastante útil en objetos proxy, con casos de uso real.

Imagínese que usted está escribiendo un tipo matrix y desea utilizar de esta manera:

Matrix<3, 3> matrix; 
Matrix<1, 3> rowVector; 

/* assign a row */ 
matrix[1] = rowVector; 

Para ello, se vuelve un nuevo objeto proxy de operator[]. Cuando se opera en un const Matrix, aún desea poder acceder a los datos a través del proxy, pero prohíbe el acceso de escritura. Esto se puede hacer volviendo por el valor const.

template<size_t Rows, size_t Cols> 
class Matrix { 
    class RowProxy { 
     Matrix& m; 
     size_t row; 
     /* ... operator= and operator[] */ 
    }; 

    RowProxy operator[](size_t row) { return RowProxy(*this, row); } 
    const RowProxy operator[](size_t row) const { return RowProxy(*this, row); } 
    // ^~~~ here the const is very useful and important 
};