Assignment operator in C++

––The assignment operator in C++ programming language is '='. Like other operators in C++, it can be overloaded.

The copy assignment operator is a special case of assignment operator used to assign objects of the same class to each other. It is one of the special member functions, and is generated automatically by the compiler if not explicitly declared by the programmer. The compiler-generated code performs a shallow copy.

The copy assignment operator differs from the copy constructor in that it must clean up the data members of the assignment's target (and correctly handle self-assignment) whereas the copy constructor assigns values to uninitialized data members. [cite book
last = Stroustrup
first = Bjarne
authorlink = Bjarne Stroustrup
title = The C++ Programming Language
edition = 3
publisher = Addison-Wesley
date = 2000
isbn = 978-0201700732
ref = stroustrup
pages = 244 ] For example:

My_Array first; // initialization by default constructorMy_Array second = first; // initialization by copy constructorsecond = first; // assignment by copy assignment operator

Overloading copy assignment operator

When deep copies of objects have to be made, exception safety should be taken into consideration. One way to achieve this when resource deallocation never fails is:

# Acquire new resources
# Release old resources
# Assign the new resources' handles to the object

class My_Array {

int * array; int count;

public:

My_Array & operator = (const My_Array & other) { if (this != &other) // protect against invalid self-assignment { // 1: allocate new memory and copy the elements int * new_array = new int [other.count] ; std::copy(new_array, new_array + other.count, other.array);

// 2: deallocate old memory delete [] array;

// 3: assign the new memory to the object array = new_array; count = other.count; } // by convention, always return *this return *this; }

...

};

However, if no-fail swap method is available for all the members and the class provides a copy constructor and destructor (which it should do according to the rule of three), the most straightforward way to implement copy assignment is as follows [Citation
last1 = Sutter | first1 = H. | author1-link = Herb Sutter
last2 = Alexandrescu | first2 = A. | author2-link = Andrei Alexandrescu
title = C++ Coding Standards
publisher = Addison-Wesley
date = October 2004
year = 2004
isbn = 0-321-11358-6 ] :

public:

void swap(My_Array & other) // the swap member function (should never fail!) { // swap all the members (and base subobject, if applicable) with other std::swap(array, other.array); std::swap(count, other.count); }

My_Array & operator = (My_Array other) // note: argument passed by value! { // swap this with other swap(other);

// by convention, always return *this return *this;

// other is destroyed, releasing the memory }

The reason why operator = returns My_Array& instead of void is simple. It allows for concatenation of assignments like this:

array_1 = array_2 = array_3; // array_3 is assigned to array_2 // and then array_2 is assigned to array_1

ee also

*Operator overloading
*Operators in C and C++

References

–