缓式评估（lazy evaluation）

考虑使用缓式评估（lazy evaluation）

• 缓式评估是一种编程技巧，它可以延迟计算的执行，直到结果真正需要的时候。这样可以提高程序的效率和响应性，避免不必要的开销。
• 缓式评估的实现方法有多种，例如使用代理类（proxy class）、函数对象（functor）、惰性列表（lazy list）等。这些方法都需要在类的设计上做一些改动，以支持缓式评估的逻辑。
• 缓式评估的优点是可以节省时间和空间，提高用户体验，实现更高级的功能，例如无限序列、惰性求值等。缓式评估的缺点是可能增加代码的复杂度，引入额外的开销，造成一些副作用，例如异常处理、多线程同步等。
• 缓式评估并不是万能的，它需要根据具体的场景和需求来选择合适的方法和时机。一般来说，当计算的代价很高，而结果的使用频率很低时，缓式评估是有利的。反之，当计算的代价很低，而结果的使用频率很高时，缓式评估是不利的。
• 缓式评估是一种有用的工具，但也需要谨慎使用。在使用缓式评估时，要注意保持类的接口和语义的一致性，避免给用户带来意外的行为和结果。

假设您有一个类，表示一个复数，如下：

class Complex {
public:
    Complex(double real, double imag); // 构造函数，接受实部和虚部
    double real() const; // 返回实部
    double imag() const; // 返回虚部
    Complex operator+(const Complex& rhs) const; // 重载加法运算符
    Complex operator*(const Complex& rhs) const; // 重载乘法运算符
    // 其他成员函数和运算符
private:
    double real_; // 实部
    double imag_; // 虚部
};

如果您想要计算两个复数的和和积，您可能会这样写：

Complex c1(1.0, 2.0); // 复数 1 + 2i
Complex c2(3.0, 4.0); // 复数 3 + 4i
Complex sum = c1 + c2; // 复数 4 + 6i
Complex product = c1 * c2; // 复数 -5 + 10i

这样做的问题是，您可能并不需要同时使用 sum 和 product 的值，而是只需要其中的一部分，比如 sum 的实部或者 product 的虚部。但是在计算 sum 和 product 的时候，您已经付出了完整的计算成本，包括分配内存，调用构造函数，执行加法或乘法运算等。

为了避免这种浪费，您可以使用缓式评估的方法，让 sum 和 product 只在需要的时候才计算。这可以通过使用一个代理类（proxy class）来实现，如下：

class ComplexProxy {
public:
    ComplexProxy(const Complex& lhs, const Complex& rhs, char op); // 构造函数，接受两个复数和一个运算符
    double real() const; // 返回实部，根据运算符执行相应的计算
    double imag() const; // 返回虚部，根据运算符执行相应的计算
    operator Complex() const; // 转换为 Complex 类型，执行完整的计算
private:
    const Complex& lhs_; // 左操作数
    const Complex& rhs_; // 右操作数
    char op_; // 运算符，可以是 '+' 或 '*'
};

这个代理类的作用是，当您调用 Complex 类的加法或乘法运算符时，返回一个 ComplexProxy 对象，而不是一个 Complex 对象。这个 ComplexProxy 对象只保存了两个操作数和一个运算符，而没有执行任何计算。只有当您调用它的 real() 或 imag() 函数时，它才会根据运算符执行相应的计算，并返回结果。如果您需要将它转换为 Complex 类型，它会执行完整的计算，并返回一个 Complex 对象。

为了让这个代理类工作，您需要修改 Complex 类的加法和乘法运算符的返回类型，如下：

class Complex {
public:
    // 其他成员函数和运算符
    ComplexProxy operator+(const Complex& rhs) const; // 重载加法运算符，返回 ComplexProxy 类型
    ComplexProxy operator*(const Complex& rhs) const; // 重载乘法运算符，返回 ComplexProxy 类型
};

这样，您就可以使用缓式评估的方式来计算两个复数的和和积，如下：

Complex c1(1.0, 2.0); // 复数 1 + 2i
Complex c2(3.0, 4.0); // 复数 3 + 4i
ComplexProxy sum = c1 + c2; // 并没有执行加法运算，只是返回一个代理对象
ComplexProxy product = c1 * c2; // 并没有执行乘法运算，只是返回一个代理对象
double sum_real = sum.real(); // 此时才执行加法运算，并返回实部 4
double product_imag = product.imag(); // 此时才执行乘法运算，并返回虚部 10
Complex sum_complex = sum; // 此时才执行完整的加法运算，并返回一个复数对象 4 + 6i
Complex product_complex = product; // 此时才执行完整的乘法运算，并返回一个复数对象 -5 + 10i

这样做的好处是，您可以节省时间和空间，只在需要的时候才执行计算，而不是一开始就执行。当然，这也带来了一些额外的开销，比如维护代理类，重载运算符，处理类型转换等。所以，您需要根据具体的场景和需求来选择是否使用缓式评估。