шаблонное множественное наследование с переменным типом аргумента - PullRequest
Новая
       47

шаблонное множественное наследование с переменным типом аргумента

0 голосов
/ 22 ноября 2018

Мне нужно наследовать несколько раз следующий класс, принимая переменные аргументы в качестве параметров шаблона.

template <class SignalDispatcherClass, class ... ArgTypes>
class ISignalMap
{
//private
public:

    void RegisterSlot(SignalAddress pSignalFunc, ISlotInvoker<ArgTypes...>* pSlotInvoker)
    {
        //implementation
    }
};

Пока что я могу расширить пакет параметров и получить несколько специализаций класса, но с функциями, принимающими только один аргумент. 

template <class SignalDispatcherClass, class ... ArgTypes>
class ISignalStorage : public ISignalMap<SignalDispatcherClass, ArgTypes>...
{
};

///////
ISignalStorage<SignalA, int, double, bool> iss;

На данный момент это позволяет мне регистрировать функции слотов содин аргумент (int, double или bool - соответственно).Мне нужно что-то, что выглядело бы так: 

ISignalStorage<SignalA, <int, double, bool>, <int, int>, <const char*>> iss;

До сих пор я рассматривал другие вопросы, и один из них, кажется, несколько близок к теме, хотя я не смог реализовать или понять это.Хотелось бы, чтобы был более простой способ ( Вариативные шаблоны Variadic )

добавлено: пример кода 

struct IDummySlot
{
    void FuncDbl(double)
    {}
    void FuncInt(int)
    {}
    void FuncIntDbl(int, double)
    {}
};

template <class ... Args>
struct ISlotInvoker
{};

template <class SignalDispatcherClass, class ... ArgTypes>
class ISignalMap
{
public:

    void RegisterSlot(void(IDummySlot::*pSignalFunc)(ArgTypes...), ISlotInvoker<ArgTypes...>* pSlotInvoker)
    {
        return;
    }
};

template <class SignalDispatcherClass, class ... ArgTypes>
class ISignalStorage : public ISignalMap<SignalDispatcherClass, ArgTypes>...
{
};


int main()
{
    ISignalStorage<IDummySlot, int, double> iss;

    ISlotInvoker<int> slot_int;
    ISlotInvoker<double> slot_double;
    ISlotInvoker<int, double> slot_intDouble;

    //iss.RegisterSlot(&IDummySlot::FuncInt, &slot_int); //ambigous
    /*Appears to be that I didn't test it, I just saw that inheritance worked as I expected, but didn't try to invoke*/

    return 0;
}

enter image description here

Ответы [ 2 ]

0 голосов
/ 22 ноября 2018

На данный момент это позволяет мне регистрировать функции слотов с одним аргументом (int, double или bool - соответственно).Мне нужно что-то похожее на:

ISignalStorage<SignalA, <int, double, bool>, <int, int>, <const char*>> iss;

Как лучше объяснил Сэм Варшавчик, этот тип потребностей обычно управляется упаковкой пакетов типов в качестве аргументов шаблона длядругой класс.Обычно используется std::tuple, который предлагает несколько удобных инструментов для управления пакетом типов, но вы также можете определить тривиальный шаблонный класс / структуру следующим образом (TW для "оболочки типа") 

template <typename...>
struct TW
 { };

Я предлагаю немного другое решение, которое является нейтральным по отношению к оболочке (так что вы можете использовать с классическим std::tuple, с пользовательским TW или также смешивая их) 

template <typename, typename>
struct ISignalStorageHelper;

template <typename T, template <typename...> class C, typename ... Ts>
struct ISignalStorageHelper<T, C<Ts...>> : public ISignalMap<T, Ts...>
 { };

template <typename SignalDispatcherClass, typename ... Tuples>
class ISignalStorage
   : public ISignalStorageHelper<SignalDispatcherClass, Tuples>...
 { };

Таким образом, мы можем избежать usingизвлечь type внутри промежуточной структуры, но ISignalStorage наследовать также от ISignalStorageHelper структур (надеюсь, это не проблема).

Вы можете определить ISignalStorage объекты, используя кортежи 

ISignalStorage<foo, std::tuple<int, double>, std::tuple<double, int>> a;

Упаковка на заказ как TW

ISignalStorage<foo, TW<int, double>, TW<double, int>> a;

или также смешивание 

ISignalStorage<foo, std::tuple<int, double>, TW<double, int>> a;
0 голосов
/ 22 ноября 2018

Фундаментальная проблема здесь заключается в том, что не существует синтаксиса для «сжатия» нескольких пакетов переменных параметров из одного пакета параметров.

Обычный подход в подобных ситуациях заключается в использовании std::tuple дляоберните каждый отдельный пакет параметров и создайте пакет параметров из этих кортежей: 

    ISignalStorage<foo, std::tuple<int, double>, std::tuple<double, int>> a;

Затем просто разверните каждый пакет параметров из std::tuple, используя специализацию: 

#include <tuple>


template <class SignalDispatcherClass, class ... ArgTypes>
class ISignalMap
{
};

// Take a class, and a tuple. Give me an ISignalMap for the class, and
// what's in the tuple.

template<typename cl, typename tuple_t> struct tuple_expansion;

template<typename cl, typename ...tuple_types>
struct tuple_expansion<cl, std::tuple<tuple_types...>> {

    typedef ISignalMap<cl, tuple_types...> type;
};

// Syntactic sugar.    
template<typename cl, typename tuple_t>
using tuple_expansion_t=typename tuple_expansion<cl, tuple_t>::type;

// And a variadic parameter pack of tuples...

template <class SignalDispatcherClass, class ... ArgTypes>
class ISignalStorage : public tuple_expansion_t<SignalDispatcherClass,
                        ArgTypes>...
{
};

class foo;

void bar()
{

    // Note the syntax: pass each "inner" parameter pack wrapped into a
    // tuple.
    ISignalStorage<foo, std::tuple<int, double>, std::tuple<double, int>> a;

    ISignalMap<foo, int, double> &b=a;
    ISignalMap<foo, double, int> &c=a;
}
...