Why this code is NOT causing redefinition error?

Question

#include <initializer_list>

struct Foo
{
    template <typename T>
    Foo(std::initializer_list<T>) {}

    template <typename T>
    Foo(std::initializer_list<typename T::BarAlias>) {}
};

struct Bar
{
    using BarAlias = Bar; 
};

int main()
{
    Foo foo{ Bar{} };
}

I believe that a compiler should produce two exactly the same constructors inside of Foo. Why is it even working?

Side note: https://stackoverflow.com/questions/31816095/why-should-i-not-include-bits-stdc-h — Werner Henze, Oct 24 '21 at 16:40
Here is the answer [SFINAE](https://en.cppreference.com/w/cpp/language/sfinae). — 273K, Oct 24 '21 at 16:43
I see two different constructors. One of the two (constructor #2) is MORE specialized than the other and gets selected in this case. — Michaël Roy, Oct 24 '21 at 16:43

Evg · Accepted Answer · 2021-10-24T17:10:32.393

You have two templates with unrelated template arguments Ts. For the second constructor to be a candidate, T should be deducible, at least. However, in

template <typename T>
Foo(std::initializer_list<typename T::BarAlias>) {}

T is in a non-deduced context. As a result, this constructor will always be rejected thanks to SFINAE.

Note how your code is different from

template<class T>
struct Foo {
    Foo(std::initializer_list<T>);
    Foo(std::initializer_list<typename T::BarAlias>);
};

which for Foo<Bar> foo{Bar{}}; will indeed produce an error that you expect.

Why this code is NOT causing redefinition error?

1 Answers1