How to write function for generic nested container in c++17?

Question

I want to implement a function with argument type like List<List<int>> where List maybe std::vector or std::list, or even std::vector with customed allocator, and at the same time, it also accepts raw brace enclosed expression

Currently I have a native try as following

#include <iostream>
#include <list>
#include <vector>

template<typename LLO = std::vector<std::vector<int>>>
void f(const LLO& a) {
   for (const auto& i : a) {
      for (const auto& j : i) {
         std::cout << j;
      }
      std::cout << '\n';
   }
}

template<typename LO = std::vector<int>, int = 0>
void f(const std::initializer_list<LO>& a) {
   f(std::vector(a));
}

int main() {
   f({{1, 2}, {3, 4}});
   f({std::vector{1, 2}, {3, 4}});
   f(std::list{std::list{1, 2}, {3, 4}});
   f({std::list{1, 2}, {3, 4}});
}

The most important test is f({std::list{1, 2}, {3, 4}}), it requires me to write an ugly overload for std::initializer_list explicitly.

In fact, in my situation, I have three arguments with nested container type like this, if I use this solution, I have to write 2^3=8 overload functions

I want to know whether there is some good-looking solution, and my code is under c++17, if it can be achieved easily in c++20 with concept, it would not help me this time but I am still curious about it.

Answer 1

If you can tolerate using an auxiliary function, you can do it as such:

#include <iostream>
#include <list>
#include <vector>

template<class LLO>
LLO
make_param(LLO&& a) { return std::forward<LLO>(a); }

template<template<class...> class Cont = std::vector, class T = int, class... Rest>
auto
make_param(std::initializer_list<Cont<T, Rest...>> ilist)
{
    return Cont<Cont<T, Rest...>, Rest...>(ilist);
}


template<class LLO>
void f(const LLO& p)
{
    //code here
}

template<class LLO1, class LLO2>
void f(const LLO1& p1, const LLO2& p2)
{
    //more code here
}

int main()
{
    f(make_param({{1, 2}, {3, 4}}));
    f(make_param({std::vector{1, 2}, {3, 4}}));
    f(make_param(std::list{std::list{1, 2}, {3, 4}}));
    f(make_param({std::list{1, 2}, {3, 4}}));

    std::vector<int, std::allocator<float>> v;
    f(make_param({v, v}));

    f(make_param({{1, 2}, {3, 4}}), make_param({std::list{1, 2}, {3, 4}}));
}

Another solution to not have to use an auxiliary function for every parameter could be something like this:

#include <iostream>
#include <list>
#include <vector>
#include <tuple>

template<class Item, template<class...> class Tuple, class... Types, std::size_t... Is>
std::tuple<Types..., Item>
tuple_append_impl(Item&& item, Tuple<Types...>& t, std::index_sequence<Is...>)
{
    return { std::move(std::get<Is>(t))..., std::forward<Item>(item) };
}

template<class Item, class... Types>
std::tuple<Types..., Item>
tuple_append(Item&& item, std::tuple<Types...>& t)
{
    return tuple_append_impl(std::forward<Item>(item), t, std::make_index_sequence<sizeof...(Types)>());
}

template<class... Conts>
struct param
{
    template<class LLO>
    param<Conts..., LLO>
    operator()(LLO&& a)
    {
        return { tuple_append(std::forward<LLO>(a), conts) };
    }

    template<template<class...> class Cont = std::vector, class T = int, class... Rest>
    param<Conts..., Cont<Cont<T, Rest...>, Rest...>>
    operator()(std::initializer_list<Cont<T, Rest...>> ilist)
    {
        return { tuple_append(Cont<Cont<T, Rest...>, Rest...>(ilist), conts) };
    }

    std::tuple<Conts...> conts;
};

template<>
struct param<>
{
    template<class LLO>
    param<LLO>
    operator()(LLO&& a) { return {std::forward<LLO>(a)}; }

    template<template<class...> class Cont = std::vector, class T = int, class... Rest>
    param<Cont<Cont<T, Rest...>, Rest...>>
    operator()(std::initializer_list<Cont<T, Rest...>> ilist)
    {
        return {Cont<Cont<T, Rest...>, Rest...>(ilist)};
    }
};

param() -> param<>;

template<class Cont>
void f(const param<Cont>& p)
{
    //function taking one param
    auto& llo = std::get<0>(p.conts);
}

template<class Cont1, class Cont2>
void f(const param<Cont1, Cont2>& p)
{
    //function taking two param
    auto&& llo0 = std::get<0>(p.conts);
    auto&& llo1 = std::get<1>(p.conts);
}

template<class Cont1, class Cont2, class Cont3>
void f(const param<Cont1, Cont2, Cont3>& p)
{
    //function taking three param
}

template<class... Conts>
void f2(const param<Conts...>& p)
{
    //function taking arbitrary amount of params
}

int main()
{
    f(param<>()({{1, 2}, {3, 4}}));
    f(param<>()({std::vector{1, 2}, {3, 4}}));
    f(param<>()(std::list{std::list{1, 2}, {3, 4}}));
    f(param<>()({std::list{1, 2}, {3, 4}}));

    f(param<>()({{1, 2}, {3, 4}})
            ({std::list{1, 2}, {3, 4}})
            (std::list{std::list{1, 2}, {3, 4}}));
}