Considere estas clases:

<code>#include <iostream>
#include <string>

class A
{
    std::string test;
public:
    A (std::string t) : test(std::move(t)) {}
    A (const A & other) { *this = other; }
    A (A && other) { *this = std::move(other); }

    A & operator = (const A & other)
    {
        std::cerr<<"copying A"<<std::endl;
        test = other.test;
        return *this;
    }

    A & operator = (A && other)
    {
        std::cerr<<"move A"<<std::endl;
        test = other.test;
        return *this;
    }
};

class B
{
    A a;
public:   
    B (A && a) : a(std::move(a)) {}
    B (A const & a) : a(a) {}
};
</code>

Al crear unB, Siempre tengo un camino de avance óptimo paraA, un movimiento para los valores o una copia para los valores.

¿Es posible lograr el mismo resultado con un constructor? No es un gran problema en este caso, pero ¿qué pasa con los múltiples parámetros? Necesitaría combinaciones de cada posible aparición de valores y valores en la lista de parámetros.

Esto no se limita a los constructores, sino que también se aplica a los parámetros de la función (por ejemplo, los configuradores).

Nota: esta pregunta es estrictamente sobreclass B; class A existe solo para visualizar cómo se ejecutan las llamadas copiar / mover.