在 c++ 中不使用虚函数从模板化派生类访问方法？

Question

我该如何解决这个问题？我显然无法将 value() 方法设为虚拟，因为我事先不知道它是什么类型，并且在从 b 访问该方法时可能不知道这一点：

class Base
{
public:
    Base() { }
    virtual ~Base() { }
private:
    int m_anotherVariable;
};

template <typename T>
class Derived : public Base
{
public:
    Derived(T value) : m_value(value) { }
    ~Derived() { }

    T value() { return m_value; }
    void setValue(T value) { m_value = value; }
private:
    T m_value;
};

int main()
{
    Base* b = new Derived<int>(5);

    int v = b->value();

    return 0;
}

编译错误：

error: 'class Base' has no member named 'value'

Answer 1

此语句：

int v = b->value();

变量“b”被视为 Derived的对象。
所以告诉编译器：

int v = dynamic_cast<Derived<int>*>(b)->value();

注意：如果 b 不是 Derived；转换结果为 NULL。
因此，以下内容可能会更安全：

Derived<int>*  d = dynamic_cast<Derived<int>*>(b);
if (d)
{
    int v = d->value();
}
else
{
    // Error
}

或者，通过使用引用，您会抛出 bad_cast 异常：

// Throw bad_cast on failure.
Derived<int>& d = dynamic_cast<Derived<int>&>(*b);
int v = d->value();

或者为了友好和晦涩，我们可以用一行来做。

// Assign v or throw bad_cast exception:
int v = dynamic_cast<Derived<int>&>(*b).value();

但我认为你可以通过 boost::any 实现你想要做的事情

int main()
{
    boost::any   b(5);

    int    v = boost::any_cast<int>(b);

    b        = 5.6; // double
    double d = boost::any_cast<double>(b);
}

Answer 2

如果您提出这个问题，我认为您的设计可能存在一些问题（根据我的设计经验）。
但是，有一些解决方法：

1. 正如其他人已经回答的那样，您可以将 Base 设为类模板。
2. 您可以向下转型 b （尽管我更愿意尽可能避免向下转型）
3. 您可以在 Base 中声明 value() 返回 boost::any 并使其成为纯虚拟
4. 您甚至可以将其声明为返回 void* （但不要这样做这是一种选择，但不是一个好选择）

但这里真正的问题是你想在这里描述什么？ Base、Derived 和 value() 的含义是什么。问自己这些问题，你可能不需要这些答案......

Answer 3

一些解决方案：

template < typename T>
class Base{
public: 
    Base() { }    
    virtual ~Base() { }
    virtual T value() = 0;
private:    
    int m_anotherVariable;
};

template <typename T>
class Derived : public Base<T> {
  ...
}

int main(){    
    Base<int>* b = new Derived<int>(5);    
    int v = b->value();    
    return 0;
}

另一个解决方案：

class Base {
public: 
    Base() { }    
    virtual ~Base() { }
    template<class T> T value() const;
private:    
    int m_anotherVariable;
};

template <typename T>
class Base2 : public Base {
public: 
    Base2() { }    
    virtual ~Base2() { }
    virtual T getValue() const = 0;    
};

template<class T> T Base::value() const {
    const Base2<T> * d = dynamic_cast<const Base2<T> *>(this);
    return d ? d->getvalue() : T();
}

template <typename T>
class Derived : public Base2<T> {
public:    
    Derived(T value) : m_value(value) { }    
    virtual ~Derived() { }    
    void setValue(T value) { m_value = value; }
    virtual T getValue() const { return  m_value; }    
private:    
     T m_value;
}

int main(){    
    Base* b = new Derived<int>(5);    
    int v = b->value<int>();
    return 0;
}

Answer 4

在这种情况下，Base 将需要了解模板类型，因此 b->value 返回 T。

我建议将模板添加到 Base，然后将 value 设置为 Base 上的虚拟函数

Answer 5

您可以将指针强制转换为 Derived：

int v = dynamic_cast<Derived<int>*>(b)->value();

当然，在实际代码中，您必须添加检查以确保 dynamic_cast 不会失败。

Answer 6

为什么不制作基于 Base 模板的类呢？那么您就可以拥有作为虚拟会员的价值。

或者您可以将 b 向下转型为 Derived。

Answer 7

看起来您想要动态多态性，但只使用模板的“静态多态性”。

如果您想要动态多态性，您确实需要基类中的虚拟成员（以及虚拟析构函数）或 down_cast （如果您没有通用接口）。

如果没有，请删除虚拟析构函数并仅使用指向派生类型的指针或实例。

关于 Base 作为模板：

它将阻止您拥有用于动态多态性的单个基类，如 Base<;整数>且基数＜其他>将会不兼容。

Answer 8

处理此问题的一种方法是通过访问者模式。基本思想是，在类的层次结构中实现一个接受访问者的 onNode 函数。然后，您编写执行您想要的操作的特定访问者。就你而言，你最终会得到：

class GetIntValue : public BaseVisitor
{
public:
  GetIntValue (int & result)
  : m_result (result) {}

  void onNode (Derived<int> & d)
  {
    m_result = d.m_value;
  }
  void onNode (Derived<A> & d)
  {
    assert (! "calling GetIntValue on a node that doesn't have a value");
  }


private:
  int & m_result;
};

int main()
{
  Base* b = new Derived<int>(5);

  int v;
  GetIntValue(v).visit (*b);

  return 0;
}