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

#include <iostream>
#include <vector>

// 基础向量类
template<typename T>
class Vector {
    std::vector<T> 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<typename Expr>
    Vector& operator=(const Expr& expr) {
        for (size_t i = 0; i < size(); ++i) {
            data[i] = expr[i];
        }
        return *this;
    }
};

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

// 加法表达式
template<typename LHS, typename RHS>
class AddExpr : public Expression<double, AddExpr<LHS, RHS>> {
    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<typename T>
class Vector : public Expression<T, Vector<T>> {
    std::vector<T> 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<typename Expr>
    Vector& operator=(const Expr& expr) {
        for (size_t i = 0; i < size(); ++i) {
            data[i] = expr[i];
        }
        return *this;
    }
};

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

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