Surprising behavior in multiple copy constructor inheritance

Question

Starting with C++11, there can be two copy constructors, one taking a parameter of type T&, and one taking a parameter of type const T&.

I have a situation where (seemingly) adding a second copy constructor causes neither one to get called, when the constructors are inherited in a derived class. The copy constructor is overridden by a templatized constructor when both are present.

Here is a MWE:

struct A {
  template <typename... Args>
  A (Args&&... args)
  { std::cout << "non-default ctor called\n"; }

  A (A&) { std::cout << "copy ctor from non-const ref\n"; }
};

struct C :public A { using A::A; };

int main() {
  C c1;
  C c2(c1);
}

Running this code, we see output

non-default ctor called
copy ctor from non-const ref

which is as expected.

However, adding an additional constructor to struct A as follows:

  A (const A&) { }

somehow causes the other copy constructor not to get called, so the output becomes

non-default ctor called
non-default ctor called

In my use case, I want to inherit all the constructors from a base class into a derived class, including the copy constructors and anything else. But it seems that somehow the two copy constructors don't get inherited when they are both present. What is going on here?

Answer 1

From https://en.cppreference.com/w/cpp/language/using_declaration

If one of the inherited constructors of Base happens to have the signature that matches a copy/move constructor of the Derived, it does not prevent implicit generation of Derived copy/move constructor (which then hides the inherited version, similar to using operator=).

So

struct C :public A { using A::A; };

is

struct C :public A
{
    using A::A;
    C(const C&) = default;
    C(C&&) = default;
};

where C(const C&) = default; is similar to

C(const C& c) : A(static_cast<const A&>(c)) {}

So with

struct A {
  template <typename... Args>
  A (Args&&... args)
  { std::cout << "non-default ctor called\n"; }

  A (A&) { std::cout << "copy ctor from non-const ref\n"; }
};

template constructor is chosen, but

struct A {
  template <typename... Args>
  A (Args&&... args)
  { std::cout << "non-default ctor called\n"; }

  A (const A&) { std::cout << "copy ctor from const ref\n"; }
  A (A&) { std::cout << "copy ctor from non-const ref\n"; }
};

A (const A&) is chosen.

As you can notice, there is also a defect:

The semantics of inheriting constructors were retroactively changed by a defect report against C++11. Previously, an inheriting constructor declaration caused a set of synthesized constructor declarations to be injected into the derived class, which caused redundant argument copies/moves, had problematic interactions with some forms of SFINAE, and in some cases can be unimplementable on major ABIs. Older compilers may still implement the previous semantics.

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0136r1.html

With that defect, your class C would be

struct C :public A
{
    using A::A;

    template <typename ...Ts>
    C(Ts&&... ts) : A(std::forward<Ts>(ts)...) {} // Inherited.

    C(const C&) = default;
    C(C&&) = default;
};

So you call C(C& c) : A(c) {} (after template substitution).