C++ 一种m元树结构的遍历方法

我有一个节点类和一个树类（带模板），我想为我的树类编写一个遍历方法，打印出结构中的每个节点。但我只得到根的子元素，之后就没有任何打印了

---

这是我的代码。它有点太长了，但所讨论的方法名为traverse（），它正好位于main函数之前

#include <iostream>
#include <cstddef>
#define N 5

template <typename V>
class Node {
private:
  V _data;
  unsigned short _size;
  Node<V>* _children;

  template <typename U>
  friend std::ostream& operator<< (std::ostream&, const Node<U>&);

public:
  Node();
  Node(V, unsigned short);
  Node(const Node&); // copy constructor
  Node& operator= (Node&); // assignement by copy constructor
  Node (Node&&); // transfer constructor
  Node& operator= (Node&&); // assignement by transfer constructor
  ~Node();
  V getData() const;
  unsigned short getSize() const;
  Node<V>* getChildren();
  void setChild(unsigned short, Node<V>);
};

template <typename V>
Node<V>::Node()
  : _data(0), _size(0), _children(nullptr) {}

template <typename V>
Node<V>::Node(V data, unsigned short size)
  : _data(data), _size(size), _children(new Node<V>[_size]) {
}

template <typename V>
Node<V>::Node (const Node& other)
  : _size(other._size), _data(other._data) {
  _children = new Node<V>[_size];
  for (unsigned short i = 0; i < _size; i++) 
    _children[i] = other._children[i];
}

template <typename V>
Node<V>& Node<V>::operator= (Node& n){
  if (&n != this) {
    delete[] _children;
    _data = n._data; _children = n._children; _size = n._size;
    n._data = 0; n._size = 0; n._children = nullptr;
  }
  return *this;
}

template <typename V>
Node<V>::Node (Node&& n){
  _data = n._data; _size = n._size; _children = n._children;
  n._data = 0; n._size = 0; n._children = nullptr;
}

template <typename V>
Node<V>& Node<V>::operator= (Node&& n){
  if (&n != this) {
    delete[] _children;
    _data = n._data; _children = n._children; _size = n._size;
    n._data = 0; n._size = 0; n._children = nullptr;
  }
  return *this; 
}

template <typename V>
Node<V>::~Node() { delete[] _children; }

template <typename V> // TO DO : move this to class scope ???
V Node<V>::getData() const {return _data;}

template <typename V>
unsigned short Node<V>::getSize() const {return _size;}

template <typename V>
Node<V>* Node<V>::getChildren() {return _children;}

template <typename V>
void Node<V>::setChild(unsigned short index, Node<V> childNode){
  this->_children[index] = childNode;
}

template <typename V>
std::ostream& operator<< (std::ostream& o, const Node<V>& node){
  if (node._data) o << node._data ;
  return o;
}

template <typename V>
class Tree {
private:
  Node<V>* _info;
public:
  Tree();
  Tree(Node<V>*);
  Tree(V, unsigned short);
  ~Tree() = default;
  Node<V>* info();
  void traverse();
  void traverse_process(Node<V>*, unsigned short);
};

template <typename V>
Tree<V>::Tree() 
  : _info(nullptr) {}

template <typename V>
Tree<V>::Tree(Node<V>* newNode)
  : _info(newNode) {}

template <typename V>
Tree<V>::Tree(V data, unsigned short size) {
  Node<V>* node = new Node<V>(data, size);
  _info = node;
}

template <typename V>
Node<V>* Tree<V>::info() { return _info;}

template <typename V>
void Tree<V>::traverse() {
  traverse_process(this->_info, _info->getSize());
}

template <typename V>
void Tree<V>::traverse_process(Node<V>* node, unsigned short size) {
  if (node){
    for (unsigned short i = 0; i < size; i++) {
      if (node->getChildren()[i].getData()){
        std::cout << node->getChildren()[i] << std::endl;
        traverse_process(node->getChildren()[i], size);
      }
    }
  }
}

int main(int argc, char const *argv[]) {
  Node<char> n1('A', N); // root 
  Node<char> n1_1('B',N); // child of n1
  Node<char> n1_2('C', N); // child of n1
  Node<char> n1_3('D', N); // child of n1
  Node<char> n1_4('E', N); // child of n1
  Node<char> n1_1_1('F', N); // child of n1_1
  Node<char> n1_1_2('G', N); // child of n1_1
  Node<char> n1_1_3('H', N); // child of n1_1
  Node<char> n1_2_1('I', N); // child of n1_2
  Node<char> n1_2_2('J', N); // child of n1_2
  Node<char> n1_1_1_1('K', N); // child of n1_1_1
  n1.setChild(0,n1_1);
  n1.setChild(1,n1_2);
  n1.setChild(2,n1_3);
  n1.setChild(4,n1_4);
  n1_1.setChild(1, n1_1_1);
  n1_1.setChild(2, n1_1_2);
  n1_1.setChild(3, n1_1_3);
  n1_2.setChild(2, n1_2_1);
  n1_2.setChild(4, n1_2_2);
  n1_1_1.setChild(0, n1_1_1_1);
  Tree<char> t(&n1);
  t.traverse();
  return 0;
}

#包括
#包括
#定义n5
模板
类节点{
私人：
V_数据；
未签名的短\u大小；
节点*_子节点；
模板
friend std:：ostream&operator_children[index]=childNode；
}
模板
std:：ostream&operatorgetSize（）；
}
模板
void Tree:：遍历_进程（节点*节点，无符号短大小）{
如果（节点）{
for（无符号短i=0；igetChildren（）[i].getData（））{
std:：cout getChildren（）[i]getChildren（）[i]，size）；
}
}
}
}
int main（int argc，char const*argv[]{
节点n1（'A'，N）；//根
节点n1_1（'B'，N）；//n1的子节点
节点n1_2（'C'，N）；//n1的子节点
节点n1_3（'D'，N）；//n1的子节点
节点n1_4（'E'，N）；//n1的子节点
节点n1_1_1（'F'，N）；//n1_1的子节点
节点n1_1_2（'G'，N）；//n1_1的子节点
节点n1_1_3（'H'，N）；//n1_1的子节点
节点n1_2_1（'I'，N）；//n1_2的子节点
节点n1_2_2（'J'，N）；//n1_2的子节点
节点n1_1_1_1（'K'，N）；//n1_1_1的子节点
n1.setChild（0，n1_1）；
n1.setChild（1，n1_2）；
n1.setChild（2，n1_3）；
n1.setChild（4，n1_4）；
n1_1.setChild（1，n1_1_1）；
n1_1.setChild（2，n1_1_2）；
n1_1.setChild（3，n1_1_3）；
n1_2.setChild（2，n1_2_1）；
n1_2.setChild（4，n1_2_2）；
n1_1_1.setChild（0，n1_1_1）；
树t&n1；
t、 导线（）；
返回0；
}

---

非常感谢您的帮助

您的节点有两个副本：

• 您在这里的堆栈上分配它们：

  Node n1（'A'，N）

• 他们在这里创建自己的子节点：

  \u children=newnode[\u size]

调用setChild（）时，它会执行以下操作：

• this->\u children[index]=childNode

它将整个节点从堆栈上的节点复制到该节点拥有的节点

因此，当您将孙子添加到堆栈上的孙子时，

traverse\u进程

不会看到任何内容，因为它使用不同的副本。这就是为什么遍历的第一级可以工作，而深层次不行

---

要修复它，您需要为节点拥有的子节点添加访问器，并在那里调用setChild。或者，您需要更改_children的工作方式，以便从堆栈分配的节点向它提供指针。

错误消息的描述会有所帮助。我把整件事都扔到了戈德博尔特，一切正常。我不得不将第一个参数改为

traverse\u process

改为

&node->getChildren（）[I]

，尽管@parktomatomi我编辑了这个问题。。。没有任何错误。我得到根的子元素，在那之后，即使我对根的每个子元素调用traverse\u过程，我也不会得到子元素的任何打印。输出是

bcd E

，它只是根的子级，而不是所有的子级。谢谢你的回答。我现在明白了这个问题，但我无法解决它。我不明白你最后一段是什么意思。请您详细说明或给出解决方案的提示。您需要确保正在设置的节点的所有者是其父节点。使用您现在拥有的API，您可以这样做：

auto&n1_1=n1.getChildren（）[0]=Node（'B'，N）并且它将工作，因为
n1_1
成为对
n1
拥有的节点的引用，然后您为其分配一个临时节点，该节点应调用移动分配操作符。但是，这也有点乏味。您可以尝试调整API以使其更易于使用。非常感谢您的回答