Storing objects in multiple lists of shared_ptr

Question

I am working on a simple game for which i need to store the game-objects in containers. I want to store them in different std::list (objects that get drawn to the screen every frame, objects that need to be updated every frame, etc) so i can just iterate over all objects of a certain type when i need it. Now some objects have to be in more than one list (some of them get drawn and need to be updated every frame) and sometimes it is necessary to delete one from all lists that contain it. The objects should get deleted when they are removed from all lists. This is a simplified example of what i currently have:

#include <iostream>
#include <memory>
#include <string>
#include <list>

class A
{
public:

    A(std::string text)
    {
        message = text;
    }

    ~A()
    {
        std::cout << "Deleted: " << message << std::endl; 
    }

    std::string getMessage() { return message; }

private:

    std::string message;
};

int main()
{
    std::list<std::shared_ptr<A>> list1;
    std::list<std::shared_ptr<A>> list2;

    if(true) // to create scope
    {
        std::shared_ptr<A> tmp(new A("Test"));

        list1.push_back(std::shared_ptr<A>(tmp));
        list2.push_back(std::shared_ptr<A>(tmp));

    } // tmp out of scope


    // delete the object from both lists:
    auto i = std::begin(list1);

    while(i !=  std::end(list1))
    {
        if(i->get()->getMessage() == "Test");

        list1.remove(*i);
        list2.remove(*i); // the object gets deleted after this line
    }

    return 0;
}

It work's but it really seems overly complicated (i'm using C# at work where this task is trivial). I have very little experience with memory management using smart pointers. Am i doing something fundamentally wrong?

You can just use `{ }` pairs to introduce a scope, you don't need a dummy `if(true)`. — François Andrieux, Oct 21 '19 at 17:51
After `list1.remove(*i);` the iterator `i` is invalidated, the element it refers to no longer exists. The following `list2.remove(*i);` is undefined behavior. You need to revise how you choose to iterate. — François Andrieux, Oct 21 '19 at 17:54
I don't understand why it works then. The line runs without throwing an error and i get the expected output of "Deleted: Test" right after it. So the object does indeed get deleted from list2. I'm using GCC 8.3.0. What would be the proper way to delete an object from multiple lists of shared_ptr? Do i have to manually search it from every list individually? — Eric, Oct 21 '19 at 18:07
It's not your `A` object that gets deleted on the first `erase`, it's the `shared_ptr`. Then, the next `*i` is trying to dereference an invalidated iterator. It used to refer to the `shared_ptr` you just destroyed. But as luck would have it, on your platform, this time, apparently nobody happened to do anything to the memory that it occupied. So when your program pretends there's still a `shared_ptr` there it doesn't notice the problem. Errors are not required to crash in C++, you often just get Undefined Behavior. It might stop working for no apparent reason at any time. — François Andrieux, Oct 21 '19 at 18:21
[This answer](https://stackoverflow.com/a/6445794/7359094) has a good analogy as to why accessing a destroyed object won't necessarily crash and why you also can't count on it working each time. — François Andrieux, Oct 21 '19 at 18:24
Tactical note: It's rare, but `std::shared_ptr tmp(new A("Test"));` can still leak. The simple example is `new A("Test")` succeeds and you get a dynamic allocation but construction of `tmp` fails. the `A` is still out there, but you don't get `tmp`, so nothing points at it. Prefer to use [`std::make_shared`](https://en.cppreference.com/w/cpp/memory/shared_ptr/make_shared) if it is available. `std::shared_ptr tmp = std::make_shared ("Test");` — user4581301, Oct 21 '19 at 19:03
This is a question dealing with who is responsible for the lifetime of the object. This might not be the best solution but if these lists of objects are not responsible for keeping the object alive, you can give them weak pointers to the objects. Then when the owning container deletes the object, the weak pointer will be invalid and that is something you can check for when iterating over them. — Philip Nelson, Oct 21 '19 at 20:55

Storing objects in multiple lists of shared_ptr

0 Answers0