模板检测T是指针还是类

Question

考虑以下代码：

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

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

如何修复上面的代码？

- barej

---

请发布一个MCVE。 - Baum mit Augen

更好的方法是以这样的方式重新编写您的代码，使其不关心它正在处理类还是指针。标准的list<T>和vector<T>类并不关心，为什么您的List<T>会关心呢？它在做什么取决于模板参数是类类型吗？ - user743382

Answer 1

您可以使用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;
}

Live example: https://ideone.com/3DtBfr

- m.s.

---

当我试图使用这个方法时，出现了编译错误。错误：未能满足要求 'std :: is_pointer <MyType> :: value'; 'enable_if' 无法用于禁用此声明。 - einstein

@einstein 是哪个例子？用的是哪款编译器？ - m.s.

我只是忘记在方法中为类重新分配模板参数，就像您的示例中那样。 但是在做了这件事之后，它运作得非常好！ - einstein

Answer 2

我知道我的回答并不完全是关于你所问的内容，但也许它可以帮助你。

我认为你的意图是拥有一个List类，其中只有一个插入方法（而不是两个），并且该方法的行为应该取决于你的模板参数。为此，您可以为指针编写一个类的特化。然后基本模板将用于非指针类型，而特化将用于指针类型。

你的代码应该像这样：

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*
    }
};

- robal

Answer 3

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 }

这里有一个实时示例here。但是，我鼓励您确定是否真的需要它，并可能相应地修复您的设计。

- edmz

Answer 4

这就是诀窍：

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" ;
    }
} ;

这里有一个可用的示例。

- TonyK

---

但这将允许插入非“Object”数据类型，我不认为这是被允许的。 - edmz