Can a templatised constructor stand in for a deleted copy constructor?

Question

Consider

template<typename T>
struct Foo
{
    Foo(const Foo&) = delete;
    template <typename Y>
    Foo(const Foo<Y>&){}
};

Does the appropriate instantiation of the template constructor stand in for the copy constructor? I know it doesn't normally (since the copy constructor must not be a template function) but here I've deleted the copy constructor.

Answer 1

The trouble here is that deleted functions still participate in overload resolution. So given

Foo<int> a;
Foo<int> b{a};

the viable functions are the deleted copy constructor and the template constructor with deduced template argument int. Being a non-template, the deleted copy constructor wins. And using the deleted function makes the program ill-formed.

So no, a template constructor cannot ever be instantiated as a copy constructor for copying an object of the same type.

Answer 2

No it can't: overload resolution always considers non-templated functions first, and when a deleted one is encountered, overload resolution fails rather than a template overload being considered.

Allow me to introduce the default constructor into your class with the line

Foo() = default;

Then, consider two variables

Foo<double> double_foo;
Foo<int> int_foo;

Then note

1. Foo<int> bar(double_foo); is allowed due to the template
2. Foo<int> bar(int_foo); is not allowed due to the deleted constructor
3. Foo<int> bar = Foo<int>(); would be allowed if you had re-introduced the move constructor by writing Foo(const Foo&&) = default;. You need to use the = syntax here since Foo<int> bar(Foo<int>()); is a forward declaration.

Finally, your assertion "the copy constructor must not be a template function" is not correct. Credit to @LightnessRacesInOrbit:

C++14 12.8.2 "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).