Copy constructor gets called instead of inizialier_list<> constructor

[gedamial]

Hello.

struct Foo 
{
	Foo() 
	{
		cout << "default ctor" << endl;
	}

	Foo(std::initializer_list<Foo> ilist) 
	{
		cout << "initializer list" << endl;
	}

	Foo(const Foo& copy)
	{
		cout << "copy ctor" << endl;
	}
};

int main()
{
	
	Foo a;
	Foo b(a); 

	// This calls the copy constructor again! Shouldn't this call the initializer_list constructor?
	Foo c{b}; 
	


	_getch();
	return 0;
}

The output is:

>default ctor
>copy ctor
>copy ctor

Why? Shouldn't the last have been "initializer list"?

Confused.

[TarikNeaj]

http://programmers.stackexchange.com/questions/133688/is-c11-uniform-initialization-a-replacement-for-the-old-style-syntax

http://stackoverflow.com/questions/18222926/why-is-list-initialization-using-curly-braces-better-than-the-alternatives

[gedamial]

In the second link you provided, there's an answer that gives this example:

struct Foo 
{
	Foo() 
	{
		cout << "default ctor" << endl;
	}

	Foo(std::initializer_list<Foo> ilist) 
	{
		cout << "initializer list" << endl;
	}

	Foo(const Foo& copy) 
	{
		cout << "copy ctor" << endl;
	}
};

int main()
{
	Foo a;
	Foo b(a); 
	Foo c{ a }; 


	_getch();
	return 0;
}

The output is:

>default ctor
>copy ctor
>copy ctor

In this case, why didn't the initializer_list<Foo> constructor get called?
And how to call it?

[Cubbi]

Starting from http://en.cppreference.com/w/cpp/language/initializer_list

The first form "initializes the base or member named by class-or-identifier using direct initialization", linking to http://en.cppreference.com/w/cpp/language/direct_initialization

The second form "Initializes the base or member named by class-or-identifier using list-initialization (which becomes ... aggregate-initialization when initializing an aggregate)", linking to http://en.cppreference.com/w/cpp/language/list_initialization

There are many minor differences, but the one that is relevant to your choice of types is this:

list-initialization limits the allowed implicit conversions by prohibiting the following:
* conversion from a floating-point type to an integer type

which is why this compiles:

S(float xcoord, float ycoord) : x(xcoord), y(ycoord)
{
}

but this does not

S(float xcoord, float ycoord) : x{xcoord}, y{ycoord}
{
}

[gedamial]

@Cubbi

the code all compiles, because i'm explicitly converting the floating-point number to a float

S b{ 10.5f , 20.5f };

But I don't understand why the brace-initialization calls the copy constructor in the case above :/

[Cubbi]

because i'm explicitly converting the floating-point number

no, it compiles because you used round parentheses in the member initializer list, which allow float to int conversion.

Now the code in the initial post changed, so this is no longer relevant. With regards to its latest iteration, Foo c{b};, http://en.cppreference.com/w/cpp/language/list_initialization has the rule:

If T is a class type and the initializer list has a single element of the same or derived type (possibly cv-qualified), the object is initialized from that element (... by direct-initialization for direct-list-initialization).