C++
Copiando vs Asignación

Sintaxis

• Copia Constructor
• MyClass (const MyClass y otros);
• MyClass (MyClass y otros);
• MyClass (const. Volátil MyClass y otros);
• MyClass (MyClass volátil y otros);
• Constructor de Asignaciones
• MyClass & operator = (const MyClass & rhs);
• MyClass & operator = (MyClass & rhs);
• MyClass & operator = (MyClass rhs);
• const MyClass & operator = (const MyClass & rhs);
• const MyClass & operator = (MyClass & rhs);
• const MyClass & operator = (MyClass rhs);
• Operador MyClass = (const MyClass & rhs);
• Operador MyClass = (MyClass & rhs);
• Operador MyClass = (myClass rhs);

Parámetros

Observaciones

Operador de Asignación

El Operador de asignación es cuando reemplaza los datos con un objeto ya existente (previamente inicializado) con los datos de algún otro objeto. Tomemos esto como un ejemplo:

// Assignment Operator
#include <iostream>
#include <string>

using std::cout;
using std::endl;

class Foo
{
  public:
    Foo(int data)
    {
        this->data = data;    
    }
    ~Foo(){};
    Foo& operator=(const Foo& rhs)
    {
            data = rhs.data; 
            return *this;
    }

    int data;
};

int main()
{
   Foo foo(2); //Foo(int data) called
   Foo foo2(42);
   foo = foo2; // Assignment Operator Called
   cout << foo.data << endl; //Prints 42
}

Puede ver que aquí llamo al operador de asignación cuando ya inicialicé el objeto foo . Luego más tarde le asigno foo2 a foo . Todos los cambios que aparecen cuando llama a ese operador de signo igual se define en su función operator= . Puede ver un resultado ejecutable aquí: http://cpp.sh/3qtbm

Copia Constructor

Copia del constructor, por otro lado, es el opuesto completo del Constructor de asignación. Esta vez, se utiliza para inicializar un objeto ya inexistente (o no inicializado previamente). Esto significa que copia todos los datos del objeto al que se lo está asignando, sin inicializar realmente el objeto en el que se está copiando. Ahora echemos un vistazo al mismo código que antes, pero modifiquemos el constructor de asignaciones para que sea un constructor de copia:

// Copy Constructor
#include <iostream>
#include <string>

using std::cout;
using std::endl;

class Foo
{
  public:
    Foo(int data)
    {
        this->data = data;    
    }
    ~Foo(){};
    Foo(const Foo& rhs)
    {
            data = rhs.data; 
    }

    int data;
};

int main()
{
   Foo foo(2); //Foo(int data) called
   Foo foo2 = foo; // Copy Constructor called
   cout << foo2.data << endl;
}

Puedes ver aquí Foo foo2 = foo; en la función principal, asigno inmediatamente el objeto antes de inicializarlo, lo cual, como se dijo antes, significa que es un constructor de copia. Y note que no necesito pasar el parámetro int para el objeto foo2 ya que automáticamente extraje los datos anteriores del objeto foo. Aquí hay un ejemplo de salida: http://cpp.sh/5iu7

Copiar constructor vs Asignación de constructor

Ok, hemos revisado brevemente lo que el constructor de copia y el de asignación están arriba y damos ejemplos de cada uno ahora veamos a ambos en el mismo código. Este código será similar al anterior. Tomemos esto:

// Copy vs Assignment Constructor
#include <iostream>
#include <string>

using std::cout;
using std::endl;

class Foo
{
  public:
    Foo(int data)
    {
        this->data = data;    
    }
    ~Foo(){};
    Foo(const Foo& rhs)
    {
            data = rhs.data; 
    }

    Foo& operator=(const Foo& rhs)
    {
        data = rhs.data; 
        return *this;
    }

    int data;
};

int main()
{
   Foo foo(2); //Foo(int data) / Normal Constructor called
   Foo foo2 = foo; //Copy Constructor Called
   cout << foo2.data << endl;

   Foo foo3(42);
   foo3=foo; //Assignment Constructor Called
   cout << foo3.data << endl;
}

Salida:

2
2

Aquí puede ver que primero llamamos al constructor de copia ejecutando la línea Foo foo2 = foo; . Ya que no lo inicializamos previamente. Y luego, a continuación, llamamos al operador de asignación en foo3 ya que ya estaba inicializado foo3=foo ;