从std::vector移除std::unique_ptr时触发迭代器断言失败问题排查

看起来你遇到的迭代器不可解引用问题，核心原因是并行迭代与容器修改的并发冲突，加上遍历过程中容器元素被删除导致的迭代器失效，具体分析和修复方案如下：

1. 核心问题分析 #

（1）并行查找的线程安全隐患 #

你在getAgentInstance和checkAgentType中使用了std::execution::par执行并行find_if：

auto it = std::find_if(std::execution::par, agentsVec.begin(), agentsVec.end(), ...);

但与此同时，Environment::updateHealth循环里会调用lattice->killAgent，后者通过std::experimental::erase_if修改agentsVec（删除元素）。

并行迭代的前提是容器在迭代期间绝对不能被修改——当erase_if删除元素时，vector的内部结构会发生变化（元素移动、内存可能重新分配），正在并行运行的find_if会持有失效的迭代器，甚至访问已经被销毁的unique_ptr，这直接触发了调试断言。

（2）遍历与删除的竞态条件 #

在Environment的双层网格循环中，你会在循环内部删除agentsVec的元素：

if (currentAgent->getHealth() <= -10) {
    lattice->killAgent(Position(i, j));
}

如果此时有并行查找任务正在访问agentsVec，或者循环后续代码还在引用已被删除的Agent指针，就会导致非法内存访问。

2. 修复方案 #

方案一：移除并行执行，改用串行查找 #

最简单的修复是去掉std::execution::par，改用默认的串行find_if，彻底避免并行迭代和容器修改的冲突：

// 移除 std::execution::par 参数
auto it = std::find_if(agentsVec.begin(), agentsVec.end(), [=](std::unique_ptr<Agent>& agent) { 
    return agent->getID() == ID; 
});

串行迭代时，容器的修改只会影响当前迭代过程，不会出现跨任务的迭代器失效问题。

方案二：添加线程同步（若必须保留并行） #

如果你确实需要并行查找提升性能，必须在访问和修改agentsVec时添加同步机制，比如用std::mutex保护：

// 在Lattice类中添加成员变量
std::mutex agentsMutex;

// 修改getAgentInstance
Agent* Lattice::getAgentInstance(Position position) {
    int ID = getAgentID(position);
    std::lock_guard<std::mutex> lock(agentsMutex); // 访问前加锁
    auto it = std::find_if(std::execution::par, agentsVec.begin(), agentsVec.end(), [=](std::unique_ptr<Agent>& agent) { 
        return agent->getID() == ID; 
    });
    if (it != agentsVec.end()) {
        return it->get();
    }
    return nullptr;
}

// 修改killAgent中的erase_if逻辑
std::lock_guard<std::mutex> lock(agentsMutex); // 修改前加锁
std::experimental::erase_if(agentsVec, [this, &positionID](auto const& agent) {
    auto agentID = agent->getID();
    if (positionID == agentID) {
        Utils::addIDToStack(agentID);
        return true;
    }
    return false;
});

这样能确保同一时间只有一个操作在访问或修改agentsVec，彻底避免竞态条件。

方案三：优化Agent查找方式（推荐） #

目前每次查找Agent都要遍历整个vector，效率低且容易出问题。可以维护一个ID到Agent指针的映射（比如std::unordered_map<int, Agent*>），将查找复杂度降到O(1)，同时避免遍历vector：

// 在Lattice类中添加成员变量
std::unordered_map<int, Agent*> agentIDMap;

// 生成Agent时同步插入映射
std::generate_n(agentVecIter, p.second, [this, &p]() {
    auto agent = factory.createAgent(p.first);
    changeAgentOnLattice(generatePosition(), agent->getID());
    agentIDMap[agent->getID()] = agent.get(); // 插入ID映射
    return agent;
});

// 修改getAgentInstance
Agent* Lattice::getAgentInstance(Position position) {
    int ID = getAgentID(position);
    auto it = agentIDMap.find(ID);
    if (it != agentIDMap.end()) {
        return it->second;
    }
    return nullptr;
}

// 修改killAgent，删除元素时同步更新映射
std::experimental::erase_if(agentsVec, [this, &positionID](auto const& agent) {
    auto agentID = agent->getID();
    if (positionID == agentID) {
        Utils::addIDToStack(agentID);
        agentIDMap.erase(agentID); // 从映射中移除
        return true;
    }
    return false;
});

这种方式既提升了查找效率，也从根源上避免了遍历vector带来的迭代器问题，即使不用并行查找也能获得不错的性能。

额外注意事项 #

• 若使用ID映射，必须保证agentIDMap与agentsVec的生命周期一致，删除Agent时必须同步删除映射中的条目，否则会出现悬空指针。
• 如果存在多线程环境，即使使用映射，也要用mutex保护映射的访问和修改，避免并发冲突。

内容的提问来源于stack exchange，提问作者Michael S.