无需重载B类operator+，如何实现A += B+B+B操作？

当然有办法！核心思路是绕开直接让B相加，转而利用A已有的operator+=来模拟B的“相加”逻辑，而且完全不需要修改B类的代码。下面是几种可行的方案：

方案1：定义全局的operator+，把B的“相加”转成临时A的累加 #

既然A已经能通过operator+=接受B，那我们可以写一个全局的operator+，让两个B相加返回一个A对象——这个对象就是把两个B依次加到空A上的结果。同理，再补充一个A和B相加的全局运算符，就能支持B+B+B的链式操作：

// 全局运算符，不属于B类成员，完全不修改B
A operator+(const B& lhs, const B& rhs) {
    A temp;
    temp += lhs;
    temp += rhs;
    return temp;
}

// 支持A（由B+B得到）和第三个B继续相加
A operator+(const A& lhs, const B& rhs) {
    A temp = lhs;
    temp += rhs;
    return temp;
}

这样你的原表达式A += B + B + B就能正常编译运行了——本质上是把B+B转成临时A，再和第三个B转成新的临时A，最后用A的operator+=把这个结果加到目标A上。

方案2：用临时A的链式累加替代B+B+B #

如果不想新增全局运算符，也可以直接在表达式里用临时A对象来模拟三次B的累加，写法稍微调整一下，但逻辑完全贴合你的需求：

// 原表达式替换成这样，不需要任何额外重载
A += (A{} += B) += B += B;

这里A{}创建一个默认构造的临时A对象，然后连续三次调用+= B（利用A已有的operator+=），最后把这个累加完的临时A加到目标A上——前提是你的A类有默认构造函数，且operator+=返回的是A&（这也是重载operator+=的标准写法）。

方案3：封装辅助函数，让写法更直观 #

如果觉得上面的链式写法不够清晰，可以封装一个小的辅助函数，专门用来生成“多个B累加后的A对象”：

inline A accumulate_bs(const B& b, int count) {
    A result;
    for (int i = 0; i < count; ++i) {
        result += b;
    }
    return result;
}

然后调用的时候写成：

A += accumulate_bs(B{}, 3); // 如果是同一个B实例，直接传你的B对象即可

这种方式可读性更强，而且同样不需要修改B类的任何代码。

内容的提问来源于stack exchange，提问作者Martin Žid