haciendo un objeto igual a otro objeto

Question

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?

Answer 1

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
}

Answer 2

El operador de asignación de sobrecarga para ese objeto puede ayudarlo. (Espero que estés hablando de objetos de la misma clase :))

Answer 3

Para el operador de asignación, simplemente sobrecargue el operador de asignación de acuerdo con la implementación de su clase.

Answer 4

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;
}

Answer 5

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);
   }
}