如何实现一个懒加载成员变量的getter方法并保持const正确性？也就是说，我希望我的getter方法是const的，因为在第一次使用之后，它就是一个普通的getter方法。只有在对象第一次初始化时，const不适用。我想做的是：
class MyClass {
MyClass() : expensive_object_(NULL) {}
QObject* GetExpensiveObject() const {
if (!expensive_object_) {
expensive_object = CreateExpensiveObject();
}
return expensive_object_;
}
private:
QObject *expensive_object_;
};
我能吃掉我的蛋糕而又留着它吗？
这很好，也是通常的做法。
您需要将expensive_object_声明为mutable。
mutable QObject *expensive_object_;
mutable 的基本含义是：“我知道自己在一个 const 对象中，但修改它不会破坏 const 属性。”
如果您经常这样做，我建议将James Curran的答案封装到自己的类中：
template <typename T>
class suspension{
std::tr1::function<T()> initializer;
mutable T value;
mutable bool initialized;
public:
suspension(std::tr1::function<T()> init):
initializer(init),initialized(false){}
operator T const &() const{
return get();
}
T const & get() const{
if (!initialized){
value=initializer();
initialized=true;
}
return value;
}
};
class MyClass {
MyClass() : expensive_object_(CreateExpensiveObject) {}
QObject* GetExpensiveObject() const {
return expensive_object_.get();
}
private:
suspension<QObject *> expensive_object_;
};
MyClass而言是一种实现细节。（好吧，它比这更多，因为MyClass安排成员属于该类型——但我偏离了主题。）如果MyClass关心成员的常量性，则在expensive_object的声明中添加const关键字似乎是正确的方法。 - Dan Breslauexpensive_object_ 可变。在那个特定的地方使用const_cast来避开常量。
QObject* GetExpensiveObject() const {
if (!expensive_object_) {
const_cast<QObject *>(expensive_object_) = CreateExpensiveObject();
}
return expensive_object_;
}
在我看来，这比将expensive_object_变为可变对象更好，因为这样你就不会失去其他所有方法中的const安全性。
您考虑过使用包装类吗？ 您可能可以使用类似智能指针的东西，只提供const版本的 operator * ， operator-> 和可能的 operator [] ... 你可以额外得到类似 scoped_ptr 的行为。
我们来试试这个方法，我相信人们可以指出一些缺陷：
template <typename T>
class deferred_create_ptr : boost::noncopyable {
private:
mutable T * m_pThing;
inline void createThingIfNeeded() const { if ( !m_pThing ) m_pThing = new T; }
public:
inline deferred_create_ptr() : m_pThing( NULL ) {}
inline ~deferred_create_ptr() { delete m_pThing; }
inline T * get() const { createThingIfNeeded(); return m_pThing; }
inline T & operator*() const { return *get(); }
inline T * operator->() const { return get(); }
// is this a good idea? unintended conversions?
inline T * operator T *() const { return get(); }
};
使用type_traits可能会使这个更好...
你需要为数组指针编写不同的版本，并且如果你想传递参数给T的构造函数，你可能需要玩弄一下创建者函数或工厂对象之类的东西。
但是你可以像这样使用它：
class MyClass {
public:
// don't need a constructor anymore, it comes up NULL automatically
QObject * getExpensiveObject() const { return expensive_object_; }
protected:
deferred_create_ptr<QObject> expensive_object_;
};
现在是时候去编译这个程序并且看看它是否能够被破解了... =)
我在这个主题上稍微玩了一下，并提出了一个备选方案，以防您使用C++11。请考虑以下内容：
class MyClass
{
public:
MyClass() :
expensiveObjectLazyAccess()
{
// Set initial behavior to initialize the expensive object when called.
expensiveObjectLazyAccess = [this]()
{
// Consider wrapping result in a shared_ptr if this is the owner of the expensive object.
auto result = std::shared_ptr<ExpensiveType>(CreateExpensiveObject());
// Maintain a local copy of the captured variable.
auto self = this;
// overwrite itself to a function which just returns the already initialized expensive object
// Note that all the captures of the lambda will be invalidated after this point, accessing them
// would result in undefined behavior. If the captured variables are needed after this they can be
// copied to local variable beforehand (i.e. self).
expensiveObjectLazyAccess = [result]() { return result.get(); };
// Initialization is done, call self again. I'm calling self->GetExpensiveObject() just to
// illustrate that it's safe to call method on local copy of this. Using this->GetExpensiveObject()
// would be undefined behavior since the reassignment above destroys the lambda captured
// variables. Alternatively I could just use:
// return result.get();
return self->GetExpensiveObject();
};
}
ExpensiveType* GetExpensiveObject() const
{
// Forward call to member function
return expensiveObjectLazyAccess();
}
private:
// hold a function returning the value instead of the value itself
std::function<ExpensiveType*()> expensiveObjectLazyAccess;
};
主要思想是将返回昂贵对象的函数作为成员变量而不是对象本身。在构造函数中使用以下函数进行初始化：
我喜欢这种方法的原因是即使只有在第一次查询昂贵对象时才会执行初始化代码，但初始化代码仍然写在构造函数中（如果不需要懒加载，我自然会把它放在那里）。
这种方法的缺点是std::function在执行过程中会重新分配自己。在重新分配后访问任何非静态成员（在使用lambda时捕获）将导致未定义的行为，因此需要额外注意。此外，这种方法有点像黑客技术，因为GetExpensiveObject()是const，但它仍然在第一次调用时修改了成员属性。
在生产代码中，我可能更喜欢像James Curran所描述的那样将成员变量设置为mutable。这样，您类的公共API清楚地说明该成员不被视为对象状态的一部分，因此不会影响constness。
经过更深入的思考，我发现可以使用带有std::launch::deferred参数的std::async与std::shared_future相结合，以便能够多次检索结果。以下是代码：class MyClass
{
public:
MyClass() :
deferredObj()
{
deferredObj = std::async(std::launch::deferred, []()
{
return std::shared_ptr<ExpensiveType>(CreateExpensiveObject());
});
}
const ExpensiveType* GetExpensiveObject() const
{
return deferredObj.get().get();
}
private:
std::shared_future<std::shared_ptr<ExpensiveType>> deferredObj;
};
Lazy<T>的类模板，具有以下功能：
以下是如何使用它：
// Constructor takes function
Lazy<Expensive> lazy([] { return Expensive(42); });
// Multiple ways to access value
Expensive& a = *lazy;
Expensive& b = lazy.value();
auto c = lazy->member;
// Check if initialized
if (lazy) { /* ... */ }
这是实现代码。
#pragma once
#include <memory>
#include <mutex>
// Class template for lazy initialization.
// Copies use reference semantics.
template<typename T>
class Lazy {
// Shared state between copies
struct State {
std::function<T()> createValue;
std::once_flag initialized;
std::unique_ptr<T> value;
};
public:
using value_type = T;
Lazy() = default;
explicit Lazy(std::function<T()> createValue) {
state->createValue = createValue;
}
explicit operator bool() const {
return static_cast<bool>(state->value);
}
T& value() {
init();
return *state->value;
}
const T& value() const {
init();
return *state->value;
}
T* operator->() {
return &value();
}
const T* operator->() const {
return &value();
}
T& operator*() {
return value();
}
const T& operator*() const {
return value();
}
private:
void init() const {
std::call_once(state->initialized, [&] { state->value = std::make_unique<T>(state->createValue()); });
}
std::shared_ptr<State> state = std::make_shared<State>();
};
你的getter并不是真正的const，因为它确实改变了对象的内容。我认为你想得太多了。
mutable 被发明出来的原因 -- 使您能够声明某些东西为 const，即使您必须修改其内存，即使您知道其接口始终看起来相同。 - Ken Bloom