Variadic templates

[220Volt]

Здравствуйте!

Как передавать несколько parameter pack’ов? Пример:

template <typename... _Ty1, typename... _Ty2>
            void fn(_Ty1... args1,
                    _Ty2... args2)  {}
int main()
{
    fn( 3, 3 );
    return 0;
}

Компилируется, но как четко задать какие параметры в args1, а какие в args2?

[220Volt]

Решил вопрос при помощи std::tuple. Была задача - передать элементы в конструкторы родителей шаблона. Получилось что-то вроде:

#include <tuple>

struct S1
{
    int v1_1;
    int v1_2;
    S1(int v1_1, int v1_2): v1_1(v1_1), v1_2(v1_2) {}
    S1(std::tuple<int, int> pack)   { std::tie(this->v1_1, this->v1_2) = pack; }
};

struct S2
{
    int v2_1;
    int v2_2;
    S2(int v2_1, int v2_2): v2_1(v2_1), v2_2(v2_2) {}
    S2(std::tuple<int, int> pack)   { std::tie(this->v2_1, this->v2_2) = pack; }
};

template <typename _T1, typename _T2>
    struct Sd : public _T1, public _T2
    {
        template <typename... _Targs1, typename... _Targs2>
            Sd(std::tuple<_Targs1...> pack1,
               std::tuple<_Targs2...> pack2): _T1(pack1), _T2(pack2) {}
    };

int main()
{
    Sd<S1, S2> f( std::make_tuple(4, 6),    // Передаем в конструктор S1
                  std::make_tuple(2, 1)     // Передаем в конструктор S2
                );
    return 0;
}

[220Volt]

Так как появились variadic шаблоны и возможность наследоваться от variadic аргументов, на мой взгляд, появилась необходимость организовывать compile time циклы. Например, написать operator== или дочерний объект – это сумма возможностей родителей, т.е. нужно перебрать всех предков и вызвать нужные методы. В последние дни много плясал с бубном и реализовал такую штуку. Оставлю здесь, чтоб не потерялось, может кому пригодится (mingw):

struct S_base     { virtual void print() = 0; };

struct S_1 : virtual public S_base     {  void print()override   { std::cout<<"S_1\n"; }  };

struct S_2 : virtual public S_base     {  void print()override   { std::cout<<"S_2\n"; }  };

struct S_3 : virtual public S_base     {  void print()override   { std::cout<<"S_3\n"; }  };

namespace compound_object
{
    template <typename _This_type, typename... _Args>
        struct Compile_time_cycle
        {
            static void cycle(_This_type _this)
            {
                _this->template sub_print<_Args...>();
            }
        };

    template <typename _This_type>                  // Все аргументы обработаны, выход из цикла.
        struct Compile_time_cycle<_This_type>
        {
            static void cycle(_This_type thi) {}
        };

    template <typename... _Ty>
        struct S_final : public _Ty...
        {
        template <typename _This_type, typename... _Args>
            friend struct Compile_time_cycle;
        private:
            template <typename _First, typename... _Other>
                void sub_print()
                {
                    _First::print();
                    Compile_time_cycle<decltype(this), _Other...>::cycle(this);
                }
        public:
            void print()override
            {
               Compile_time_cycle<decltype(this), _Ty...>::cycle(this);
            }
        };
}


int main()
{
    std::cout<<"----------  p1 :\n";
    S_base *p1 =  new compound_object::S_final<S_3, S_1>();
    p1->print();
    std::cout<<'\n';

    std::cout<<"----------  p2 :\n";
    S_base *p2 =  new compound_object::S_final<S_1>();
    p2->print();
    std::cout<<'\n';

    std::cout<<"----------  p3 :\n";
    S_base *p3 =  new compound_object::S_final<S_2, S_3>();
    p3->print();
    std::cout<<'\n';

    return 0;
}