Quiero sobrecargar una función para que manipule su argumento de alguna manera y luego devuelva una referencia al argumento, pero si el argumento no es mutable, entonces debería devolver un @ manipuladupd del argumento en su lugar. Después de jugar con él durante años, esto es lo que se me ocurrió.

using namespace std;

string& foo(string &in)
{
    in.insert(0, "hello ");
    return in;
}

string foo(string &&in)
{
    return move(foo(in));
}

string foo(const string& in)
{
    return foo(string(in));
}

Parece que este código funciona correctamente, pero me interesa saber si alguien puede pensar en una mejor manera de hacerlo.

Aquí hay un programa de prueba:

int main(void)
{
    string var = "world";
    const string var2 = "const world";
    cout << foo(var) << endl;
    cout << var << endl;

    cout << foo(var2) << endl;
    cout << var2 << endl;

    cout << foo(var + " and " + var2) << endl;
    return 0;
}

La salida correcta es

hello world
hello world
hello const world
const world
hello hello world and const world

Supongo que sería un poco más ordenado si pudiera hacer esto:

string& foo(string &in)
{
    in.insert(0, "hello ");
    return in;
}

string foo(string in)
{
    return move(foo(in));
}

Por supuesto, eso no funciona porque la mayoría de las funciones llama afoo sería ambiguo, incluida la llamada enfoo ¡sí mismo! Pero si de alguna manera pudiera decirle al compilador que priorice el primero ...

Como dije, el código que publiqué funciona correctamente. Lo principal que no me gusta es el código extra repetitivo. Si tuviera un montón de funciones como esa, se volvería un desastre y la mayoría sería muy repetitivo. Como segunda parte de mi pregunta: ¿alguien puede pensar en una forma de generar automáticamente el código para la segunda y tercerafoo funciones? p.e

// implementation of magic_function_overload_generator
// ???

string& foo(string &in);
magic_function_overload_generator<foo>;

string& bar(string &in);
magic_function_overload_generator<bar>;

// etc