首先，要指出的是：C++了、不是C，要尽量使用对象和引用，而不是内存和指针。
    
    先看，C++中树状结构避免使用new对象的例子：
#include <iostream>
#include <vector>
using namespace std;

class TreeNode{
private:
    static int maxLevel;
    int level;
    int id;
    string name;
    vector<TreeNode> children;
public:
    TreeNode(int id,string name){
        this->level=0;
        this->id=id;
        this->name=std::move(name);
    }
    bool operator < (const TreeNode& other) const{
        return this->name < other.name;
    }
    TreeNode& getChild(int i){//这个方法是最重要的方法，C++的非指针版本的树结构中一定要有这个方法，返回左值引用
        return this->children[i];
    }
    void addChild(TreeNode& node){
        node.level=this->level+1;
        if(node.level>maxLevel){
            maxLevel=node.level;
        }
        this->children.push_back(node);
    }
    ~TreeNode(){
        children.clear();
    }
    void printTree()const{
        for(int i=this->level;i<=maxLevel;i++){
            printLevel(i,*this);
            cout<<endl;
        }
    }
    void printLevel(const int targetLevel, const TreeNode& parent)const{
        if(targetLevel==parent.level){
            cout<<parent.id<<"\t";
            return;
        }else if(targetLevel>parent.level){
            for(int i=0;i<parent.children.size();i++){
                printLevel(targetLevel,parent.children[i]);
            }
        }
    }
};

int TreeNode::maxLevel=0;

int main(){
    TreeNode root(1,"root");

    TreeNode level1Node2(2,"2");
    root.addChild(level1Node2);
    TreeNode level1Node3(3,"3");
    root.addChild(level1Node3);

    TreeNode level2Node4(4,"4");
    //root.getChild(0).addChild(level2Node4);//C++从业人员必知必会内容>>>>>C++中级联调用是错误的C++使用方法：返回值为引用，返回的是一个地址变量，当赋值操作结束，存储这个地址变量的空间就立马释放了，所以，在C++中不能使用级联调用
    TreeNode& child=root.getChild(0);//左值引用
    child.addChild(level2Node4);
    TreeNode level2Node5(5,"5");
    child=root.getChild(0);
    child.addChild(level2Node5);

    TreeNode level2Node6(6,"6");
    child=root.getChild(1);
    child.addChild(level2Node6);
    TreeNode level2Node7(7,"7");
    child=root.getChild(1);
    child.addChild(level2Node7);



    root.printTree();
    return 0;
}
打印结果：
1
2       3
4       5       6       7

    关键点：利用vector中的存储的对象的引用避免了指针的使用。

    注意：树状结构中为了避免指针的使用，一定要定义获取第几个子节点的对象引用的方法，即：TreeNode& getChild(int i)。



    再看C++中使用指针和动态内存分配功能实现的循环链表。

    注意：在C++中，新建一个指针指向的对象使用new，删除一个指针指向的对象使用delete。

    代码如下：

#include <iostream>
using namespace std;
template<class T>
class Item{
private:
    Item* prev;
    Item* next;
    T data;
public:
    explicit Item(T data){//explicit：不能使用Item t=999999;等于号来隐式构造对象，只能使用Item t(999999);来构造对象
        this->data=data;
    }
};
template<class T>
class LinkedTable{
private:
    Item<T>* head;
public:
    LinkedTable(){
        head = nullptr;
    }
    ~LinkedTable(){
        while(head != head){
            auto tmp=head;
            head->prev->next=head->next;
            head->next->prev=head->prev;

            head=head->next;
            delete tmp;
        }
        if(head!=nullptr){
                delete head;
                head=nullptr;
        }
    }
    void push_head(T data){
        auto* item = new Item<T>(data);
        if(head == nullptr){
            head = item;
            head->next = head;
            head->prev = head;
        }else{
            item->next = head->next;
            head->next = item;
            item->prev = head;
        }
    }
    void push_back(T data){
        auto* item = new Item<T>(data);
        if(head == nullptr){
            head = item;
            head->next = head;
            head->prev = head;
        }else{
            item->prev = head->prev;
            head->prev = item;
            item->next = head;
        }
    }
    T* pop_head(){
        if(head== nullptr){
            return nullptr;
        }else{
            Item<T>*item=head;
            if(head->next==head){
                head = nullptr;
            }else{
                head->next->prev=head->prev;
                head->prev->next=head->next;
                head=head->next;
            }
            return item;
        }
    }
};