¿Es bueno usar boost :: tuple <bool, T> para indicar si se encontró T o no?

Question

Supongamos que necesitamos una función que devuelva algo. Pero ese algo no se puede encontrar. Veo opciones:

1. T find(bool &ok); //return default T value if not found 

Podemos hacer una estructura:

template <typename T> 
class CheckableValue 
{ 
public: 
    CheckableValue(), 
    _hasValue(false) 
    { 

    } 
    CheckableValue(const T &t): 
    _value(t), 
    _hasValue(true) 
    { 

    } 

    inline bool hasValue() const {return _hasValue} 
    const T &value() const 
    { 
     assert(hasValue()); 
     return _value; 
    } 

private: 
    T _value; 
    bool _hasValue; 
}; 

y hacer la función:

2. CheckableValue<T> find(); 

O podemos utilizar:

3.boost::tuple<bool, T> find() 

Qué hacer crees que es preferible?

Answer 1

Prefiero:

4. boost::optional<T> find(); 

El problema con la tupla es que la parte T no es válida cuando la parte bool es falso; este comportamiento no se aplica por la tupla. Su clase CheckableValue es el mismo remedio que boost::optional por el mismo problema.

Answer 2

devuelve algo. Pero ese algo no se puede encontrar.

¿Estás planeando devolver una copia, o algún tipo de referencia para la cosa? "no encontrado" implica que la función funciona al "encontrar" un valor preexistente en una estructura de datos en alguna parte.

En ese caso, la solución simple es devolver un puntero al valor existente, usando NULL para no encontrado.