When should we write our own assignment operator in C++?

 

 

　　The answer is same as Copy Constructor. If a class doesn’t contain pointers, then there is no need to write assignment operator and copy constructor. The compiler creates a default copy constructor and assignment operators for every class.

　　The compiler created copy constructor and assignment operator may not be sufficient when we have pointers or any run time allocation of resource like file handle, a network connection..etc. For example, consider the following program.

#include<iostream>
using namespace std;

// A class without user defined assignment operator
class Test
{
    int *ptr;
public:
    Test (int i = 0)      
    { 
        ptr = new int(i); 
    }
    void setValue (int i) 
    { 
        *ptr = i; 
    }
    void print()          
    { 
        cout << *ptr << endl; 
    }
};

int main()
{
    Test t1(5);
    Test t2;
    t2 = t1;
    t1.setValue(10);
    t2.print();
    return 0;
}

　　Output of above program is “10″.

　　If we take a look at main(), we modified ‘t1′ using setValue() function, but the changes are also reflected in object ‘t2′. This type of unexpected changes cause problems.
　　Since there is no user defined assignment operator in the above program, compiler creates a default assignment operator, which copies ‘ptr’ of right hand side to left hand side. So both ‘ptr’s start pointing to the same location.

 

　　We can handle the above problem in two ways.

　　1) Do not allow assignment of one object to other object. We can create our own dummy assignment operator and make it private.

　　2) Write your own assignment operator that does deep copy.

　　

　　Same is true for Copy Constructor.

　　Following is an example of overloading assignment operator for the above class.

#include<iostream>
using namespace std;

class Test
{
    int *ptr;
public:
    Test (int i = 0)      
    { 
        ptr = new int(i); 
    }
    void setValue (int i) 
    { 
        *ptr = i; 
    }
    void print()          
    { 
        cout << *ptr << endl; 
    }
    Test & operator = (const Test &t);
};

Test & Test::operator = (const Test &t)
{
    // Check for self assignment
    if(this != &t)
    {
        *ptr = *(t.ptr);
    }
    
    return *this;
}

int main()
{
    Test t1(5);
    Test t2;
    t2 = t1;
    t1.setValue(10);
    t2.print();
    return 0;
}

　　Output：5
　　

　　We should also add a copy constructor to the above class, so that the statements like “Test t3 = t4;” also don’t cause any problem.

　　Note the if condition in assignment operator. While overloading assignment operator, we must check for self assignment（认同测试）. Otherwise assigning an object to itself may lead to unexpected results (See this). Self assignment check is not necessary for the above ‘Test’ class, because ‘ptr’ always points to one integer and we may reuse the same memory.

　　But in general, it is a recommended practice to do self-assignment check.

 

 

　　补充：

　　C++ doesn't allow default assignment operator to be used when there is a reference in your class.

　　For example, the following program produces error "error C2582: 'Test' : 'operator =' function is unavailable".

#include<iostream>
using namespace std;


class Test
{
    int x;
    int &ref;
public:
    Test (int i):x(i),ref(x) 
    {
    }
    void print() 
    { 
        cout << ref; 
    }
    void setX(int i) 
    { 
        x = i; 
    }
    //Test &operator = (const Test &t) {x = t.x;}
};


int main()
{
    Test t1(10);
    Test t2(20);
    t2 = t1;
    t1.setX(40);
    t2.print();
    return 0;
}

　　If you uncomment the operator definition in the above program, the program works fine and prints "10".
　　So compiler forces to write an assignment operator when you have a non-static reference in your class.

 

 

 

 

　　Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

　　转载请注明：http://www.cnblogs.com/iloveyouforever/

　　2013-11-26　　21:35:48