Constructor for any initializer_list accepted by given T

Question

I am looking for a solution to create constructor accepting all std::initializer_lists accepted by given T. For example:

#include <initializer_list>
#include <utility>

template <typename T> struct AllInits
{
  AllInits(std::initializer_list<?>){}
};

struct ManyListTypes
{
  ManyListTypes(std::initializer_list<bool>){}
  ManyListTypes(std::initializer_list<int>){}
  ManyListTypes(std::initializer_list<std::pair<int, int>>){}
};

int main()
{
  AllInits<ManyListTypes> first{true,false,true};
  AllInits<ManyListTypes> second{1,2,3};
  AllInits<ManyListTypes> third{{1,1},{2,2},{3,3}};
  return 0;
}

Is it even possible?

I was thinking about some `std::tuple` but `{1, 1}` is not detected as `std::tuple`. Any ideas? — wehin19066, Nov 02 '21 at 20:31
@HolyBlackCat of cause it will not work without suitable overloads. — 273K, Nov 02 '21 at 20:32
@wehin19066 `{1, 1}` is `std::initializer_list`, not `std::tuple`. — 273K, Nov 02 '21 at 20:32
@RemyLebeau This won't let you pass any braced-init-lists to it. — HolyBlackCat, Nov 02 '21 at 20:40
There is no reflection in C++. So I doubt we can retrieve possible argument without help. if `ManyListTypes` provide a `using arg_types = std::tuple>`, we might change `AllInits` accordly. — Jarod42, Nov 02 '21 at 20:46
@Jarod42 `If {1, 1}` has no type, what type of a is here: `#include int main() { auto a = {1, 1}; int b = a; return 0; }` — 273K, Nov 02 '21 at 20:46
@S.M. `a` is `std::initializer_list`, but `{1, 1}` is not. `auto` has special rules for this case. Try `decltype` on it... — HolyBlackCat, Nov 02 '21 at 20:50
@HolyBlackCat `{1, 1}` is not an expression, `decltype` does not work in a such way. — 273K, Nov 02 '21 at 20:53
@S.M. Since it's not an expression, it can't have a type. Q.E.D. :P — HolyBlackCat, Nov 02 '21 at 20:56
@S.M.: From [list_initialization#Notes](https://en.cppreference.com/w/cpp/language/list_initialization#Notes) *"A braced-init-list is not an expression and therefore has no type, e.g. `decltype({1,2})` is ill-formed."* and *"A special exception is made for [type deduction using the keyword `auto`](https://en.cppreference.com/w/cpp/language/template_argument_deduction#Other_contexts) , which deduces any braced-init-list as `std::initializer_list` in copy-list-initialization."* — Jarod42, Nov 02 '21 at 20:58
Can you use specify types by hands? `template struct AllInits { AllInits(std::initializer_list){} }; AllInits first{true,false,true}; AllInits second{1,2,3}; AllInits> third{{1,1},{2,2},{3,3}}; ` — Shadasviar, Nov 02 '21 at 21:06
@wehin19066: Is inheriting constructor an option `template struct AllInits : T { using T::T; };`? — Jarod42, Nov 02 '21 at 21:09
@wehin19066 It solves your problem, but forces `AllInits` to inherit from `ManyListTypes`. — HolyBlackCat, Nov 03 '21 at 10:34

score 1 · Answer 1 · answered Nov 02 '21 at 21:22

The best practical solution would be:

template <typename T>
struct AllInits
{
    template <typename U>
    requires std::constructible_from<T, std::initializer_list<U> &>
    AllInits(std::initializer_list<U>){}
};

This passes the first two testcases, but fails the third one. I.e. you can't have nested braced lists.

A possible workaround is to specify the element types:

AllInits<ManyListTypes> third{std::pair{1,1}, std::pair{2,2}, std::pair{3,3}};

There is a solution that doesn't have this limitation, but it relies on some arcane tricks, and probably shouldn't be used in practice.

Run on gcc.godbolt.org

#include <concepts>
#include <cstddef>
#include <initializer_list>
#include <iostream>
#include <type_traits>
#include <utility>

// Some helpers.

template <typename T>
struct Tag
{
    using type = T;
};

template <typename ...P>
struct TypeList
{
    inline static constexpr std::size_t size = sizeof...(P);
};

template <typename T>
void PrintType()
{
    #ifndef _MSC_VER
    std::cout << __PRETTY_FUNCTION__ << '\n';
    #else
    std::cout << __FUNCSIG__ << '\n';
    #endif
};

// A generic stateful-template list.

constexpr void adl_ListElem() {} // A dummy ADL target.

template <typename Key, std::size_t Index>
struct ElemViewer
{
    #if defined(__GNUC__) && !defined(__clang__)
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wnon-template-friend"
    #endif
    friend constexpr auto adl_ListElem(ElemViewer);
    #if defined(__GNUC__) && !defined(__clang__)
    #pragma GCC diagnostic pop
    #endif
};

template <typename Key, std::size_t Index, typename Value>
struct ElemWriter
{
    friend constexpr auto adl_ListElem(ElemViewer<Key, Index>) {return Tag<Value>{};}
};

template <typename Key, typename Unique, std::size_t Index = 0, typename = void>
struct NumElems : std::integral_constant<std::size_t, Index> {};

template <typename Key, typename Unique, std::size_t Index>
struct NumElems<Key, Unique, Index, decltype(adl_ListElem(ElemViewer<Key, Index>{}), void())> : std::integral_constant<std::size_t, NumElems<Key, Unique, Index+1, void>::value> {};

template <typename Key, typename Value>
struct ElemInserter : ElemWriter<Key, NumElems<Key, Value>::value, Value>, std::true_type {};

// Constructor detection.

template <typename T>
struct AnyInitList
{
    template <
        typename U,
        typename = std::enable_if_t<std::is_same_v<U, std::initializer_list<typename U::value_type>>>,
        typename = std::enable_if_t<ElemInserter<T, typename U::value_type>::value>
    >
    operator U() const
    {
        return {};
    }
};

template <typename T, typename = void>
struct DetectCtors {};

template <typename T>
struct DetectCtors<T, decltype(T(AnyInitList<T>{}), void())> {};

template <typename Type, typename I>
struct ElemListLow {};

template <typename T, std::size_t ...I>
struct ElemListLow<T, std::index_sequence<I...>>
{
    static constexpr TypeList<typename decltype(adl_ListElem(ElemViewer<T, I>{}))::type...> helper() {}
    using type = decltype(helper());
};

template <typename T>
struct ElemList : ElemListLow<T, std::make_index_sequence<NumElems<T, decltype(DetectCtors<T>{}, void())>::value>> {};

// Generating a type with the suitable constructors.

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

template <typename T, typename>
struct MultiCtor;

template <typename T, typename ...P>
struct MultiCtor<T, TypeList<P...>> : SingleCtor<P>...
{
    using SingleCtor<P>::SingleCtor...;

    using list = TypeList<P...>;
    
    template <typename U>
    requires std::constructible_from<T, std::initializer_list<U> &>
    MultiCtor(std::initializer_list<U>){}
};

// The final type.

template <typename T>
struct Foo : MultiCtor<T, typename ElemList<T>::type>
{
    using MultiCtor<T, typename ElemList<T>::type>::MultiCtor;
};

// Demo.

struct ManyListTypes
{
    ManyListTypes(std::initializer_list<bool>){}
    ManyListTypes(std::initializer_list<int>){}
    ManyListTypes(std::initializer_list<std::pair<int, int>>){}
};

int main()
{
    PrintType<Foo<ManyListTypes>::list>(); // TypeList<bool, int, std::pair<int, int>>

    Foo<ManyListTypes> first{true,false,true};
    Foo<ManyListTypes> second{1,2,3};
    Foo<ManyListTypes> third{{1,1},{2,2},{3,3}};
}

There is a lot going on here.

class AnyInitList has a templated conversion operator to std::initializer_list<??>.
An attempt is made to construct your type (ManyListTypes) from AnyInitList, but we don't care if it succeeds, any errors are hidden by SFINAE.
This process instantiates AnyInitList for all types that the constructors of ManyListTypes can accept. We then use stateful metaprogramming to collect those types into a list.
The rest is easy. We create class SingleCtor<T> that's constructible from std::initializer_list<T>, then inherit the final type from several specializations of SingleCtor (inheriting constructors), one per type in the list we got.

*"it relies on some arcane tricks, and probably shouldn't be used in practice."* See [is-stateful-metaprogramming-ill-formed-yet](https://stackoverflow.com/questions/44267673/is-stateful-metaprogramming-ill-formed-yet) — Jarod42, Nov 03 '21 at 10:42

Constructor for any initializer_list accepted by given T

1 Answers1