为什么我不能用C ++中的模板版本覆盖默认的复制构造函数和赋值运算符

Question

I asked this question about overloading the copy constructor and assignment operator with template versions and considering the confusion involving around the question (since it seems to be a compiler bug), I thought I'd try with only template copy constructor and template assignment operator to see what happens. But they are completely ignored by the compiler.

struct BaseClass
{
public:
  BaseClass() {}

  template<typename T>
  BaseClass(const T& a_other)
  {
    int i = 0; // for break point which is not hit
  }

  template<typename T>
  BaseClass& operator= (const T& a_other)
  {
    int i = 0; // for break point which is not hit
    return *this;
  }

};

struct MyClass : public BaseClass
{
};

int main()
{
  MyClass i, j;
  i = j;

  return 0;
}

Why can't I over-ride the defaults with template versions (I suspect the answer will be the defaults are a better match but I would like the template versions to act as defaults as well)? And is there anything I can do to make sure the template versions are called instead of the defaults?

Answer 1

template<typename T>
BaseClass(const T& a_other) 

First of all, this is not a copy-constructor. It is rather a templated constructor.

The copy-constructor should be this:

BaseClass(const BaseClass & a_other)

Notice the difference?

Note that the templated constructor doesn't define copy-constructor . The compiler will still generate a default copy-constructor for you, instead of instantiating the templated constructor.

Same argument for copy-assignment.

Answer 2

As mentioned in answers to your other question, the standard specifically disallows it.

I'd guess that a rationale is that if a non-default for these constructors is necessary it would be because they need to deal with the specifics of the class in question. A 'generic' solution wouldn't make sense and might quietly hide potential problems.

Some people might believe it's bad enough that there's already the 'generic' implicit versions of these functions, which silently does the wrong thing for many classes.

The standardese disallowing template versino of these is here:

From C++03 12.8 "Copying class objects"

• (Para 1): A non-template constructor for class X is a copy constructor if its first parameter is of type X&, const X&, volatile X& or const volatile X&, and either there are no other parameters or else all other parameters have default arguments (8.3.6)
• (Para 9): A user-declared copy assignment operator X::operator= is a non-static non-template member function of class X with exactly one parameter of type X, X&, const X&, volatile X& or const volatile X&