C++ constructor initialization list invokes default constructor. Why? - c++

Question

take a look at my code. It will convert Vector4 to Vector4.
There is this copy constructor, which automatically does the conversion component by component. I can't understand one thing: why at the end of construction, when each component is correctly set up, default constructor is invoked on each component making output vector empty. You can see execution flow in the output below. Interesting is, that if I replace initialization list by 4 assignments, the code works as expected.
Compiler is VS2013.
#include <cstdio>
using namespace std;
struct half
{
unsigned short data;
half() : data(0) { printf("half::default_constructor\n"); }
half(half& pattern) : data(pattern.data) { printf("half::copy_constructor\n"); }
explicit half(float pattern) : data(16) { printf("half::from_float_constructor\n"); }
operator float() { printf("half::to_float_operator\n"); return 3.0f; }
};
template <typename T>
struct Vector4
{
Vector4() : x(0), y(0), z(0), w(0) { }
Vector4(T value) : x(value), y(value), z(value), w(value) { }
Vector4(T x, T y, T z, T w) : x(x), y(y), z(z), w(w) { }
template <typename U>
Vector4(Vector4<U>& other) : x((T)other.x), y((T)other.y), z((T)other.z), w((T)other.w) { }
union
{
struct { T x, y, z, w; };
struct { T r, g, b, a; };
};
};
int main()
{
Vector4<float> a(0, 1, 4, 6);
Vector4<half> b(a);
}
Output from this program:
half::from_float_constructor
half::to_float_operator
half::from_float_constructor
half::from_float_constructor
half::to_float_operator
half::from_float_constructor
half::from_float_constructor
half::to_float_operator
half::from_float_constructor
half::from_float_constructor
half::to_float_operator
half::from_float_constructor
half::default_constructor
half::default_constructor
half::default_constructor
half::default_constructor

Answer 1

The reason is that the code is invalid. You cannot store non-POD types in a union. Your code results in undefined behaviour. I don’t know exactly what the compiler does as a result, and why it invokes the default constructor1 – but that’s undefined behaviour for you.
1 Although I have a theory: it probably attempts to initialise r, g, b and a.

Answer 2

First of all C++ has no anonymous structures. So this definition of Vector4 member
union
{
struct { T x, y, z, w; };
struct { T r, g, b, a; };
};
is not C++ compliant. I think you use MS VC++ that has such language extension.
Now let consider what occurs.
In mem-initializer list of the template constructor
template <typename U>
Vector4(Vector4<U>& other) : x((T)other.x), y((T)other.y), z((T)other.z), w((T)other.w) { }
C-style casting as for example (T)other.x invokes constructor of class half
explicit half(float pattern) : data(16) { printf("half::from_float_constructor\n");
The result of this call is creating a temporary object of type half
You may not apply the copy constructor of class half because its parameter is declared as non-const reference and temporary objects may not bind to non-const references.
half(half& pattern) : data(pattern.data) { printf("half::copy_constructor\n"); }
So the constructor searches other paths to do the task.
It can convert the temporary object to an object of type float
operator float() { printf("half::to_float_operator\n"); return 3.0f; }
};
that to call at last constructor
explicit half(float pattern) : data(16) { printf("half::from_float_constructor\n"); }
Thus you get the following sequence of messages
half::from_float_constructor
half::to_float_operator
half::from_float_constructor
I prepared a more simple C++ compliant example that demonstrates the same behaviour
#include <iostream>
struct A
{
float x = 0.0f;
};
struct B
{
explicit B( float ){ std::cout << "B::from_float_constructor" << std::endl; }
B( B & ){ std::cout << "B::from_copy_constructor" << std::endl; }
operator float () const
{
std::cout << "B::to_float_operator" << std::endl;
return 0.0f;
}
};
struct C
{
B b;
C( A a ) : b( ( B )a.x ) {}
};
int main()
{
A a;
C c( a );
return 0;
}
The output is
B::from_float_constructor
B::to_float_operator
B::from_float_constructor