• Believe it or not, in C++, the assignment operator (and many other operators) are function calls

• The following expressions are equivalent in C++:

  x = expression;

  operator=(x, expression);

• Recall that C++ does not know how to perform operations on user-defined types (classes)

  For example:

  MatrixNxN P(4), Q(4), R(4); R = P * Q; // Illegal, unless you define // the operator function

• There is one exception to this rule: assignment

  It is very common to make copies of variable, and in most cases, variables of user-defined type can be copied by copying ALL fields defined inside the user-defined type (class) from one class variable to another class variable of the same type

• Therefore, C++ decided to provide a default assignment operator to every user-defined class that performs a verbatim copying operation

• This verbitim copying can be illustrated with the following program:

  class MatrixNxN { public: float *A; int N; /* ----------------------- Constructor(int) ----------------------- */ MatrixNxN(int n) { A = new float[n*n]; N = n; } }

  int main(int argc, char *argv[]) { int N = 4; MatrixNxN M(N), Q(N); // Define 2 matrices Q = M; // Copy M to Q.... Q.A[0] = 1234; // Modify Q, will M be modified ??? }

  • You will see an unexpected result: Matrix M will be modified

  • In fact, there is another unexpected result: the array that was allocated to store the matrix for Q has become INACCESSIBLE (garbage)

• Example Program: (Default assignment operator)   ---- click here        

• Just like the case of the DEFAULT copy constructor, the DEFAULT assignment operator can fail to work correctly on SOME user-defined types

• In that case, you must override (replace) the C++ provided DEFAULT copy constructor with your own.

• To replace C++'s provided assignment operator, define this operator function in your class:

  class MatrixNxN { public: float *A; int N; /* ----------------------- Constructor(int) ----------------------- */ MatrixNxN(int n) { A = new float[n*n]; N = n; } void operator=(MatrixNxN & M) { int i, j; if ( M.N != N ) { cout << "**Unequal size matrices cannot be copied..."; return; } for (i = 0; i < N; i=i+1) for (j = 0; j < N; j=j+1) A[i*N+j] = M.A[i*N+j]; } }

  int main(int argc, char *argv[]) { int N = 4; MatrixNxN M(N), Q(N); // Define 2 4x4 matrices MatrixNxN R(3); // Define a 3x3 matrix Q = M; // Copy M to Q.... Q.A[0] = 1234; // Modify Q, M is NOT modified }

   

  • Example Program: (Your own assignment operator) ---- click here        

• Assignment operations in C and C++ can cascade:

  x = y = z;

  The variable z is copied into the variables y and x.

• The reason is that
  • The assignment operation x = expression returns the value of the expression, and

  • the assignment operator is right-to-left associative (for a discussion on operator associativity, see: click here )

• As a result, the assignment expression is evaluated as follows:

  x = y = z; => x = (y = z); // Assigns z to y and returns z => x = z; // Assigns z to x and returns z

• The assignment operator that we have defined above does NOT allow us to write cascaded assignments for MatrixNxN variables:

  MatrixNxN P(4), Q(4), R(4); P = Q = R; // Disallowed....

  The reason is that the expression is evaluated as follows:

  P = Q = R; => P = (Q = R); // Assigns R to Q (that's OK), // but does NOT return anything.... => P = void; // Disallowed

• Once we have identified the problem, the solution is easy: the assignment operator must return an object of the same type.

  A better assignment operator:

  class MatrixNxN { public: float *A; int N; /* ----------------------- Constructor(int) ----------------------- */ MatrixNxN(int n) { A = new float[n*n]; N = n; } MatrixNxN & operator=(MatrixNxN & M) { int i, j; if ( M.N != N ) { cout << "**Unequal size matrices cannot be copied..."; return(M); } for (i = 0; i < N; i=i+1) for (j = 0; j < N; j=j+1) A[i*N+j] = M.A[i*N+j]; return(M); } }

  int main(int argc, char *argv[]) { int N = 4; MatrixNxN M(N), Q(N); // Define 2 4x4 matrices MatrixNxN R(3); // Define a 3x3 matrix Q = R = M; // M is assigned to Q // (but not R due to size difference) }

  • NOTE: since we pass the input parameter back out, and the input parameter is passed in by reference (copy the address) it is more efficient to pass the parameter out by reference (copy the address out)

  • Example Program: (Cascading assignment operator) ---- click here        

The assignment operator and the copy constructor are similar in many aspects:

• They both use one variable to make a copy of that variable into another variable.

• C++ intrinsically provides a default (built-in) copy constructor, and C++ also provides a default (built-in) assignment operator

• The default assignment operator and copy constructor performs the same operation:
  copy every member variable defined in a user class verbatim from one class variable to another class variable

• Because the assignment operator is similar to the copy constructor in so many aspects, the rule of thumb is:

  Whenever you define a COPY-CONSTRUCTOR in some class, you MUST define an ASSIGNMENT OPERATOR ALSO, and vice versa

• Taken along with the rule of thumb that whenever you define a copy-constructor, you must also define a destructor, we get the follow rule of thumb:

  When you define a class and you need to define one of these functions: a DESTRUCTOR a COPY-CONSTRUCTOR or an ASSIGNMENT OPERATOR Then you MUST define ALL three and make sure they work in the proper manner

• The destructor, copy-constructor and assignment operator are collectively known as the Big Three in C++....