Baffled by templated operator=

Now this really took me by surprise and I just believed it after extensive debugging. Here's the punchline: A templated operator= is not used for assignments from the same data-type. That means when test has a templated operator=, this does not call it:

test a, b;
a = b;

On a second thought, this is actually comprehensible behaviour. The compiler generates a default operator= for assignments of it's own type that calls operator= for each member. This default operator is even generated when a templated operator exists. And because overloaded functions have stronger "binding" than template-functions, the implicitly created and therefore overloading operator= is called. Here's an example:

#include <iostream>

struct test
{
   template<typename T>
   test &operator=(const T &value)
   {
      std::cout << "template operator=()" << std::endl;
      return *this;
   }
};

int main()
{
   test a, b;
   b = 10;
   a = b;
}

You might think that the output is

operator=()
operator=()

but it isn't. The output contains only one line, because the generated operator= does not create any output.

It is extremely important to know this rule and don't fall into it's trap like I did. In my case I had a pointer-member and simply assigning it resulted in a double-free in the dtor of the last destroyed copy of that object. Here's the correct way to circumvent this:

#include <iostream>

struct test
{
   template<typename T>
   test &operator=(const T &value)
   {
      std::cout << "template operator=()" << std::endl;
      return *this;
   }
   test &operator=(const test &value)
   {
      return operator=<test>(value);
   }
};

int main()
{
   test a, b;
   b = 10;
   a = b;
}