如何在不可变的 c++ 对象中实现延迟初始化和缓存？

Question

不久前我已经了解了“优雅对象”原则（参见优雅对象.org），它们很容易在 C# 中遵循，但现在我正在做一些 c++，不变性给我带来了一些麻烦。我正在寻找有关如何以不可变的方式实现延迟初始化和缓存的最佳实践。

惰性初始化和缓存的结合意味着一些数据必须在对象构造后存储在对象内部，这需要一些可变的行为。 在 C# 中，如果类的所有字段都声明为“只读”，则您的对象是不可变的。幸运的是，这是一种浅层不变性，因此您的不可变对象可以将可变对象封装为只读字段并对其进行操作以实现可变行为，请参见下面的 C# 示例。

最接近 C# 在 C++ 中的“只读”的做法是将字段声明为“常量”。但是，在 C++ 中，如果将其他可变对象存储在 const 字段中，则不能像在 C# 中那样直接操作它。尝试在 C++ 中重新创建我的 C# 示例会导致编译时错误，请参见下面的第二个示例。

有一个解决方法：将每个数组转换为 void 指针并返回到我需要的类型的指针（例如 int 或 bool），然后将该指针视为数组，这样我就可以绕过原始数组的 const 限定.虽然这很丑陋，但它似乎是一些肮脏的 hack，并且使代码的可读性低于我刚刚删除 const 限定符时的可读性。

我真的很想要那些 const 限定符，它们是向人们保证该类确实是不可变的一种正式方式，而无需阅读整个类的代码。

我想要实现的 C# 示例：

using System;

public sealed class Program
{
    public static void Main()
    {
        var test = 
            new CachedInt(
                ()=>5 // this lambda might aswell be a more expensive calculation, which would justify lazy initialization and caching
            );
        Console.WriteLine(test.Value());
    }
}

public sealed class CachedInt
{
    //note that these are all readonly, this is an immutable class
    private readonly Func<int> source;
    private readonly int[] cache;
    private readonly bool[] hasCached;

    public CachedInt(Func<int> source)
    {
        this.source = source;
        this.cache = new int[1];
        this.hasCached = new bool[1]{false};
    }

    public int Value()
    {
        if(!this.hasCached[0])
        {
            // manipulating mutable objects stored as readonly fields:
            this.cache[0] = this.source.Invoke();
            this.hasCached[0] = true;
        }
        return this.cache[0];
    }
}

导致编译时错误的 C++ 示例：

#include <iostream>
#include <functional>

class CachedInt final
{
private:

    // all const, this is an immutable class
    const std::function<int()> source;
    const int cache[1];
    const bool hasCached[1];

public:

    CachedInt(std::function<int()> source) :
        source(source),
        cache{0},
        hasCached{false}
    {}

    int Value()
    {
        if(!this->hasCached[0])
        {
            // the following two lines obviously don't work due to the const qualification
            this->cache[0] = this->source();
            this->hasCached[0] = true;
        }
        return this->cache[0];
    }
};

int main()
{
    CachedInt test([]()->int{return 5;});
    std::cout << test.Value();
}

丑陋的解决方法：

#include <iostream>
#include <functional>

class CachedInt final
{
private:

    // all const, this is an immutable class
    const std::function<int()> source;
    const int cache[1];
    const bool hasCached[1];

public:

    CachedInt(std::function<int()> source) :
        source(source),
        cache{0},
        hasCached{false}
    {}

    int Value()
    {
        if(!this->hasCached[0])
        {
            // this works but it's ugly. there has to be a better way.
            ((int*)(void*)this->cache)[0] = this->source();
            ((bool*)(void*)this->hasCached)[0] = true;
        }
        return this->cache[0];
    }
};

int main()
{
    CachedInt test([]()->int{return 5;});
    std::cout << test.Value();
}

尝试编译第二个示例时抛出的错误：

 In member function 'int CachedInt::Value()':
24:28: error: assignment of read-only location '((CachedInt*)this)->CachedInt::cache[0]'
25:32: error: assignment of read-only location '((CachedInt*)this)->CachedInt::hasCached[0]'

这个错误不是问题，我知道为什么会抛出它，我只是为了完整性而添加它。

总而言之，我希望一个类进行延迟初始化并缓存结果，但我也希望该类是不可变的。在 c++ 中最优雅的方法是什么？

Answer 1

这是一条红鲱鱼：因为缓存是private，所以不管它是否是const：你（类成员函数的设计者）可以完全控制任何改变它的值的尝试.

这是一个 C++ 实现，其中的值由 const 成员访问

template<typename valueType>
struct cachedFunctionValue {
    cachedFunctionValue(std::function<valueType()> &&f)
    : func(f) {}

    valueType get() const       // constant access to function value
    {
        if(!cache.has_value())
            cache = func();     // works because cache is mutable
        return cache.value();
    }
private:
    const std::function<valueType()> func;
    mutable std::optional<valueType> cache;
};