#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;
}
c++不一样的对象池
最新推荐文章于 2024-09-28 13:59:06 发布