具有类型的 C++ 多态性

Question

我正在尝试拥有一个具有 T 类型变量的节点，T data; 以及存储指向其父节点 NodeBase *parent; 的指针。

类如下所示：

class Node: public NodeBase {
    T data;
    NodeBase *parent;
public:
    Node(T);
    void setData(T);
    T * getData(void);
    void setParent(NodeBase * const);
    NodeBase * getParent(void);
};

class NodeBase {
};

我以为我可以在NodeBase中放一个纯虚函数，但是你必须指定返回类型，因为NodeBase没有类型我不能指定virtual T * getData(void) = 0;

我遇到问题的具体案例：

Node<char> n1 = Node('A');
Node<int>  n2 = Node(63);
n1.setParent(&n2);

NodeBase *pNode = n1.getParent();
pNode->getData(); // Error: BaseNode has no member 'getData()'

Answer 1

我相信您将运行时多态性与编译时多态性混淆了。模板提供后者。解决您的问题的一种可能方法是使 NodeBase 成为模板类：

template <class T>
class NodeBase {
    public:
        virtual T getData() = 0;
};

template <class T>
class Node : NodeBase<T> {
    T data;
    NodeBase *parent;

public:
    Node(T);
    void setData(T);
    T getData(void);
    void setParent(NodeBase<T> * const);
    NodeBase<T> * getParent(void);
};

请注意，我让getData 返回T 而不是T*。 （有理由返回指针吗？）

Answer 2

C++ 是静态类型的，所以每次你写这样的代码：

NodeBase *pNode = n1.getParent();
pNode->getData(); // Error: BaseNode has no member 'getData()'

编译器需要知道getData() 的类型。在您的情况下，您希望它是 int(void) 或 char(void) - 没有参数的函数返回 char 或 int。

有办法解决这个问题。该策略将取决于您的情况。返回类型有几种情况：

• 一组固定的 bultins - 使用联合
• 一组固定的内置函数或类，但类型永远不会改变 - 使用联合
• 修复了一组内置函数或类，但类型可能会改变 - 使用 boost 变体
• 任何其他情况 - 使用 boost any

所以总而言之，在返回上述数据结构之一的基类（非模板化）中添加一个虚函数。 boost 的文档很容易在网上找到。

这在 c++ 中要困难得多的原因是因为其他语言（尤其是动态语言）隐藏了困难。进行函数调用时，会分配空间 - 通常在堆栈上以获得最佳速度 - 并将返回值复制到该空间中。如果要返回未知类型，则需要使所有可能的返回类型（联合，也许是 boost 变体？）的最大可用空间，或者从堆中分配该空间（boost any）。许多静态类型语言只为前者提供良好的支持。

如果您想自己动手，C++ 确实有一些有用的功能。

#include <iostream>
#include <typeinfo>

using namespace std;

struct NodeBase {
    virtual ~NodeBase(){}
};

template<typename T>
struct Node: public NodeBase {
    T data;
    NodeBase *parent;

    Node(T data, NodeBase* parent = nullptr)
        : data(data), parent(parent)
    {}

    ~Node(){}
};

int main()
{
    Node<int>  n2(63);
    Node<char> n1('A', &n2);

    NodeBase* b = n1.parent; //pointer to n2

    if(typeid(*b) == typeid(Node<int>))
        cout << ((Node<int>*) b)->data << endl;

    return 0;
}

请注意，此功能需要 typeinfo 和 NodeBase 中的至少一个虚函数。

Answer 3

你可以给NodeBase添加一个模板函数：

class NodeBase {
    public:
       template<typename T>
       T* getData();
};

这会将对象转换为Node<T> 并返回getData()。这是一个工作示例 - 仅包含因为它实际上花了我一段时间来解决循环定义的问题：

class NodeBase {
    public:
    template<typename T>
    T* getData();
};

template<typename T>
class Node: public NodeBase {
    T data;
    NodeBase *parent;

protected:  
    friend NodeBase;
    T * getData(void){return &data;};

public:
    Node(T var){data=var;};
    void setData(T& var){data=var;};
    void setParent(NodeBase * const par){parent=par;};
    NodeBase * getParent(void){return parent;};
};

template<typename T>
T* NodeBase::getData(){ return dynamic_cast<Node<T>*>(this)->getData();};


int main(){
    Node<char> n1 = Node<char>('A');
    Node<int>  n2 = Node<int>(63);
    n1.setParent(&n2);

    NodeBase *pNode = n1.getParent();
    std::cout << *pNode->getData<int>() << std::endl;

    return 0;
}

Answer 4

NodeBase *pNode = n1.getParent();
pNode->getData(); // Error: BaseNode has no member 'getData()'

你有pNode（子），所以你可以直接使用getData()，其次你的基类对getData()一无所知，所以使用向上转换的指针你不能调用它。