Как передать произвольную функцию-член ЛЮБОГО класса в шаблон, чтобы разрешить его подпись?

В моем движке у меня есть простая система отражения, заполненная информацией о классах во время компиляции (то есть построенная вокруг набора шаблонов, которая позволяет мне автоматизировать процесс генерации метаинфо).

Рассмотрим следующий пример:

class Type
{
  //...
  Map<PropertyHash, TypeProperty> _properties;
};

Для каждого типа есть функция:

template <class T>
void InitializeType(TypeInitializer* typeInitializer);

ответственный за инициализацию типа. TypeInitializer имеет несколько методов, используемых для добавления полей и базовых типов к типу. В общем, каждый новый тип требует только специализации этой функции. Позже, когда тип запрашивается в первый раз, TypeDatabase создает конкретный объект Type и вызывает InitializeType() для него (TypeInitializer получает указатель на тип во время построения). Например:

struct CST
{
    const float* fptr;
    volatile Uint32 vuint;
    void** vptr;
};

template <>
SvrInline void InitializeType<CST>(TypeInitializer* typeInitializer)
{
    typeInitializer->AddProperty("fptr", &CST::fptr);
    typeInitializer->AddProperty("vuint", &CST::vuint);
    typeInitializer->AddProperty("vptr", &CST::vptr);
}

И это все. Вся магия делается в конструкторе TypeProperty, который объявлен как:

template <class Object_type, class Property_type>
TypeProperty(const char* fieldName, Property_type (Object_type::* propertyPtr));

Это позволяет мне знать точный тип собственности. Я проверяю его на размер, постоянство, изменчивость и т. Д. И сохраняю эту информацию в объекте TypeProperty. Ницца.

Теперь мне нужно что-то идентичное для функций членов. "Идентичный" означает, что я могу добавить функцию точно так же, как я добавляю свойства прямо сейчас.

Моей первой мыслью были шаблоны с переменным числом аргументов (мой движок построен с полной поддержкой функций C++11):

template <typename Object_t, typename Return_t, typename... Args>
TypeMethod(const char* methodName, Return_t (Object_t::*)(Args&&... args)
{
  //What now?
}

Однако я не знаю, как мне извлекать типы из аргументов. Я видел статью с подходом, который использует перегрузку функций:

template <typename P, typename R, typename Arg1, typename... Args>
void Func(R (P::*)(Arg1 arg1, Args&&... args))
{
}

template <typename P, typename R, typename... Args>
void Func(R (P::*)(Args&&... args))
{
}

template <typename P, typename R>
void Func(R (P::*)())
{
}

Функция была "перенаправлена" рекурсивно (я знаю, что это не реальная рекурсия), каждый раз на один параметр меньше. Я не вижу, однако, как это подходит для моего случая.

Источник

3 ответа

Решение

Нет необходимости в рекурсии, просто используйте расширение пакета:

template <typename Object_t, typename Return_t, typename... Args>
TypeMethod(const char* methodName, Return_t (Object_t::*)(Args&&... args)
{
  setName(methodName);
  setObjectType<Object_t>();
  setReturnType<Return_t>();
  auto dummy[] = {0, (addArgumentType<Args>(), 0)...};
}

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

Источник 
...

template <typename P, typename R, typename Arg1, typename Arg2>
void Func(R (P::*)(Arg1 arg1, Arg2 arg2))
{
    // function type is R (P::*)(Arg1 arg1, Arg2 arg2)
}

template <typename P, typename R, typename Arg1>
void Func(R (P::*)(Arg1 arg1))
{
    // function type is R (P::*)(Arg1 arg1)
}

template <typename P, typename R>
void Func(R (P::*)())
{
     // function type is R (P::*)()
}

Я не знаком с разнообразными аргами. Это было единственное решение до C++11. Но теперь новые возможности C++ 11 могут решить эту проблему более элегантно.

КСТАТИ. Сначала я увидел этот способ разрешения подписи в реализации библиотеки boost.pyton.

Источник

С помощью decompose_mem_fun_ptr от /questions/47107586/ispolzovanie-in-dlya-sopostavleniya-atributa-obektov-python-v-massive/47107663#47107663

template <typename M>
TypeMethod(const char* methodName, M&m)
{
    setName(methodName);
    setObjectType<typename decompose_mem_fun_ptr<M>::class_type>();
    setReturnType<typename decompose_mem_fun_ptr<M>::return_type>();

    // use other info from decompose_mem_fun_ptr<M>.

    using args_type = typename decompose_mem_fun_ptr<M>::arguments; 

    internal_setArgs<args_type>(make_index_sequence<std::tuple_size<args_type>::value>());
}

template<typename Tuple, std::size_t...Is>
void internal_setArgs(index_sequence<Is...>)
{
    // Assuming setArg<T>(i_th).
    int dummy[] = {0, (setArg<typename std::tuple_element<Is, Tuple>::type>(Is), 0)...};
    static_cast<void>(dummy); // silent warning about unused variable.
}

за index_sequence а также make_index_sequence:

#if 1 // Not in C++11
#include <cstdint>

template <std::size_t ...> struct index_sequence {};

template <std::size_t N, std::size_t ...Is>
struct make_index_sequence : make_index_sequence < N - 1, N - 1, Is... > {};

template <std::size_t ... Is>
struct make_index_sequence<0, Is...> : index_sequence<Is...> {};

#endif // make_index_sequence
Источник
Другие вопросы по тегам