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

Question

I believe this will be my first question for the site, so I apologize for any mistakes or errors in this post. I am a beginner C++ programmer as well, so forgive me if my questions come across as “noobish”.

Background: A collection of Parent Entity objects are created at startup (and currently not removed or added-to during runtime), and are then linked to a series of Activator Entity objects (both at the beginning, and during, runtime) through a Child Entity object. When establishing a link, the Parent generates a Child (which is stored in a local vector), and returns a pointer to the Child for the Activator to store.

Activators will “activate” children they are linked with, which will then do jobs based off internal and Parent settings. After being activated, they are also updated periodically by the Parent, continuing until eventually deactivating.

Below is a simplified example of the classes present.

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();
        }
    }
};

With that all laid out, my three questions are:

1. Is there a way to update Pointers when a vector resizes?

When a Child is added, if it goes past the expected capacity, the vector creates a new array and moves the original objects to the new location. This breaks all of the Activator pointers, and any m_ActiveChild pointers, as they are pointing to the old location.

2. Is there a way to remove Child objects from the m_Children vector?

Since ChildEntity objects will host const items within them, copy assignment operations won't work smoothly, and the Vector's erase function won't work. The m_Children vector could be rebuilt without the unwanted object through a temporary vector and copy constructor, but this leads to all of the pointers being wrong again.

3. Please let me know if there are any other suggested optimizations or corrections I should make!

Thank you all for your help!

Answer 1

Your problem, abstractly seen, is that on one hand you have collections of objects that you want to iterate through, kept in a container; and that on the other hand these objects are linked to each other. Re-ordering the container destroys the links.

Any problem can be solved by an additional indirection: Putting not the objects but object handles in the container would make re-ordering possible without affecting cross-references. The trivial case would be to simply use pointers; modern C++ would use smart pointers.

The disadvantage here is that you'll move to dynamic allocation which usually destroys locality right away (though potentially not if most allocations happen during initialization) and carries the usual run-time overhead. The latter may be prohibitive for simple, short-lived objects.

The advantage is that handling pointers enables you to make your objects polymorphic which is a good thing for "activators" and collections of "children" performing "updates": What you have here is the description of an interface which is typically implemented by various concrete classes. Putting objects in a container instead of pointers prevents such a design because all objects in a container must have the same concrete type.

If you need to store more information you can write your own handle class encapsulating a smart pointer; perhaps that's a good idea from the beginning because it is easily extensible without affecting all client code with only a moderate overhead (both in development and run time).