Удаление объекта с помощью std :: weak_ptr

Это может быть случай, когда std::set это правильный выбор std::vector, std::set гарантирует поиск, вставку и удаление в логарифмическом времени. Таким образом, вы можете искать объект по индексу в одном из ваших объектов карт, а затем удалять его в любом контейнере с log(N) спектакль.

Я бы предложил этот подход, если операции вставки / удаления представляют собой узкое место в производительности вашего приложения.

Кстати, внимательно рассмотрите фактическую необходимость shared_ptr, так как shared_ptr приходит с определенными накладными расходами производительности в отличие от unique_ptr например. Ваш владелец контейнер может использовать unique_ptr и различные карты могут просто использовать сырые указатели.

Итак, вот еще один вариант, основанный на импорте объектов путем перемещения std::unique_ptr<>, К несчастью, unique_ptrs не являются полезными ключами для std::set (поскольку они уникальны), если у вас нет C ++ 14, когда set::find() может принимать другой аргумент, чем ключ (см. ниже).

Для C ++ 11 подход, поэтому необходимо использовать std::map хранить unique_ptrс, что требует удвоения id а также name записи: один раз в data_t и однажды в качестве ключей в maps. Вот эскиз.

struct data_t {
const std::size_t id;       // changing these would
const std::string name;     // lead to confusion
/* more data */
};
using data_ptr = std::unique_ptr<data_t>;
using data_map = std::map<std::size_t,data_ptr>;
using obj_it   = data_map::iterator;
using name_map = std::multimap<std::string,obj_it>;
data_map DataSet;
name_map NameMap;

std::vector<data_t*> find_by_name(std::string const&name) const
{
auto range = NameMap.equal_range(name);
std::vector<data_t*> result;
result.reserve(std::distance(range.first,range.second));
for(auto it=range.first; it!=range.second; ++it)
result.push_back(it->second->get());
return result;
}

data_t* find_by_id(std::size_t id) const
{
auto it = DataSet.find(id);
return it == DataSet.end()? nullptr : it->second.get();
}

// transfer ownership here
void insert_object(data_ptr&&ptr)
{
const auto id = ptr->id;
if(DataSet.count(id))
throw std::runtime_error("id '"+std::to_string(id)+"' already known");
auto itb = DataSet.emplace(id,std::move(ptr));
auto err = itb.second;
if(!err)
err = NameMap.emplace(itb.first->name,itb.first).second;
if(err)
throw std::runtime_error("couldn't insert id  "+std::to_string(id));
}

// remove object given an observing pointer; invalidates ptr
void delete_object(data_t*ptr)
{
if(ptr==nullptr)
return;                 // issue warning or throw ?
auto it = DataSet.find(ptr->id);
if(it==DataSet.end())
throw std::runtime_error("attempt to delete an unknown object");
auto range = NameMap.equal_range(it->second->name);
for(auto i=range.first; i!=range.second; ++i)
if(i->second==it) {
NameMap.erase(i);
break;
}
DataSet.erase(it);
}

Вот эскиз для C ++ 14 решение, которое позволяет избежать дублирования id а также name данные на картах, но требует / предполагает, что data_t::id а также data_t::name неизменны.

struct data_t {
const std::size_t id;       // used as key in set & multiset:
const std::string name;     // must never be changed
/* more data */
};

using data_ptr = std::unique_ptr<data_t>;

struct compare_id {
using is_transparent = std::size_t;
static bool operator(data_ptr const&l, data_ptr const&r)
{ return l->id < r->id; }
static bool operator(data_ptr const&l, std::size_t r)
{ return l->id < r; }
static bool operator(std::size_t l, data_ptr const&r)
{ return l < r->id; }
};

using data_set = std::set<data_ptr,compare_id>;
using data_it  = data_set::const_iterator;

struct compare_name {
using is_transparent = std::string;
static bool operator(data_it l, data_it r)
{ return (*l)->name < (*r)->name; }
static bool operator(data_it l, std::string const&r)
{ return (*l)->name < r; }
static bool operator(std::string const&l, data_it r)
{ return l < (*r)->name; }
};

using name_set = std::multiset<data_it,compare_name>;

data_set DataSet;
name_set NameSet;

std::vector<data_t*> find_by_name(std::string const&name) const
{
auto range = NameSet.equal_range(name);
std::vector<data_t*> result;
result.reserve(std::distance(range.first,range.second));
for(auto it=range.first; it!=range.second; ++it)
result.push_back((*it)->get());
return result;
}

data_t* find_by_id(std::size_t id) const
{
auto it = DataSet.find(id);
return it == DataSet.end()? nullptr : it->get();
}

// transfer ownership here
void insert_object(data_ptr&&ptr)
{
const auto id = ptr->id;
if(DataSet.count(id))
throw std::runtime_error("id '"+std::to_string(id)+"' already known");
auto itb = DataSet.emplace(std::move(ptr));
auto err = itb.second;
if(!err)
err = NameSet.emplace(itb.first).second;
if(err)
throw std::runtime_error("couldn't insert id  "+std::to_string(id));
}

// remove object given an observing pointer; invalidates ptr
void delete_object(data_t*ptr)
{
if(ptr==nullptr)
return;                 // issue warning or throw ?
auto it = DataSet.find(ptr->id);
if(it==DataSet.end())
throw std::runtime_error("attempt to delete an unknown object");
auto range = NameSet.equal_range(ptr->name);
for(auto i=range.first; i!=range.second; ++i)
if((*i)==it) {
NameSet.erase(i);
break;
}
DataSet.erase(it);
}

Здесь могут быть некоторые ошибки, в частности ошибки с разыменованием различных типов итераторов и указателей (хотя после компиляции все должно быть в порядке).