如何使变量类型多态起作用？

Question

我有一个模板节点，它返回 T 类型的数据。

template <class T> Node
{
public: 
     virtual const T& GetData() = 0;
};

我想要派生类 RefNode 和 ValueNode，它们包含指向数据的指针和实际数据。这样我就可以选择是使用数据副本还是使用节点中的实际数据。

template<class T> class RefNode : public Node<T>
{
public: 
    RefNode(T *_data) : data(_data) { }
    const T& GetData() { return *data; }
protected:
    DataType *data;
};

template<class T> class ValueNode : public Node<T>
{
public: 
    ValueNode(const T&_data) : data(_data) { }
    const T& GetData() { return data; }
protected:
    T data;
};

我知道模板不能有虚方法，但我只是想说明我想要得到的效果。我想要得到的效果是：

//对于类向量

Vector v, *c;
c = new Vector();
Node<Vector>* node = new RefNode<Vector>(c);
Node<Vector>* node2 = new ValueNode<Vector>(a);

node2->GetData(); //calls ValueNode<Vector>'s GetData();
node->GetData(); //calls RefNode<Vector>'s GetData();

C++ 中有什么方法可以实现这种行为吗？

编辑：

我会像这样使用 GetData()：

Vector *vecarr[9];

Node<Vector>* nodes[10];
nodes[0] = new RefNode<Vector>(vecarr[0]);
nodes[1] = new ValueNode<Vector>(Vector(2,3)); //non reference vector
nodes[2] = new RefNode<Vector>(vecarr[1]);
nodes[3] = new RefNode<Vector>(vecarr[2]);
.....

void processPositionNodes(Node<Vector> **nodes, int n)
{
   for(int i=0; i< n; i++)  //iterate over all nodes
   {
      Vector vec = nodes[i]->GetData();
      //do something with vec

   }
}

我希望能够更改节点包含的数据类型，因为我想实现几种处理不同类型数据的图形算法，（向量、标量..）

Answer 1

这段代码可以正常工作（您的版本有一些小的和不相关的更改）：

#include <iostream>

using namespace std;

template <class T>
class Node
{
public: 
     virtual const T& GetData() = 0;
};

template<class T>
class RefNode : public Node<T>
{
public: 
    RefNode(T *_data) : data(_data) { *data = 5; }
    const T& GetData() { return *data; }
protected:
    T *data;
};

template<class T> class ValueNode : public Node<T>
{
public: 
    ValueNode(const T&_data) : data(_data) { data = 5; }
    const T& GetData() { return data; }
protected:
    T data;
};

int main(){
    double data;
    Node<double>* rn = new RefNode<double>(&data);
    Node<double>* rv = new ValueNode<double>(data);

    const double& a = rn->GetData();
    const double& b = rv->GetData();

    cout << a << '\t' << b << endl;
}

但是，此代码存在一些潜在问题：Node 类中缺少虚拟析构函数，RefNode 类中缺少复制 ctor、dtor 和 operator=

Answer 2

正如 cmets 中所指出的，模板确实可以具有虚函数。但是，这并不能解决您的问题。事实上，您需要这些函数具有不同的返回类型。

这可能是针对您的问题的基于模板的解决方案，它可能不是最优雅的，但您（我们）可以在此基础上工作

#include <iostream>

using namespace std;

template <typename T, template<typename> class Accessor, template<typename> class Traits>
class Node{
    public:
        Node() : data(5.){}
        typedef typename Traits<T>::type getType;
        getType get(){
           return static_cast<Accessor<T>*>(this)->implementation();
        }
        virtual ~Node(){}
    protected:
        T data;
};

template <typename T>
struct TraitsP{
    typedef T* type;
};

template <typename T>
class PointerAccessor : public Node<T, PointerAccessor, TraitsP>{
    public:
        typename TraitsP<T>::type implementation(){
            return &(Node<T, PointerAccessor, TraitsP>::data);
        }
};

template <typename T>
struct TraitsD{
    typedef T type;
};

template <typename T>
class DirectAccessor : public Node<T, DirectAccessor, TraitsD>{
    public:
        typename TraitsD<T>::type implementation(){
            T ret = Node<T, DirectAccessor, TraitsD>::data;
            return ret;
        }
};

int main(){
    auto np = new PointerAccessor<double>();
    double* p = np->get();
    cout << *p << endl;

    auto np2 = new DirectAccessor<double>();
    double d = np2->get();
    cout << d << endl;
}

这个解决方案可能看起来很奇怪，PointerAccessor 是由 Node\<... pointeraccessor ...> 派生的。这就是所谓的Curiously Recurring Template Pattern (CRTP)