Possible way to achieve lazy loading with const objects

[Peter Alexander]

On 24/09/11 12:47 PM, Jonathan M Davis wrote:
> On Saturday, September 24, 2011 12:19:33 Peter Alexander wrote:
>> Lazy loading and caching are the same thing.
>
> No. Caching is more general. Lazy loading is explicitly one load and has
> different characteristics, whereas is caching can have multiple loads.

Yes, you are right. Sorry.

> The problem with this is that with a single load, you can guarantee constness,
> but once you have multiple, you can't. Unless you can find a mechism which
> _guarantees_ logical constness while changing the variable multiple times,
> then you can't guarantee constness, and it doesn't work. Also, whatever the
> mechanism is, it _has_ to work in the face of immutable, which may or may not
> be harder with a more general caching mechanism.
>
> This particular solution jsn't even _trying_ to solve the caching problem. I
> seriously question that that's at all solvable without breaking const. The
> whole reason that this could work is because it does the load only once, which
> therefore guarantees that the value never changes and therefore never breaks
> const. This is only attempting to solve the lazy-loading issue, not the
> general caching issue.
>
> If you can come up with a way to do general caching without breaking const,
> then that's great. But all I've been able to come up with is a potential means
> of doing lazy loading.
>
> But really, my real question here is whether this scheme is really feasible or
> whether I've missed something. If it's feasible, then _maybe_ it's possible to
> build on it somehow to come up with a general caching mechanism (though I
> doubt it), but if it's _not_, then obviously this sort of approach isn't going
> to be able to do a single lazy load, let alone be expanded somehow to make
> general caching possible.
>
> - Jonathan M Davis

I think your approach to lazy loading works.

However, I'm not sure I see the point of just allowing one kind of 
enforced logical const. Logical const can't be enforced in general, and 
I think in this case a partial attempt is as good as no attempt.