C++
Copiando vs Asignación
Buscar..
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
rs | Lado derecho de la igualdad para los constructores de copia y asignación. Por ejemplo, el constructor de asignación: MyClass operator = (MyClass & rhs); |
---|---|
Marcador de posición | Marcador de posición |
Observaciones
Otros buenos recursos para futuras investigaciones:
¿Cuál es la diferencia entre el operador de asignación y el constructor de copia?
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
;