#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>


template <std::size_t N>
bool increase(const std::array<std::size_t , N> & sizes,
              std::array<std::size_t, N> & indexes) {
    bool is_increased = false;
//Создадим цикл, в котором переберем все возможные комбинации. Будем изменять индекс контейнера до момента, когда они закончатся. После этого обнулим индекс исходного контейнера, увеличивая индекс предыдущего. Так будем делать до тех пор, пока не будут перебраны все возможные комбинации. После того, как все возможные комбинации будут рассмотрены, функция вернет значение false.
    for(std::size_t i = 0; i < N; ++i) {
        const std::size_t index = N-1-i;
        ++indexes[index];
        if(indexes[index] >= sizes[index])
            indexes[index] = 0;
        else {
            is_increased = true;
            break;
        }
    }

    return is_increased;
}

template<typename F, std::size_t ... Indexes,
        std::size_t N, typename Tuple>
void apply(F && function,
           //ссылка на rvalue: вместо глубокого копирования данных кучи, скопируем указатель, а затем установим исходный указатель на ноль. Это необходимо, чтобы реализовать перемещение без дублирования кода и издержек времени выполнения
           std::index_sequence<Indexes...>,
           //последовательность индексов
           const std::array<std::size_t, N> &indexes, //массив индексов
           const Tuple &tuple) //кортеж векторов из функции combine
{
    function(std::get<Indexes>(tuple)[indexes[Indexes]]...);
    //вызывется лямбда функция, в которой происходит добавление нового элемента в конец контейнера result. Новый элемент - это кортеж, который является частичным прямым произведением с элементами контейнеров vs.., индексы которых достаются из контейнера indexes, который был построен в is_increased).
}


template<typename ... Types>
auto combine(const std::vector<Types> &... vs) {

    std::vector<std::tuple<Types...>> result; //создается контейнер с типом кортеж, типы которого равны исходным типам контейнеров vs...

    constexpr std::size_t N = sizeof...(Types); //вычисляется количество исходных контейнеров

    std::array<std::size_t, N> sizes = {vs.size()...};//создается массив, содержащий размеры исходных контейнеров
    std::array<std::size_t, N> indexes; //создается массив, содержащий индексы исходных контейнеров
    indexes.fill(0);


    //создаем цикл, который будет работать до тех пор, пока bool increase != false
    for (;increase(sizes, indexes) ;) {
        apply([&result](const auto &...args) { result.emplace_back(args...); },
                //лямбда-функция, которая в контейнер result добавляет( при помощи функции emplace_back() ) все возможные аргументы. В нашем случае, это будут кортежи, содержащие в себе частичное прямое произведение из всевозможных комбинаций индексов контейров vs...
              std::make_index_sequence<N>(),
              //создается последовательность индексов ( в compile time)
              indexes, std::tie(vs...)); //кортеж из всевозможных контейнеров vs...
    }
    return result;

}

// =============================================================================

int main(int argc, char **argv) {


    std::vector<int> v1 = {1, 2};
    std::vector<std::string> v2 = {" A ", " B ", " C "};
    std::vector<int> v3 = {4, 5, 6, 7};

    const auto result = combine(v1, v2, v3);

    for (const auto &t : result) {
        std::cout << '(' <<
                  std::get<0>(t) << ' ' <<
                  std::get<1>(t) << ' ' <<
                  std::get<2>(t) << ')' << ',';
    }
    std::cout << std::endl;

    system("pause");
    return 0;
}