从向量中删除 shared_ptr 时从 unordered_map 中删除 shared_ptrs（模拟）

Question

Let's consider this piece of code:

class Organism
{ //some code here..
}
class World
{    
    unordered_map<int, std::shared_ptr<Organism>> organims_map;
    vector <std::shared_ptr<Organism>> animals_vector;
    add_organisms { 
    //i want to create specified shared_ptr destructor here

}

Shortly speaking I use a vector to store shared_pointers to store all animals inside World. I use an unordered map for instant access to animals by their coordinates ( int value will be based on the 2-dimensional position of the organism, I may change it to std::pair but just skip it, it's not important for now).

I want to have a custom deleter to shared_ptrs that is inside std::vector which will also delete shared_ptr that points to the same object in std::map ( Because if something is not inside my animals_vector IT MUST NOT BE INSIDE MY organisms_map ).

I'm asking about how to write such a specified destructor for std::shared_ptr .

Answer 1

Your approach won't work, because your custom-deleter won't execute until the last shared_ptr to a given Organism has gone away, and since you are keeping each Organism in two different data structures, there will always be a second shared_ptr in your animals_map after you removed the one from the animals_vector .

As a workable alternative, I suggest writing your own remove_animal(std::shared_ptr) method that removes the entry from both data structures, and have your code call that method instead. (Making both of the data structures private can help ensure that all of the calling code uses your methods rather than trying to access the data structures directly, and therefore that your constraints don't get unintentionally violated)

Answer 2

I don't think your problem asks for a custom deleter, I think you mainly run into problems because you do double bookkeeping. You have both a map and a vector containing the same information, a set of animals in your world. I would propose you only keep the map.

What you need back is an easy way to iterate over all the animals in your map, for that you can use a custom iterator. And this example shows you how you can achieve a syntax like this :

int main()
{
    world_t world;
    for (const auto& animal : world.animals())
    {
        std::cout << animal << std::endl;
    }
}

Full source code : (PS. I am still double-checking the full correctness of the custom iterator, I don't write them often, but for this example, it works)

// https://stackoverflow.com/questions/69243916/deleting-shared-ptrs-from-unordered-map-when-deleting-shared-ptr-from-vector-s

#include <algorithm>
#include <map>
#include <string>
#include <iostream>
#include <vector>

//=================================================================================================
// map_value_iterator.h

//-------------------------------------------------------------------------------------------------
// implementation of a custom iterator over std::map that returns the values

namespace impl
{
    template<typename key_t, typename value_t>
    struct const_map_value_iterator_t
    {
        using iterator_category = std::forward_iterator_tag;
        using value_type = value_t; 
        using difference_type = std::ptrdiff_t;
        using pointer = const value_t*; // <== not completely sure this is correct, todo check
        using reference = const value_t&;

        // the underlying map iterator type
        using underlying_iterator_t = typename std::map<key_t, value_t>::const_iterator;

        const_map_value_iterator_t() = default;

        explicit const_map_value_iterator_t(const underlying_iterator_t& it) :
            m_map_iterator{ it }
        {
        }
    
        const_map_value_iterator_t(const const_map_value_iterator_t& rhs) :
            m_map_iterator{ rhs.m_map_iterator }
        {
        }
    
        const_map_value_iterator_t& operator=(const const_map_value_iterator_t& rhs)
        {
            m_map_iterator = rhs.m_map_iterator;
        }

        reference operator*() const
        {
            return (m_map_iterator->second);
        }

        pointer operator->() const
        {
            return &(m_map_iterator->second);
        }

        const_map_value_iterator_t& operator++()
        {
            ++m_map_iterator;
            return *this;
        }

        const_map_value_iterator_t& operator++(int)
        {
            ++m_map_iterator;
            return *this;
        }

        const_map_value_iterator_t& operator--()
        {
            --m_map_iterator;
            return *this;
        }

        const_map_value_iterator_t& operator--(int)
        {
            --m_map_iterator;
            return *this;
        }

        bool operator==(const const_map_value_iterator_t& rhs)
        {
            return m_map_iterator == rhs.m_map_iterator;
        }

        bool operator!=(const const_map_value_iterator_t& rhs)
        {
            return m_map_iterator != rhs.m_map_iterator;
        }

    private:
        underlying_iterator_t m_map_iterator;
    };

} /* namespace impl */

//-------------------------------------------------------------------------------------------------
// struct to initialize iterator based on a map
// and to provide a nice grouping of begin/end
// so both can be returned by one getter.

template<typename key_t, typename value_t>
struct map_values_iterator_t
{
    explicit map_values_iterator_t(const std::map<key_t, value_t>& map) :
        m_begin{ map.begin() },
        m_end{ map.end() }
    {
    }

    const auto& begin() const
    {
        return m_begin;
    };

    const auto& end() const 
    {
        return m_end;
    };

private:
    impl::const_map_value_iterator_t<key_t, value_t> m_begin;
    impl::const_map_value_iterator_t<key_t, value_t> m_end;
};

//=================================================================================================
// main.cpp
// inline example

struct animal_t
{
    animal_t(std::string n, std::size_t v) :
        name{ n },
        vigor{ v }
    {
    }

    // Sort orde by increasing vigor
    static bool order_by_vigor(const animal_t* lhs, const animal_t* rhs)
    {
        return lhs->vigor > rhs->vigor;
    }

    std::string name;
    std::size_t vigor;
};


class world_t 
{
public:

    // return the iterator over values in the map
    auto animals() 
    {
        return map_values_iterator_t{ m_map };
    }

    auto animals(bool (*sort_fn)(const animal_t* lhs, const animal_t* rhs))
    {
        // if your collection of animals is likely to change
        // then returning a sorted copy is probably safer
        // (remove the pointer)
        // I'd rather have used references, but they can't be sorted
        std::vector<const animal_t*> sorted_animals;

        for (const auto& animal : animals())
        {
            sorted_animals.push_back(&animal);
        }

        std::sort(sorted_animals.begin(), sorted_animals.end(), sort_fn);
        return sorted_animals;
    }

private:
    std::map<int, animal_t> m_map{ {1,{"bear",9}}, {3,{"cat",2}}, {5,{"dog",4}} };
};

//-------------------------------------------------------------------------------------------------

int main()
{
    world_t world;

    for (const auto& animal : world.animals(animal_t::order_by_vigor))
    {
        std::cout << "animal '" << animal->name << "' has vigor '" << animal->vigor << "'" << std::endl;
    }
}