C ++，一种在矢量调整大小后更新指针并在不复制的情况下擦除矢量对象的方法？

Question

我相信这将是我对该网站的第一个问题，因此对于本文中的任何错误或错误，我深表歉意。我也是一个初学者 C++ 程序员，如果我的问题被认为是“noobish”，请原谅我。

背景：父实体对象的集合在启动时创建（目前在运行时未删除或添加），然后链接到一系列激活器实体对象（在开始时和运行时期间）通过子实体对象。建立链接时，Parent 生成一个 Child（存储在本地向量中），并返回指向 Child 的指针供 Activator 存储。

激活器将“激活”与它们链接的子级，然后它们将根据内部和父级设置执行工作。在被激活后，它们也会由 Parent 定期更新，一直持续到最终停用。

下面是现有类的简化示例。

class ParentEntity {
    std::vector<ChildEntity> m_Children;
    std::vector<ChildEntity*> m_ActiveChildren;
public:
    //Funcs
    ParentEntity(unsigned expectedChildren) { m_Children.reserve(expectedChildren); }
    ChildEntity* AddChild(){
        m_Children.push_back(ChildEntity(*this));
        return &(m_Children.back());
    }
    void RemoveChild(unsigned iterator) {
        //Can't figure a way to remove from the m_Children list without disrupting all pointers. 
        //m_Children.erase(m_Children.begin() + iterator); Uses Copy operators, which wont work as Const values will be present in Child
    }
    void AddActiveChild(ChildEntity* activeChild) {
        m_ActiveChildren.push_back(activeChild);
    }
    bool Update(){  //Checks if Children are active, 
        if (!m_ActiveChildren.empty()) {
            std::vector<ChildEntity*> TempActive;
            TempActive.reserve(m_ActiveChildren.size());
            for (unsigned i = 0; i < m_ActiveChildren.size(); i++) {
                if (m_ActiveChildren[i]->Update()) {
                    TempActive.push_back(m_ActiveChildren[i]);
                }
            }
            if (!TempActive.empty()) {
                m_ActiveChildren = TempActive;
                return true;
            }
            else {
                m_ActiveChildren.clear();
                return false;
            }
        }
        else {
            return false;
        }
    }
};

class ChildEntity {
public:
    ChildEntity(ParentEntity& Origin) //Not const because it will call Origin functions that alter the parent
        :
        m_Origin(Origin)
    {}
    void SetActive() {
        m_ChildActive = true;
        m_Origin.AddActiveChild(this);
    }
    bool Update() { //Psuedo job which causes state switch
        srand(unsigned(time(NULL)));
        if ((rand() % 10 + 1) > 5) {
            m_ChildActive = false;
        }
        return m_ChildActive;
    }
private:
    ParentEntity& m_Origin;
    bool m_ChildActive = false;
};


class ActivatorEntity {
    std::vector<ChildEntity*> ActivationTargets;
public:
    ActivatorEntity(unsigned expectedTargets) { ActivationTargets.reserve(expectedTargets); }
    void AddTarget(ParentEntity& Target) {
        ActivationTargets.push_back(Target.AddChild());
    }
    void RemoveTarget(unsigned iterator) {
        ActivationTargets.erase(ActivationTargets.begin() + iterator);
    }
    void Activate(){
        for (unsigned i = 0; i < ActivationTargets.size(); i++) {
            ActivationTargets[i]->SetActive();
        }
    }
};

综上所述，我的三个问题是：

1. 有没有办法在向量调整大小时更新指针？

添加 Child 时，如果超出预期容量，则向量会创建一个新数组并将原始对象移动到新位置。这会破坏所有 Activator 指针和任何 m_ActiveChild 指针，因为它们指向旧位置。

1. 有没有办法从 m_Children 向量中删除子对象？

由于 ChildEntity 对象将在其中托管 const 项，因此复制分配操作将无法顺利进行，并且 Vector 的擦除功能将无法正常工作。 m_Children 向量可以通过临时向量和复制构造函数在没有不需要的对象的情况下重建，但这会导致所有指针再次出错。

1. 如果有任何其他建议的优化或更正，请告诉我！

感谢大家的帮助！

Answer 1

抽象地看，您的问题是，一方面您有要迭代的对象集合，保存在容器中；另一方面，这些对象是相互关联的。重新排序容器会破坏链接。

任何问题都可以通过额外的间接方式解决：在容器中放置对象而不是对象句柄 可以在不影响交叉引用的情况下进行重新排序。最简单的情况是简单地使用指针；现代 C++ 会使用智能指针。

这里的缺点是您将转向动态分配，这通常会立即破坏局部性（尽管如果大多数分配发生在初始化期间，则可能不会）并带有通常的运行时开销。后者对于简单的、短暂的对象来说可能是令人望而却步的。

优点是处理指针使您能够使对象多态，这对于“激活器”和执行“更新”的“子”集合是一件好事：您在这里拥有的是对通常实现的接口的描述由各种具体类。将 objects 放在容器中而不是 pointers 会阻止这样的设计，因为容器中的所有对象都必须具有相同的具体类型。

如果您需要存储更多信息，您可以编写自己的句柄类来封装智能指针；或许从一开始这就是一个好主意，因为它很容易扩展，而不会影响所有客户端代码，而且开销适中（在开发和运行时）。