A menudo me encuentro con ganas de escribir 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;
};

Sin embargo, gran parte de la interfaz std :: set es un poco inútil con std :: unique_ptrs ya que las funciones de búsqueda requieren parámetros std :: unique_ptr (que obviamente no tengo porque son propiedad del propio conjunto).

Puedo pensar en dos soluciones principales para esto.

Crear un unique_ptr temporal para la búsqueda. Por ejemplo, el removeObject () anterior podría implementarse como:

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

Reemplace el conjunto con un mapa de punteros en bruto a unique_ptrs.

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

Sin embargo, ambos me parecen un poco estúpidos. En la solución 1, erase () no es una excepción, por lo que unique_ptr temporal puede eliminar el objeto que realmente no posee, y 2 requiere el doble de almacenamiento innecesario para el contenedor.

Sé sobre los contenedores de punteros de Boost, pero sus características actuales son limitadas en comparación con los contenedores de bibliotecas estándar C ++ 11 modernos.

Hace poco estuve leyendo sobre C ++ 14 y encontré "Agregar una búsqueda de comparación heterogénea a contenedores asociativos". Pero como lo entendí, los tipos de búsqueda deben ser comparables a los tipos clave, pero los punteros en bruto no son comparables a unique_ptrs.

¿Alguien sabe de una solución más elegante o una próxima adición a C ++ que resuelva este problema?