Question

我有一个TypedNode类来存储一些数据：

template <typename Type>
class TypedNode {
 public:
  TypedNode() {}
  void SetNodeData(Type data) { data_ = data; }
  Type GetNodeData() { return data_; }

 private:
  Type data_;
};

然后我可以使用它：

int main() {
  TypedNode<int> int_node;
  TypedNode<double> double_node;
  TypedNode<Vector3d> vector3_node;

  int_node.SetNodeData(1);
  double_node.SetNodeData(2.3);
  vector3_node.SetNodeData(Vector3d(4,5,6));;
}

但是我想定义一个函数然后访问：

void Access(std::list<TypedNode> node_list) {
  for (auto node : node_list) {
    node.GetNodeData();
    // if it is an integer, do one thing
    // if it is a double, do another
  }
}

列表需要一个具体的类，但是我需要存储任何类型的节点。

有些我更改了Node的代码：

class NodeBase {
 public:
  NodeBase() {}
};

template <typename Type>
class TypedNode : NodeBase {
 public:
  TypedNode() {}
  void SetNodeData(Type data) { data_ = data; }
  Type GetNodeData() { return data_; }
 private:
  Type data_;
};

void Access(std::list<NodeBase> node_list) {
  for (auto node : node_list) {
    node.GetNodeData();
    // if it is an integer, do one thing
    // if it is a double, do another
  }
}

但是Access（）函数只能调用基类的方法。尽管每个派生类都有一个相同的名称接口SetNodeData，但它们具有不同的类型。因此它们是不同的。它们不能覆盖Base类中的一个相同接口。

我该怎么办？

================================================ ===============

这是我的解决方案：

#include <list>
enum NodeType {
  kInt,
  kDouble,
  kVector3,
};

class NodeBase {
 public:
  NodeBase() {}

  virtual int GetDataInt();
  virtual double GetDataDouble();
  virtual Vector3 GetDataVector3();
  NodeType type() const { return type_; }

 protected:
  void set_type(NodeType type) { type_ = type; }

 private:
  NodeType type_;
};

class NodeInt : NodeBase {
 public:
  NodeInt() { set_type(kInt); }
  int GetDataInt() override { return data_; }
  double GetDataDouble() override { check(false) << "error"; }
  Vector3 GetDataVector3() override { check(false) << "error"; }

 private:
  int data_;
};

class NodeDouble : NodeBase {
 public:
  NodeDouble() { set_type(kDouble); }
  int GetDataInt() override { check(false) << "error"; }
  double GetDataDouble() override { return data_; }
  Vector3 GetDataVector3() override { check(false) << "error"; }

 private:
  double data_;
};

void Access(const std::list<NodeBase>& node_list) {
  for (auto node : node_list) {
    switch (node.type()) {
      case kInt: {
        int data = node.GetDataInt();
        // do something about int
        break;
      }
      case kDouble: {
        double data = node.GetDataDouble();
        // do something about double
        break;
      }
      case kVector3: {
        Vector3 data = node.GetDataVector3();
        // do something about Vector3
        break;
      }
    }
  }
}

Answer 1

您的TypedNode模板没有明显的价值，它只是封装数据的获取器和设置器，因此为简单起见最好将其消除。您似乎需要的是可以是int，double或Vector3d的类型，以便可以将它们保存在同一容器中。为此，C ++ 17中有std::variant。使用不合标准的编译器的人可以使用基本相同的Boost.Variant，也可以使用C ++ 98。

#include <variant>

struct Vector3d {int x, y, z;};
using Node = std::variant<int,double,Vector3d>;

当然，当其中包含一些重要功能时，您可以使用std::variant<TypedNode<int>,TypedNode<double>,TypedNode<Vector3d>>。已发布的TypedNode没有任何功能，但键入起来却有些膨胀。

要使用相同的界面访问变体，有几种方法。例如，可以使用访客来完成。这是NodeOutput中每种类型的ostream输出的访问者Node。

#include <iostream>

struct NodeOutput {
    std::ostream& os_;
    NodeOutput(std::ostream& os) : os_{os} {}

    void operator()(Vector3d const& v3) 
    {
        os_ << "Vector3d (" << v3.x <<", "<< v3.y <<", "<< v3.z <<")\n";
    }
    void operator()(double const& d) {os_ << "Double " << d <<"\n";}
    void operator()(int const& i) {os_ << "Int " << i <<"\n";}
};

使用这样的访问者，我们可以为operator<<编写Node：

std::ostream& operator<< (std::ostream& os, Node const& v) {
    std::visit(NodeOutput{os}, v);
    return os;
}

尝试一下。 std::list是很少使用的容器，因此在这里为简单起见，将其替换为std::vector，但是它将与其他容器类似地工作。

#include<vector>

int main()
{
    std::vector<Node> nodes;
    nodes.emplace_back(42);
    nodes.emplace_back(6.66);
    nodes.emplace_back(Vector3d{3,2,1});

    for (auto& n: nodes) {std::cout << n;}   
}

输出：

Int 42
Double 6.66
Vector3d (3, 2, 1)

Answer 2

据我了解，您基本上想访问NodeBase的重写功能。您仍然可以使用模板来做到这一点。我不建议在您的设计上进行代码更改，因为我认为您过分简化了这一点，以使我们了解您希望代码执行的操作。

话虽如此，我们假设NodeBase类是NodeInt和NoteDouble的基类。看起来像这样（与您的相比略有简化）。

    class NodeBase
{
public:
  ...
  virtual void DoSomething()
  ...
};

class NodeInt : public NodeBase
{
public:
  ...
  virtual void DoSomething() //overridden
  {
  }
  ...
};

class NodeDouble : public NodeBase
{
public:
  ...
  void DoSomething()//overriden
  {
  }
  ...
};

我们还假设我们的Access函数看起来像;

template<typename Type, typename A>
void Access(std::list<TypedNode<Type>, A> node_list)
{
  for (auto node : node_list)
  {
    node.DoSomething();
  }
}

请注意，由于TypeNode，我们的Access函数现在可以获取包含TypedNode<Type>的任何类型的列表

Access函数的工作只是调用DoSomething。它不在乎它是什么类型。并且应该根据调用的内容推论得出，具体取决于我们作为Access调用的参数传递的内容。

如果传递给Access的列表是类型<TypedNode<NodeBase>，则您希望每个节点都呼叫NodeBase::DoSomething();
如果传递给Access的列表是您想要的类型<TypedNode<NodeInt> 每个要呼叫的节点NodeInt::DoSomething();
如果传递给Access的列表是类型<TypedNode<NodeDouble>，则您希望每个节点都呼叫NodeInt::DoSomething();

为此，首先让我们从参数化的模板参数继承，而不是从Base类继承。

template<typename Type>
class TypedNode : public Type

接下来，我们要为DoSomething类声明并定义TypedNode函数。

template<typename Type>
class TypedNode : public Type
{
  ...
   void DoSomething();
  ...
};

template<typename Type>
inline void TypedNode<Type>::DoSomething()
{
   Type::DoSomething();//this is where the magic happens.
}

注意Type::DoSomething();，这将使我们能够调用Generic Base类的DoSomething()函数。要注意的一件事是，当我们使用模板参数初始化对象时，在模板参数初始化中使用的类必须具有名为DoSomething的类成员，否则在编译过程中会出现错误。

例如；

 TypedNode<int> intNode;      //wont work because int doesnt have a member DoSomething.
 TypeNode<NodeBase> baseNode; //fine.
 TypeNode<NodeInt> intNode2;  //fine

最后，是为我们产生结果的主要代码。

int main() 
{
  std::list<TypedNode<NodeBase>> baseNodeList;
  std::list<TypedNode<NodeInt>> intNodeList;
  std::list<TypedNode<NodeDouble>> DoubleNodeList;

  TypedNode<NodeBase> baseNode;
  TypedNode<NodeInt> intNode;
  TypedNode<NodeDouble> doubleNode;

  baseNodeList.push_back(baseNode);
  intNodeList.push_back(intNode);
  DoubleNodeList.push_back(doubleNode);

  Access(baseNodeList);
  Access(intNodeList);
  Access(DoubleNodeList);
  return 0;
}

这是完整的代码https://ideone.com/2jEmBO

类具有相同的接口，但参数类型不同

2 个答案: