Question

在我的代码中，我需要测试给模板的类型是否为指针 - 是否聪明。根据提升，没有可靠和通用的方法（参见here） - 或者在那里？

到目前为止，我检查了以下内容：

答：可以T转换为void*吗？
B：T是否有get()方法？
C：T是否有名为element_type的类型？
D：get()会返回element_type*吗？

如果（A || B＆amp; C＆amp;＆amp; D），那么我得出结论，我的类型必须是某种指针。

这是模板：

template <typename T>
class is_pointer_type
{
    typedef struct { char array[1]; } yes;
    typedef struct { char array[2]; } no;

    template <typename C> static yes test_g(decltype(&C::get));
    template <typename C> static no  test_g(...);

    template <typename C> static yes test_e(typename C::element_type*);
    template <typename C> static no  test_e(...);

    enum {
        has_get          = sizeof(test_g<T>(0)) == sizeof(yes),
        has_element_type = sizeof(test_e<T>(0)) == sizeof(yes)
    };

    template <typename Q, bool OK = false>
    struct get { struct type {}; };

    template <typename Q>
    struct get<Q, true>
    {
        typedef decltype(((Q*)nullptr)->get()) type;
    };

    template <typename Q, bool OK = false>
    struct ptr { struct type {}; };

    template <typename Q>
    struct ptr<Q, true>
    {
        typedef typename Q::element_type* type;
    };

public:
    enum {
        types_ok = std::is_same<
                           typename get<T, has_get>::type,
                           typename ptr<T, has_element_type>::type
                   >::value,
        value    = std::is_convertible<T, void*>::value || types_ok
    };
};

到目前为止，似乎没问题。但这种推理有什么问题吗？我应该为不愉快的惊喜做好准备吗？那么const / volatile呢？

更新（动机）：

在评论中你要求我的动机并且他们是对的，我欠你一个。用例是Lua-C ++绑定库：当使用template <typename T> push_value(T value)向Lua公开类实例时，我需要在U和{{1}的任意组合中推导出基础类型T = U const/volatile/*/&。 }}。我需要知道基础类T = some_pointer<U>是否已经使用活页夹进行了注册。

Answer 1

很容易检查类型是否为指针，使用boost或定义具有专门化的自定义模板，如

template <typename C> static no test_pointer(C);
template <typename C> static yes test_pointer(C*);

但如果你更喜欢它，你可以坚持使用void *解决方案。

要检查智能指针，我建议检查适当的运算符。我认为只有同时具有operator *和operator-＆gt;的类型才能被认为是智能指针。定义。所以你应该检查

template <typename C> static yes test_deref(decltype(&C::operator*));
template <typename C> static no test_deref(...);
template <typename C> static yes test_arrow(decltype(&C::operator->));
template <typename C> static no test_arrow(...);

并要求两个结果都为'是'。因此，最终公式可以计算为“正常指针||（有运算符*＆amp;＆amp; has operator-＆gt;）”。

但是，它只是智能指针的解决方案。如果你还想将智能指针（其他包装器，集合等）以外的类型传递给Lua而不是一个完全不同的故事，我不敢为此提出解决方案。

测试类型是否为（智能）指针的通用方法

更新（动机）：

1 个答案: