3

在我的引擎中，我有一个简单的反射系统，在编译时填充了类信息（也就是说，围绕一组模板构建，这使我能够自动化生成元信息的过程）。

考虑以下示例：

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?
}

但是，我不知道应该如何从 args 中提取类型。我看到了一篇文章，其中介绍了一种使用函数重载的方法：

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::*)())
{
}

函数被递归地“转发”（我知道这不是实际的递归），每次都少一个参数。但是，我看不出这如何适合我的情况。

4

3 回答 3

1

使用decompose_mem_fun_ptr来自http://coliru.stacked-crooked.com/a/00750bf7564ab6d4

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
于 2014-02-11T14:48:12.990 回答
1 
...

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 库实现中看到了这种解决签名的方法。

于 2014-02-11T14:10:21.847 回答
1

不需要递归，只需使用包扩展：

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<...>正确的顺序进行调用。

于 2014-02-11T14:20:49.930 回答