Каков предпочтительный способ хранения одного или любого объекта в C++?

Question

В духе «выбрать контейнеры с умом», я заинтересован в том, что это лучший способ, чтобы сохранить либо ровно одинилине объекта, например, в качестве члена в классе. Это может иметь место, например, если удерживаемый объект дорог для вычисления и должен каким-то образом кэшироваться (или любого другого типа «позднего» создания).

Очевидными кандидатами являются std::vector и std::unique_ptr, например:

class object_t; 
class foo_t { 
    std::unique_ptr<object_t> m_cache; 
    public: 
    object_t getObject() { 
     if(not m_cache) { 
     m_cache.reset(new object_t()); // object creation is expensive 
     } 
     return object_t(*m_cache); 
    } 
}; 

и точно так же с вектором (или почти любой другой контейнер):

class object_t; 
class foo_t { 
    std::vector<object_t> m_cache; 
    public: 
    object_t getObject() { 
     if(m_cache.empty()) { 
     m_cache.push_back(object_t()); // object creation is expensive 
     } 
     return m_cache.front(); 
    } 
}; 

Конечно, есть еще возможность имеют некоторую логическую переменную, которая сохраняет состояние объекта:

class object_t; 
class foo_t { 
    bool cache_healthy; 
    object_t m_cache; 
    public: 
    foo_t() : cache_healthy(false), m_cache() {} 
    object_t getObject() { 
     if(not cache_healthy) { 
     m_cache = object_t(); 
     cache_healthy = true; 
     } 
     return m_cache; 
    } 
    /* do other things that might set cache_healthy to false. */ 
}; 

Из трех примеров, мне нравится последний, тем меньше, потому что он либо создает объект дважды, либо, если я изменяю object_t на «дешевый»/неполный конструктор, может вернуть недопустимый объект.

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

Теперь, думая об этом снова, я думаю, что мне больше всего нравится решение указателя, но я не совсем этому доволен и хотел бы услышать, если вы знаете какое-либо решение, которое является самым элегантным в этом случае.

Answer 1

«Очевидное» решение использует boost::optional или (в C++ 17) std::optional.

Реализации нечто подобное может выглядеть следующим образом:

template <typename T> 
class optional 
{ 
public: 
    optional() : m_isset(false) {} 

    template <typename ...Args> 
    optional(Args... args) { 
     m_isset = true; 
     new (&m_data[0]) optional { args... }; 
    } 

    // overload operator-> and operator* by reinterpret_casting m_data, throwing exceptions if isset == false 

private: 
    bool m_isset; 
    char m_data[sizeof(T)]; 
} 

К недостаткам ваших решений являются ненужным выделением кучи в 1 и 2, и полагаться на копию в 3.