C++怎么实现一个表达式模板_C++元编程技术中避免临时对象以提升性能

Vector a(1000), b(1000), c(1000), d(1000);
a = b + c + d;

#include 
#include 

// 基础向量类
template
class Vector {
    std::vector data;
public:
    explicit Vector(size_t n) : data(n) {}
    size_t size() const { return data.size(); }
    
    T& operator[](size_t i) { return data[i]; }
    const T& operator[](size_t i) const { return data[i]; }

    // 普通赋值
    template
    Vector& operator=(const Expr& expr) {
        for (size_t i = 0; i < size(); ++i) {
            data[i] = expr[i];
        }
        return *this;
    }
};

// 表达式包装基类（可选，用于统一接口）
template
class Expression {
public:
    const Expr& self() const { return static_cast(*this); }
};

// 加法表达式
template
class AddExpr : public Expression> {
    const LHS& lhs;
    const RHS& rhs;
public:
    AddExpr(const LHS& l, const RHS& r) : lhs(l), rhs(r) {}

    double operator[](size_t i) const { return lhs[i] + rhs[i]; }
    size_t size() const { return lhs.size(); }
};

// 让 Vector 继承自 Expression，以便参与表达式
template
class Vector : public Expression> {
    std::vector data;
public:
    explicit Vector(size_t n) : data(n) {}
    size_t size() const { return data.size(); }
    
    T& operator[](size_t i) { return data[i]; }
    const T& operator[](size_t i) const { return data[i]; }

    template
    Vector& operator=(const Expr& expr) {
        for (size_t i = 0; i < size(); ++i) {
            data[i] = expr[i];
        }
        return *this;
    }
};

// 重载加法，返回表达式对象而非 Vector
template
AddExpr operator+(const Expression& lhs,
                             const Expression& rhs) {
    return AddExpr(lhs.self(), rhs.self());
}

Vector a(1000), b(1000), c(1000), d(1000);
// 初始化 b, c, d ...
a = b + c + d;  // 不产生临时对象，一次循环完成计算