haciendo un objeto igual a otro objeto
Pregunta
sé que puedes hacer dos objetos iguales entre sí cuando se declara uno de ellos. Probé esto en mi programa. pero cuando fui a usar una declaración de asignación se asustó. ¿Puede hacer que dos objetos sean iguales entre sí con una declaración de asignación o solo puede hacerlo cuando se declara un objeto?
Solución
Debe proporcionar operator = a una clase para copiar el contenido de otro objeto. Por ejemplo:
class A
{
public:
//Default constructor
A();
//Copy constructor
A(const A&);
//Assignment operator
A& operator=(const A& a);
};
int main()
{
A a; //Invokes default constructor
A b(a); //Invokes copy constructor;
A c;
c = a; //Invokes assignment operator
}
Otros consejos
El operador de asignación de sobrecarga para ese objeto puede ayudarlo. (Espero que estés hablando de objetos de la misma clase :))
Para el operador de asignación, simplemente sobrecargue el operador de asignación de acuerdo con la implementación de su clase.
Es posible que se requiera que el objeto se inicialice o cree o se equipare con otro objeto cuando el objeto depende de otros objetos.
En este caso, el constructor de copias ofrece la mejor solución ... porque no copia el objeto a otro objeto poco a poco. La copia a nivel de bits crea un problema si la memoria se asigna dinámicamente al objeto. entonces, la solución es definir el copy_constructor en la clase. El constructor de copia toma referencia a un objeto existente del mismo tipo que su argumento, y se usa para crear un nuevo objeto a partir de uno existente. Aquí hay un ejemplo para equiparar los objetos con otros objetos usando el constructor de copia ..
#include "stdafx.h"
#include "iostream"
using namespace std;
class array
{
int *ptr;
int size;
public:
array (int sz) {
ptr = new int [sz];
size =sz;
for(int index=0;index<size;index++)
ptr[index]=size;
}
~array(){
delete[] ptr;
}
array(array &a) {
int index;
ptr=new int[a.size];
for(index=0;index<a.size;index++)
ptr[index]=a.ptr[index];
cout<<"copy_constructor invoked"<<endl;
}
};
int _tmain(int argc, _TCHAR* argv[])
{
array num(10);
array x(num); //invokes copy_constructor
array y=num; //invokes copy consturctor
return 0;
}
Esta respuesta se aplica a C #.
Junto con el operador Overloading = también debe anular es igual al método . También debe consultar Directrices para la sobrecarga de iguales () y Operador ==
public struct Complex
{
double re, im;
public override bool Equals(Object obj)
{
return obj is Complex && this == (Complex)obj;
}
public override int GetHashCode()
{
return re.GetHashCode() ^ im.GetHashCode();
}
public static bool operator ==(Complex x, Complex y)
{
return x.re == y.re && x.im == y.im;
}
public static bool operator !=(Complex x, Complex y)
{
return !(x == y);
}
}