C++中如何实现可回收复用的对象唯一标识符分配机制

你的核心问题在于当前的UniqueID类只维护了一个单向递增的nextID静态变量，完全没有处理对象销毁后的ID回收逻辑，所以删除对象后新创建的ID会继续往上累加，而不是复用已释放的ID。下面给出两种符合你需求的解决方案，你可以根据实际场景选择：

方案一：重用已释放的单个ID（通用场景） #

这个方案会维护一个可用ID池，当对象被销毁时把ID放回池里，新对象创建时优先从池里取可用ID，没有可用ID时再使用递增的新ID。这种方式适合需要最大化ID复用的场景，哪怕只删除了部分对象也能回收对应的ID。

修改后的完整代码：

#include <iostream>
#include <vector>
#include <queue>  // 新增：用于存储可用ID的队列

class UniqueID {
protected:
    static int nextID;
    static std::queue<int> availableIDs;  // 静态队列：存储已释放的ID
public:
    int id;
    UniqueID();
    ~UniqueID();
    UniqueID(const UniqueID& orig);
    UniqueID& operator=(const UniqueID& orig);
};

// 初始化静态成员
int UniqueID::nextID = 0;
std::queue<int> UniqueID::availableIDs;

UniqueID::UniqueID() {
    if (!availableIDs.empty()) {
        // 优先使用已释放的ID
        id = availableIDs.front();
        availableIDs.pop();
    } else {
        // 没有可用ID时，生成新的递增ID
        id = ++nextID;
    }
}

UniqueID::~UniqueID() {
    // 对象销毁时，将ID放回可用池
    availableIDs.push(id);
}

// 拷贝构造和赋值逻辑保持不变
UniqueID::UniqueID(const UniqueID& orig) {
    id = orig.id;
}

UniqueID& UniqueID::operator=(const UniqueID& orig) {
    id = orig.id;
    return(*this);
}

int main() {
    std::vector<UniqueID> UniqueIDs;
    for (int i = 0; i < 3; i++) {
        UniqueID e;
        UniqueIDs.push_back(e);
        std::cout <<"Create "<< e.id << std::endl;
    }
    std::cout << "\n";
    // 删除对象
    for (int b = int(UniqueIDs.size()) - 1; b >= 0; b--) {
        std::cout << "Delete "<< UniqueIDs[b].id << std::endl;
        UniqueIDs.erase(UniqueIDs.begin() + b);
    }
    std::cout << "\n";
    // 新对象会重用已释放的ID
    for (int i = 0; i < 3; i++) {
        UniqueID e;
        UniqueIDs.push_back(e);
        std::cout << "Create " << e.id << std::endl;
    }
}

运行这段代码会得到你预期的输出：

Create 1
Create 2
Create 3

Delete 3
Delete 2
Delete 1

Create 1
Create 2
Create 3

方案二：所有对象销毁后重置ID序列（特定场景） #

如果你只需要在所有对象都被销毁时，让新对象的ID从1重新开始，而不是复用单个释放的ID，可以通过维护一个活跃对象计数器来实现。

修改后的完整代码：

#include <iostream>
#include <vector>

class UniqueID {
protected:
    static int nextID;
    static int activeCount;  // 静态计数器：跟踪当前存在的对象数量
public:
    int id;
    UniqueID();
    ~UniqueID();
    UniqueID(const UniqueID& orig);
    UniqueID& operator=(const UniqueID& orig);
};

// 初始化静态成员
int UniqueID::nextID = 0;
int UniqueID::activeCount = 0;

UniqueID::UniqueID() {
    activeCount++;
    // 当第一个对象创建时，重置ID计数器
    if (activeCount == 1) {
        nextID = 0;
    }
    id = ++nextID;
}

UniqueID::~UniqueID() {
    activeCount--;
    // 当最后一个对象销毁时，重置ID计数器
    if (activeCount == 0) {
        nextID = 0;
    }
}

// 拷贝构造需要递增活跃计数器（拷贝出的对象也是新的活跃对象）
UniqueID::UniqueID(const UniqueID& orig) {
    id = orig.id;
    activeCount++;
}

// 赋值操作不需要修改计数器（只是ID赋值，对象本身已存在）
UniqueID& UniqueID::operator=(const UniqueID& orig) {
    id = orig.id;
    return(*this);
}

int main() {
    std::vector<UniqueID> UniqueIDs;
    for (int i = 0; i < 3; i++) {
        UniqueID e;
        UniqueIDs.push_back(e);
        std::cout <<"Create "<< e.id << std::endl;
    }
    std::cout << "\n";
    // 删除对象
    for (int b = int(UniqueIDs.size()) - 1; b >= 0; b--) {
        std::cout << "Delete "<< UniqueIDs[b].id << std::endl;
        UniqueIDs.erase(UniqueIDs.begin() + b);
    }
    std::cout << "\n";
    // 所有对象销毁后，新对象从1开始分配ID
    for (int i = 0; i < 3; i++) {
        UniqueID e;
        UniqueIDs.push_back(e);
        std::cout << "Create " << e.id << std::endl;
    }
}

这个方案的输出和你预期完全一致，适合只需要在全量销毁后重置ID的场景。

内容的提问来源于stack exchange，提问作者zisosak