Devolver un objeto de una clase desde una función por valor

Considere el caso en el que devuelve un objeto de una clase desde una función por valor. En este escenario, el objeto devuelto normalmente se considera un valor l, lo que significa que tiene un nombre y una dirección en la memoria. Sin embargo, ciertas circunstancias pueden hacer que el objeto devuelto sea tratado como un valor r, un objeto temporal sin nombre o dirección.

La regla de movimiento implícito

C define un regla de movimiento implícita que puede aplicarse al devolver un objeto por valor. Esta regla establece que si se cumplen las siguientes condiciones:

• La expresión devuelta es un valor x (una expresión que denota un objeto temporal que no es un valor l).
• La clase del El objeto devuelto tiene un constructor de movimiento.
• Se puede acceder al constructor de movimiento.

En tales casos, se invocará el constructor de movimiento en lugar del constructor de copia. Este comportamiento tiene como objetivo optimizar el rendimiento evitando copias innecesarias.

Ejemplo 1

En este ejemplo, el objeto devuelto i es un valor l, por lo que el constructor de copia test( const test&z) se invoca:

class test {
public:
    test(int y) { printf("test(int y)\n"); }
    test() { printf("test()\n"); }
    test(const test& z) { printf("test(const test&z)\n"); }
};
test Some_thing() {
    test i;
    return i;
}

Salida:

test()
test(const test&z)

Ejemplo 2

Sin embargo, en el siguiente ejemplo, el objeto devuelto i se trata como un valor x y el constructor de movimiento test( test&& s) se invoca porque el objeto es temporal y el constructor de movimiento es viable:

class test {
public:
    test(int y) { printf("test(int y)\n"); }
    test() { printf("test()\n"); }
    test(test&& s) { printf("test(test&& s)\n"); }
};
test Some_thing() {
    test i;
    return i;
}

Salida:

test()
test(test&& s)

Ejemplo 3

Si no se proporciona un constructor de movimiento o se elimina explícitamente, la regla de movimiento implícita no se puede aplicar y el el programa no podrá compilar:

class test {
public:
    test(test&& z) = delete;
    test(int y) { printf("test(int y)\n"); }
    test() { printf("test()\n"); }
    test(const test& z) { printf("test(const test&z)\n"); }
};
test Some_thing() {
    test i;
    return i;
}

Conclusión

Al devolver un objeto por valor, la regla de movimiento implícita se puede aplicar bajo condiciones específicas, lo que da como resultado que se invoque el constructor de movimiento. Comprender este comportamiento es crucial para optimizar el código y prevenir errores de compilación.