c++ - boost:: opcional<T &> vs T*

boost-optional

Question

Estoy tratando de entender cuándo es el momento adecuado para usar algunas de las estructuras que vienen con boost y tuve una pregunta sobre el uso de boost::optional con una referencia.

Supongamos que tengo la siguiente clase, usando boost::optional :

class MyClass {
public:
   MyClass() {}

   initialise(Helper& helper) {
      this->helper = helper;
   }

   boost::optional<Helper&> getHelper() {
      return helper;
   }

private:
   boost::optional<Helper&> helper;
}

¿Por qué usaría lo anterior en lugar de:

class MyClass {
public:
   MyClass() : helper(nullptr) {}

   initialise(Helper& helper) {
      this->helper = &helper;
   }

   Helper* getHelper() {
      return helper;
   }

private:
   Helper* helper;
}

Ambos transmiten la misma intención, es decir, que getHelper podría devolver un null , y la persona que llama todavía necesita probar si se devolvió un ayudante.

¿Debería usar solo boost::optional si necesita saber la diferencia entre ''un valor'', nullptr y ''no un valor''?

Answer 1

En comparación con un puntero en bruto, una referencia opcional puede sugerir que (1) la aritmética del puntero no se usa, y (2) la propiedad del referente se mantiene en otro lugar (por lo que delete no se usará claramente con la variable).

Answer 2

Gran pregunta, y la respuesta de John Zwinck arriba es correcta. Sin embargo, algunas personas (p. Ej., Muchas en el comité de estandarización) dudan si estas razones son suficientes para justificar la existencia de optional<T&> optional<T&> , cuando optional<T&> puede tener una semántica tan confusa. Considera lo que debería pasar cuando asignas a uno de estos tipos. ¿Debería volver a colocar la referencia (es decir, hacer que apunte a un objeto diferente), o asignar a través de la referencia, como una T& real T& hace? Se puede hacer un caso para cualquiera de los dos, lo que causaría confusión y errores sutiles. El soporte para optional<T&> se eliminó de la proposal que recientemente se aceptó en C ++ 14.

En resumen, si desea que su código sea portátil a std::optional C ++ 14, prefiera T* sobre boost::optional<T&> .