Muitas vezes me vejo querendo escrever código como este:

class MyClass
{
public:
  void addObject(std::unique_ptr<Object>&& newObject);

  void removeObject(const Object* target);

private:
  std::set<std::unique_ptr<Object>> objects;
};

No entanto, grande parte da interface std :: set é inútil com std :: unique_ptrs, pois as funções de pesquisa requerem parâmetros std :: unique_ptr (que eu obviamente não possuo, porque são de propriedade do próprio conjunto).

Eu posso pensar em duas soluções principais para isso.

Crie um unique_ptr temporário para pesquisa. Por exemplo, o removeObject () acima pode ser implementado como:

void MyClass::removeObject(const Object* target)
{
  std::unique_ptr<Object> targetSmartPtr(target);
  objects.erase(targetSmartPtr);
  targetSmartPtr.release();
}

Substitua o conjunto por um mapa de ponteiros brutos para unique_ptrs.

  // ...
  std::map<const Object*, std::unique_ptr<Object>> objects;
};

No entanto, ambos parecem um pouco estúpidos para mim. Na solução 1, erase () não é uma exceção, portanto, o unique_ptr temporário pode excluir o objeto que realmente não possui e 2 requer o dobro do armazenamento para o contêiner desnecessariamente.

Eu sei sobre os contêineres de ponteiro do Boost, mas seus recursos atuais são limitados em comparação com os modernos contêineres de biblioteca padrão do C ++ 11.

Eu estava lendo recentemente sobre o C ++ 14 e me deparei com "Adicionando pesquisa de comparação heterogênea a contêineres associativos". Mas para formar minha compreensão, os tipos de pesquisa devem ser comparáveis ​​aos tipos de chave, mas os ponteiros não são comparáveis ​​a unique_ptrs.

Alguém sabe de uma solução mais elegante ou uma adição futura ao C ++ que resolve este problema?