使模板功能来指定继承者和其他人

Make template function to destinguish inheritors and others

本文关键字：继承者 其他人 功能      更新时间：2023-10-16

我有一个类（base），它有许多继承者（derived_i）和一些其他类型（other）。我想在某个类处理程序（caller）中有一个模板方法，该方法以不同的方式处理base的继承者，然后是其他类型的继承者。

这是我讲述的一个示例代码。

#include <iostream>
using namespace std;
template <typename T>
class base {
public:
    base (T val = T())
        : m_val(val)
    {}
    base (const base &other)
        : base(other.m_val)
    {}
    virtual void base_specific_method()
    {
        cout << __func__ << " method called: " << m_val << endl;
    }
    void each_class_has_this() {
        cout << __func__ << " this is boring..." << endl;
    }
    T m_val;
};
class other {
public:
    void each_class_has_this() {
        cout << __func__ <<" this is boring..." << endl;
    }
};
class derived_i : public base <int>
{
public:
    derived_i () : base <int> (10)
    {}
    virtual void base_specific_method()
    {
        cout << __func__ <<" Hey! I'm interesting derived! And 10 == " << m_val << endl;
    }
};
template <typename T>
class caller {
public:
    caller (T val = T())
        : m_val(val)
    {}
    void call() {
        p_call(m_val);
    }
private:
    template <typename T1> void p_call (T1 &val)
    {
        val.each_class_has_this();
    }
    template <typename T1> void p_call (base<T1> &val)
    {
        val.base_specific_method();
    }
private:
    T m_val;
};
int main ()
{
    caller<other> c1;
    caller<base<double> > c2;
    caller<derived_i > c3;
    c1.call();
    c2.call();
    c3.call();
}

它使用 g++ -std=c++11 test.cpp 编译，输出是下一个：

  each_class_has_this this is boring...
  base_specific_method method called: 0
  each_class_has_this this is boring...

虽然我期待

  each_class_has_this this is boring...
  base_specific_method method called: 0
  base_specific_method Hey! I'm interesting derived! And 10 == 10

有没有办法更改此代码以使其适合我的请求？

这个问题似乎是另一个问题的重复，但是它的正确答案导致了我在这里遇到的问题。

附言没有办法从一个类中base和other继承者。 =（

您可以使用

SFINAE获得所需的行为：

添加类has_specific如下所示：

template <typename T>
class has_specific
{
    typedef char one;
    typedef long two;
    template <typename C> static one test( typeof(&C::base_specific_method) ) ;
    template <typename C> static two test(...);    
public:
    enum { value = sizeof(test<T>(0)) == sizeof(char) };
};

并将p_call的定义更改为：

template <typename T1=T>
typename enable_if<!has_specific<T1>::value,void>::type
p_call (T1 &val)
{
    val.each_class_has_this();
}
template <typename T1=T>
typename enable_if<has_specific<T1>::value,void>::type
p_call (T1 &val)
{
    val.base_specific_method();
}

在这种情况下，我在返回类型中使用了 SFINAE。应该可以在模板参数列表或参数列表中使用它，但这是我首先开始工作的那个。
作为技术细节，此实现不取决于您是否有从base派生的类，而是是否存在base_specific_method()方法，但我希望它仍然对您的问题有所帮助。

在线
试用has_specific从这里
取返回类型 SFINAE 从这里取

您可以将std::enable_if与std::is_base_of一起使用，以区分派生自base<T>的类。

template <typename T, typename TT = void>
class caller {
public:
    caller (T val = T())
        : m_val(val)
    {}
    void call() {
        p_call(m_val);
    }
private:
    template <typename T1> typename std::enable_if<!std::is_base_of<base<TT>, T1>::value>::type p_call (T1 &val)
    {
        val.each_class_has_this();
    }
    template <typename T1> typename std::enable_if<std::is_base_of<base<TT>, T1>::value>::type p_call(T1& val)
    {
        val.base_specific_method();
    }
private:
    T m_val;
};

请注意，base 是一个模板类，这意味着T1可能是 base<int> 或 base<double> 的派生类，依此类推。我们无法计算所有的可能性，因此需要指定模板参数TT作为提示。然后将其用作：

caller<other> c1;
caller<base<double>, double> c2;
caller<derived_i, int> c3;  // derived_i derived from base<int>
c1.call();
c2.call();
c3.call();

结果：

each_class_has_this this is boring...
base_specific_method method called: 0
base_specific_method Hey! I'm interesting derived! And 10 == 10

住

或者，您可以创建一个最基的类以使其简单：

class abstract_base {
public:
    virtual void base_specific_method() = 0;
    virtual ~abstract_base() {}
};
template <typename T>
class base : public abstract_base {
    ...
};
...
template <typename T>
class caller {
    ...
    template <typename T1> typename std::enable_if<!std::is_base_of<abstract_base, T1>::value>::type p_call (T1 &val)
    {
        val.each_class_has_this();
    }
    template <typename T1> typename std::enable_if<std::is_base_of<abstract_base, T1>::value>::type p_call(T1& val)
    {
        val.base_specific_method();
    }
    ...
};

直播2

相关文章：