faire un objet égal à un autre objet

Question

Je sais que vous pouvez faire deux objets égaux l'un à l'autre quand l'un d'eux est déclaré. J'ai testé cela dans mon programme. mais quand je suis allé à utiliser une déclaration d'affectation, il a paniqué. Pouvez-vous rendre deux objets égaux entre eux avec une instruction d'assignation ou pouvez-vous seulement faire cela quand un objet est déclaré?

Answer 1

Vous avez fourni operator = à une classe pour copier le contenu d'un autre objet. Par exemple:

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

L'opérateur d'affectation de surcharge pour cet objet peut vous aider. (J'espère que vous parlez d'objets de même classe :))

Answer 3

Pour l'opérateur d'affectation juste l'opérateur d'affectation de surcharge en fonction de votre implémentation de classe.

Answer 4

Cette réponse s'applique à C#.

Avec l'opérateur Surcharge =, vous devez également remplacer la méthode equals. Vous devriez également vérifier Guidelines pour Equals Surcharger() et l'opérateur ==

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

Answer 5

L'objet peut être nécessaire d'initialiser ou créer ou assimilée à un autre objet lorsque l'objet dépend d'autres objets.

Dans ce cas, le constructeur de copie donne la meilleure solution ... parce qu'il ne copie pas l'objet à l'autre objet par bit. La copie bit à bit crée un problème si la mémoire est allouée dynamiquement à l'objet. donc, les solutions sont la définition du copy_constructor dans la classe. La constuctor de copie fait référence à un objet existant du même type que son argument, et il est utilisé pour créer un nouvel objet à partir d'un objet existant. Voici un examplet d'assimiler les objets avec d'autres objets à l'aide constructeur de copie ..

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