Default constructor invocation difference between C++14 and C++17 - c++

Question

Consider the following code (question follows below):
#include <iostream>
struct Type0
{
Type0(char* c)
{}
};
struct Type1
{
Type1(int* i=nullptr) : i_(i)
{}
Type1(const Type1& other) = default;
int* i_;
};
template <typename ...>
struct Composable;
template <typename T0, typename ... T>
struct Composable<T0, T...> : T0, Composable<T...>
{
Composable()
{
std::cout << "Default Invoked: " << sizeof...(T) << std::endl;
}
Composable(const Composable& other) = default;
template<typename Arg, typename ... Args>
Composable(Arg&& arg, Args&& ... args) :
T0(std::forward<Arg>(arg)), Composable<T...>(std::forward<Args>(args)...)
{
std::cout << "Non-default invoked: " << sizeof...(T) << std::endl;
}
};
template <>
struct Composable<>{};
int main()
{
int i=1;
char c='c';
auto comp = Composable<Type0, Type1>(&c, &i);
std::cout << comp.i_ << std::endl;
}
You can find the live code here. This code has an interesting property: depending on whether you compile it with the --std=C++17 or --std=C++14 option, the behaviour changes (you can try this in my link to the live code: edit the g++ invocation --std parameter in the bottom left).
With --std=c++14, you get the following output:
Non-default invoked: 0
Non-default invoked: 1
Default Invoked: 0
Non-default invoked: 1
0x0
With --std=C++17, you get this instead:
Non-default invoked: 0
Non-default invoked: 1
0x7ffcdf02766c
To me, this difference is baffling. It seems clear that the C++17 version is doing the correct thing, and the C++14 is wrong. The C++14 version is invoking the default constructor of both Composable and (from it) Type1 (this is where the 0x0 final line of output comes from, as Type1 provides this as the default value for its i constructor parameter). However, I don't see any place where the default constructor is supposed to be invoked.
Furthermore, if I comment out the default constructor of Composable altogether, the C++17 version does exactly the same thing as before, whereas the C++14 version now fails to compile, complaining about the lack of a default constructor. If there was any hope of the difference being somehow explained by different optimization behavior, this fact surely kills it (the hope was anyhow small as the observed difference persists at all optimization levels, including 0).
Can anyone explain this difference? Is the C++14 behaviour a bug, or some intended behaviour which I do not understand? If the C++14 behaviour is correct within the rules of C++14, can someone please explain where the default constructor calls are coming from?

Answer 1

Guaranteed copy elision.
This line:
auto comp = Composable<Type0, Type1>(&c, &i);
In C++17, this means exactly the same thing as:
Composable<Type0, Type1> comp(&c, &i);
And if you change to this version, you'll see the same behavior bewteen C++14 and C++17. However, in C++14, that is still a move construction (or, more technically correct as you'll see in a minute, copy-initialization). But in Composable, you don't have an implicitly generated move constructor because you have a user-declared copy constructor. As a result, for the move construction, your "Non-default invoked" constructor template gets invoked (it's a better match than the copy constructor) in the C++14 version:
template<typename Arg, typename ... Args>
Composable(Arg&& arg, Args&& ... args) :
T0(std::forward<Arg>(arg)), Composable<T...>(std::forward<Args>(args)...)
Here, Arg is Composable<Type0, Type1> and Args is an empty pack. We delegate to T0 (Type0)'s constructor, forwarding the whole Composable (which works because it inherits from Type0 publicly, so we get the implicitly-generated move constructor there) and to Composable<Type1>'s default constructor (because args is empty).
This constructor template isn't really a proper move constructor - it doesn't end up initializing the Type1 member at all. Instead of moving from the right hand side's Type1::i_ you're invoking Type1::Type1(), the default constructor, which is why you end up with 0.
If you add a proper move constructor:
Composable(Composable&& other) = default;
Then you would again see the same behavior between C++14 and C++17.