- In C++, the assignment operator
(and many other operators)
is a function call
- The following expressions are equivalent in C++:
x = expression;
operator=(x, expression);
- C++
does not
know
the
internal details
of
user-defined classes
- C++
does
know
the
size
of
user-defined classes
- Therefore, the
default
assignment operator
blindly copies each component
from the
source to the destination variable.
- Example:
class Matrix3x3 { public: double A[3][3]; // 9 doubles }; int main(int argc, char *argv[]) { Matrix3x3 A, B; B = A; // Copies 9 doubles }
- Example Program:
(Demo above code)
- Prog file: click here
- Sometimes, the
default assignment operator
provided by
C++
is
inadequate (= incorrect)
to assign variables of your class
- Example:
class MatrixNxN { public: double *A; // Contains an address int N; /* ------------------------ Constructor(int) ------------------------ */ MatrixNxN(int n) { A = new double[n*n]; N = n; } }; int main(int argc, char *argv[]) { int N = 3; MatrixNxN A(N), B(N); B = A; // Copies 2 variables only }The result of the assignment operation is not a new copy of a matrix !
- Example Program:
(Demo that the assignment does not make a copy)
- Prog file: click here
You will see that Matrix B points to the same matrix as Matrix A
- When
the default assignment operator
is
inadequate ,
we must
define our own
assignment operator
and
replace the C++'s provided assignment operator
- NOTE:
The assignment operator function operator= must be a member function - Example:
an ordinary function
cannot be used as
operator=
class MatrixNxN { public: double *A; // Contains an address int N; /* ------------------------ Constructor(int) ------------------------ */ MatrixNxN(int n) { A = new double[n*n]; N = n; } }; // Ordinary function can NOT be operator= !!! void operator=(MatrixNxN & m1, MatrixNxN & m2) { int i, j; if ( m1.N != m2.N ) { cout << "** Error: Unequal size matrices..." << endl << endl; return; } for (i = 0; i < m1.N; i=i+1) for (j = 0; j < m1.N; j=j+1) m1.A[i*m1.N+j] = m2.A[i*m1.N+j]; } int main(int argc, char *argv[]) { int N = 3; MatrixNxN A(N), B(N); B = A; // Copy matrix } - Example Program:
(Demo above code)
- Prog file: click here
- Example assignment operator function:
- Example Program:
(Demo above code)
- Prog file: click here
class MatrixNxN { public: double *A; // Contains an address int N; /* ------------------------ Constructor(int) ------------------------ */ MatrixNxN(int n) { A = new double[n*n]; N = n; } // Member function operator= void operator=(MatrixNxN & m2) { int i, j; if ( m1.N != m2.N ) { cout << "** Error: Unequal size matrices..." << endl << endl; return; } for (i = 0; i < m1.N; i=i+1) for (j = 0; j < m1.N; j=j+1) m1.A[i*m1.N+j] = m2.A[i*m1.N+j]; } }; int main(int argc, char *argv[]) { int N = 3; MatrixNxN A(N), B(N); B = A; // Copy matrix } - Example Program:
(Demo above code)
- Assignment operations in C and C++ can
cascade:
int x, y, z; x = y = z;
- The reason that assignment
can cascade
is because:
- The assignment operator
=
returns the
value of the expression
- the assignment operator is
right-to-left associative
(for a discussion on operator associativity, see: click here )
- The assignment operator
=
returns the
value of the expression
- The the assignment expression is evaluated as follows:
int x, y z; z= 4; x = y = z; => x = (y = z); // Assigns z to y and returns value of z (4) => x = z; // Assigns z to x and returns value of z (4) - Example Program:
(Demo above code)
- Prog file: click here
- The assignment operator that we have defined above
does NOT cascade:
class MatrixNxN { public: double *A; // Contains an address int N; /* ------------------------ Constructor(int) ------------------------ */ MatrixNxN(int n) { A = new double[n*n]; N = n; } // Member function operator= void operator=(MatrixNxN & m2) { int i, j; if ( m1.N != m2.N ) { cout << "** Error: Unequal size matrices..." << endl << endl; return; } for (i = 0; i < m1.N; i=i+1) for (j = 0; j < m1.N; j=j+1) m1.A[i*m1.N+j] = m2.A[i*m1.N+j]; } }; int main(int argc, char *argv[]) { int N = 3; MatrixNxN A(N), B(N), C(N); C = B = A; // Error !!! } - The reason is that the expression is evaluated as follows:
C = B = A; => C = (B = A); // Assigns B to A (that's OK), // but does NOT return anything.... => C = void; // Disallowed
A cascading assignment operator:
- Example Program:
(Demo above code)
- Prog file: click here
class MatrixNxN { public: double *A; // Contains an address int N; /* ------------------------ Constructor(int) ------------------------ */ MatrixNxN(int n) { A = new double[n*n]; N = n; } // Member function operator= MatrixNxN & operator=(MatrixNxN & m2) { int i, j; if ( m1.N != m2.N ) { cout << "** Error: Unequal size matrices..." << endl << endl; return; } for (i = 0; i < m1.N; i=i+1) for (j = 0; j < m1.N; j=j+1) m1.A[i*m1.N+j] = m2.A[i*m1.N+j]; return(m2); } }; int main(int argc, char *argv[]) { int N = 3; MatrixNxN A(N), B(N), C(N); C = B = A; // Error !!! } - Example Program:
(Demo above code)
- The
assignment operator (=) and the
copy constructor are
similar :
- The assignment operator (=) and the copy constructor use an input object to make a copy of that variable in another object.
- C++ provides a default (built-in)
assignment operator (=) and the
copy constructor
- The default (built-in)
assignment operator (=) and the
copy constructor
perform the
same operation :
-
copy every member variable
in a user class
verbatim
from the source class variable
to the destination class variable
- Because the
assignment operator (=) and the
copy constructor
are similar,
the rule of thumb is:
Whenever you define a copy-constructor for some class, you must also define an assignment operator And vice versa
- Also recall this rule of thumb:
When you use a new operator in a constructor (to allocate space for some variable), you must provide a destructor to de-allocate the space allocated by the new operator
- The destructor, copy-constructor and assignment operator are collectively known as the Big Three in C++....