Re: template problem
On Jun 27, 1:24 pm, Bo <bo.zhang0...@gmail.com> wrote:
Below is a short program where I define a class A, in which I redefine
the operator =.
No, the program below does not "redefine" operator= for the A class
template; instead it overloads operator=. In other words, the program
adds an operator= to A (to support assigning new types to an A
object), but otherwise the overloaded operator= does not replace any
of A's existing assignment methods.
In main(), I define two variables a and b, both of the same type
A<int>. Then I write "a = b", where I expect that the new operator=
will be called. I expect that the compiler can figure out that "T =
int" and "S = int".
#include <iostream>
using namespace std;
template <class T>
class A
{
public:
template <class S>
A<T>& operator = (const A<S>& a)
{
cerr << "inside operator =" << endl;
return *this;
}
};
int main()
{
A<int> a;
A<int> b;
a = b; // the redefined assingment operator is NOT called.
// If I declare A<float> b, then the new operator is
// called.
}
Why the compiler cannot figure out in the first case that "T = int"
and "S = int" ?
The compiler does indeed figure out that both T and S are "int" types;
but more importantly, the compiler also recognizes that then when T
and S are the same type, then "a" and "b" also have the same type. And
whenever a class object ia assigned the value of a class object of the
same type, the compiler calls the class's "copy-assignment method"
which - if not explicitly defined - is implicitly generated by the
compiler.
Now, because the overloaded operator= in the program above does not
meet the criteria for a copy assignment operator - the program (to
assign b to a) calls A<int>'s implicit copy assignment operator,
instead. In other words, when b is assigned to a, the program calls
the same (implicit) copy assignment operator that the program would
have called - if no overloaded operator=() existed. So, as pointed out
earlier, a function template operator=() does not override (that is,
redefine) the class's implicit copy assignment operator.
So the solution to the problem of operator= not being called when
copying b to a, would be to override A's implicit copy assignment
operator with an explicit method:
A& operator=(const A& a)
{
cerr << "inside copy assignment\n";
return *this;
}
Greg
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]