模板检测T是指针还是类

Template detects if T is pointer or class

本文关键字：指针 检测      更新时间：2023-10-16

考虑以下代码：

class MyClass
{
    ...
};
template <typename Object>
class List
{
public:
    void insert(const Object & x)
    {
        // call when Object is MyClass
    }
    void insert(const Object & x)
    {
        // call when Object is MyClass*
    }
}
int main()
{
    MyClass a;
    List<MyClass> lst;
    List<MyClass*> plst;
    lst.insert(a);
    plst.insert(new Myclass);
    return 0;
}

如何根据模板是类还是指针来告诉编译器调用不同的方法？

如何修复上面的代码？

您可以使用std::is_pointer和std::enable_if:的组合

#include <type_traits>
#include <iostream>
class MyClass
{
};
template <typename Object>
class List
{
public:
    template<class T=Object>
    void insert(T t, typename std::enable_if<std::is_pointer<T>::value >::type* = 0) 
    {
        std::cout << "insert pointer" << std::endl;
    }
    template<class T=Object>
    void insert(T t, typename std::enable_if<!std::is_pointer<T>::value >::type* = 0) 
    {
        std::cout << "insert non-pointer" << std::endl;
    }
};
int main()
{
    MyClass a;
    List<MyClass> lst;
    List<MyClass*> plst;
    lst.insert(a);
    plst.insert(new MyClass());
    return 0;
}

现场示例：https://ideone.com/CK8Zdo

这将允许您将指针和非指针都插入到指针或非指针列表中。如果你想限制它，你可以使用这个：

#include <type_traits>
#include <iostream>
class MyClass
{
};
template <typename Object>
class List
{
public:
    template<class T=Object>
    void insert(T t, typename std::enable_if<std::is_same<T,Object>::value&&std::is_pointer<T>::value >::type* = 0) 
    {
        std::cout << "insert pointer" << std::endl;
    }
    template<class T=Object>
    void insert(const T& t, typename std::enable_if<std::is_same<T,Object>::value&&!std::is_pointer<T>::value >::type* = 0) 
    {
        std::cout << "insert non-pointer" << std::endl;
    }
};
int main()
{
    MyClass a;
    List<MyClass> lst;
    List<MyClass*> plst;
    lst.insert(a);
    // plst.insert(a); // compiler error
    // lst.insert(new MyClass()); // compiler error
    plst.insert(new MyClass());

    return 0;
}

现场示例：https://ideone.com/3DtBfr

我知道我的答案并不完全是关于你的问题，但也许它会有所帮助。

我相信您的意图是让List类有一个insert方法(而不是两个(，这个方法的行为应该取决于您的模板参数。为此你可以为指针编写一个专门的类。然后，基本模板将用于非指针类型，而专门化将用于指针类型。

你的代码看起来是这样的：

template <typename Object>
class List
{
public:
    void insert(const Object & x)
    {
        // call when Object is MyClass
    }
};
template <typename Object>
class List<Object *>
{
public:
    void insert(Object * x)
    {
        // call when Object is MyClass*
    }
};

void insert(const Object & x)
{
    M_insert(x, dispatcher<std::is_pointer<Object>::value> );
}

在List内部使用调度员

template <bool B> class dispatcher {};
using ObjectPtr   = dispatcher<true>;
using ObjectValue = dispatcher<false>;

然后发送到M_insert:

void M_insert(const Object &p, ObjectPtr) { // Object is a pointer }
void M_insert(const Object &p, ObjectValue) { // Object is not a pointer }

这里是一个活生生的例子。但是，我鼓励你确定你是否真的需要，并可能相应地修改你的设计。

这就完成了任务：

template <typename Object>
class List
{
public:
    template<class C = Object>
    void insert(const C & x)
    {
        // call when Object is MyClass
        std::cout << "1" << "n" ;
    }
    template<class P = Object*>
       void insert(P* p)
    {
        // call when Object is MyClass*
        std::cout << "2" << "n" ;
    }
} ;

下面是一个工作示例。

相关文章：