c++不一样的对象池

#include <iostream>
using namespace  std;

const int N = 10;

// 注意越界问题
template<size_t S>
struct idAllocator {
    // 存储回收的节点的 id
    int recycledQueue[S];

    //  [0, recycleTop] 可回收区域
    //  用户回收再利用
    int recycledIndex;

    //  最大下一个可用下标, 只增不减
    int currentMaxAllocID;

    idAllocator() {
        recycledIndex = 0;
        currentMaxAllocID = 0;
    }

    // 若回收队列不空, 从回收队列取, 否则重新申请
    int get() {
        if (recycledIndex > 0) {
            return recycledQueue[recycledIndex--];
        }
        return ++currentMaxAllocID;
    }

    void put(int x) {
        recycledQueue[++recycledIndex] = x;
    }
};

// 注意越界问题
template<size_t S, typename Object, typename IdAllocator = idAllocator<S>>
struct ObjectPool {
    IdAllocator idAlloc;
    Object freeNode[S];

    // 通过分配下标来简化
    inline int newNode() {
        return idAlloc.get();
    }

    Object &getObject(int x) {
        return freeNode[x];
    }

    void put(int x) {
        idAlloc.put(x);
        freeNode[x].reset();
    }

};

// 测试代码



enum class Child{
    Left = 0,
    Right = 1
};


struct binaryTreeNodeIterator;

struct binaryTreeNode {
    int val;
    int children[2];

    binaryTreeNode() {
        reset();
    }

    void setValue(int v) {
        val = v;
    }

    void reset() {
        val = 0;
        children[0] = 0;
        children[1] = 0;
    }

    int add(Child ch, int index) {
        return children[(int)ch] = index;
    }

    int children_num() const{
        return sizeof(children) / sizeof(int);
    }

    binaryTreeNodeIterator begin();

    binaryTreeNodeIterator end();
};

struct binaryTreeNodeIterator {
    int currIndex;
    int sz;
    binaryTreeNode& node;
    binaryTreeNodeIterator(binaryTreeNode& node, int index = 0) : node(node) {
        currIndex = index;
        sz = node.children_num();
    }

    binaryTreeNodeIterator& operator++() {
        ++currIndex;
        return *this;
    }

    int operator* () {
        return node.children[currIndex];
    }

    bool operator==(const binaryTreeNodeIterator& other) const {
        return  this->currIndex == other.currIndex;
    }

    bool operator!=(const binaryTreeNodeIterator& other) const {
        return !(*this == other);
    }
};

binaryTreeNodeIterator binaryTreeNode:: begin() {
    return binaryTreeNodeIterator(*this);
}

binaryTreeNodeIterator binaryTreeNode:: end() {
    return binaryTreeNodeIterator(*this, children_num());
}

ObjectPool<N, binaryTreeNode> pool;

struct binaryTree {
    int rootIndex;

    binaryTree() {
        rootIndex = pool.newNode();
    }

    binaryTree(int val) {
        rootIndex = pool.newNode();
        pool.getObject(rootIndex).setValue(val);
    }

    void add(Child ch, int nIndex, int val) {
        int cIndex = pool.getObject(nIndex).add(ch, pool.newNode());
        pool.getObject(cIndex).setValue(val);
    }

    void addLeft(int nIndex, int val) {
        add(Child::Left, nIndex, val);
    }

    void addRight(int nIndex, int val) {
        add(Child::Right, nIndex, val);
    }
};

void preOrderTraversal(int index) {
    if (!index) {
        return;
    }
    cout << pool.getObject(index).val << endl;
    for(auto child : pool.getObject(index)) {
        preOrderTraversal(child);
    }
}


int main() {
    binaryTree tre(0);
    tre.addLeft(tre.rootIndex, 1);
    tre.addRight(tre.rootIndex, 2);
    preOrderTraversal(tre.rootIndex);
    return 0;
}