More Effective C++ 条款22：考虑以操作符复合形式(op=)取代其独身形式(op)

最新推荐文章于 2026-06-30 09:06:16 发布
原创 最新推荐文章于 2026-06-30 09:06:16 发布 · 503 阅读 · 10 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
C++

当前文章被收录于：

C++
140 篇文章 8 人学习

666

订阅专栏 查看详情

More Effective C++ 条款22：考虑以操作符复合形式(op=)取代其独身形式(op)

核心思想：通过优先实现复合赋值操作符（如+=、-=等）并基于它们实现单独的操作符（如+、-等），可以提高代码效率、减少冗余，并确保操作符行为的一致性。

🚀 1. 问题本质分析

1.1 操作符实现的常见问题：

  • 代码冗余：单独操作符和复合操作符通常有相似实现，但常被独立实现
  • 效率损失：单独操作符可能产生不必要的临时对象
  • 一致性风险：独立实现可能导致行为不一致

1.2 效率对比分析：

// 传统实现方式（低效）
class Vector {
public:
    Vector operator+(const Vector& other) const {
        Vector result(*this);      // 创建临时对象
        result.x += other.x;       // 执行加法
        result.y += other.y;
        result.z += other.z;
        return result;             // 返回临时对象
    }
    
    Vector& operator+=(const Vector& other) {
        x += other.x;              // 直接修改当前对象
        y += other.y;
        z += other.z;
        return *this;
    }
};

// 优化实现方式（高效）
class OptimizedVector {
public:
    OptimizedVector& operator+=(const OptimizedVector& other) {
        x += other.x;
        y += other.y;
        z += other.z;
        return *this;
    }
    
    // 基于+=实现+
    friend OptimizedVector operator+(OptimizedVector lhs, const OptimizedVector& rhs) {
        lhs += rhs;  // 利用传值方式获得副本，直接修改后返回
        return lhs;
    }
};
📦 2. 问题深度解析

2.1 效率优势分析：

// 传统实现的调用过程
Vector v1, v2, v3;
Vector result = v1 + v2 + v3; 
// 可能产生多个临时对象：
// 1. temp1 = v1 + v2
// 2. temp2 = temp1 + v3
// 3. 析构temp1
// 4. result = temp2
// 5. 析构temp2

// 基于op=实现的调用过程
OptimizedVector v1, v2, v3;
OptimizedVector result = v1 + v2 + v3;
// 可能优化为：
// 1. result = v1 (拷贝构造)
// 2. result += v2
// 3. result += v3
// 减少临时对象创建

2.2 返回值优化机会：

// 基于op=的实现可以利用返回值优化
OptimizedVector operator+(OptimizedVector lhs, const OptimizedVector& rhs) {
    lhs += rhs;
    return lhs;  // 具名返回值优化(NRVO)可能适用
}

// 传统实现难以优化
Vector operator+(const Vector& lhs, const Vector& rhs) {
    Vector result(lhs);  // 必须创建具名对象
    result += rhs;
    return result;       // 可能适用NRVO，但仍有额外拷贝
}

2.3 异常安全保证：

// 基于op=的实现提供强异常安全保证
ResourceHandle operator+(ResourceHandle lhs, const ResourceHandle& rhs) {
    lhs += rhs;  // 如果+=抛出异常，lhs保持原状
    return lhs;  // 返回值优化确保无额外操作
}

// 传统实现可能面临异常安全问题
ResourceHandle operator+(const ResourceHandle& lhs, const ResourceHandle& rhs) {
    ResourceHandle result(lhs);  // 可能抛出异常
    result += rhs;               // 可能抛出异常
    return result;               // 可能抛出异常
}
⚖️ 3. 解决方案与最佳实践

3.1 标准实现模式：

class Efficient {
public:
    // 首先实现复合赋值操作符
    Efficient& operator+=(const Efficient& other) {
        // 实现复合加法
        value += other.value;
        return *this;
    }
    
    Efficient& operator-=(const Efficient& other) {
        // 实现复合减法
        value -= other.value;
        return *this;
    }
    
    // 基于复合操作符实现单独操作符
    friend Efficient operator+(Efficient lhs, const Efficient& rhs) {
        lhs += rhs;  // 利用传值获得副本，直接修改
        return lhs;
    }
    
    friend Efficient operator-(Efficient lhs, const Efficient& rhs) {
        lhs -= rhs;
        return lhs;
    }
    
private:
    int value;
};

3.2 支持多种类型组合：

class Flexible {
public:
    Flexible& operator+=(int value) {
        this->value += value;
        return *this;
    }
    
    // 支持多种参数类型的操作符
    friend Flexible operator+(Flexible lhs, int rhs) {
        lhs += rhs;
        return lhs;
    }
    
    friend Flexible operator+(int lhs, Flexible rhs) {
        rhs += lhs;  // 加法交换律
        return rhs;
    }
    
    friend Flexible operator+(Flexible lhs, const Flexible& rhs) {
        lhs += rhs.value;
        return lhs;
    }
};

3.3 现代C++优化技巧：

// 利用移动语义进一步优化
class Modern {
public:
    Modern(Modern&&) noexcept = default;
    Modern& operator=(Modern&&) noexcept = default;
    
    Modern& operator+=(const Modern& other) {
        value += other.value;
        return *this;
    }
    
    // 支持移动语义的操作符
    friend Modern operator+(Modern lhs, const Modern& rhs) {
        lhs += rhs;
        return lhs;  // 可能使用移动语义返回
    }
    
    // 右值引用重载用于优化
    friend Modern operator+(Modern&& lhs, const Modern& rhs) {
        lhs += rhs;  // 直接修改右值
        return std::move(lhs);  // 移动返回
    }
};

3.4 模板化实现：

// 通用模板实现
template<typename T>
class GenericValue {
public:
    GenericValue& operator+=(const GenericValue& other) {
        value += other.value;
        return *this;
    }
    
    // 模板友元函数
    friend GenericValue operator+(GenericValue lhs, const GenericValue& rhs) {
        lhs += rhs;
        return lhs;
    }
    
    // 支持与标量类型的操作
    friend GenericValue operator+(GenericValue lhs, const T& scalar) {
        lhs.value += scalar;
        return lhs;
    }
    
private:
    T value;
};

3.5 异常安全与资源管理：

class ResourceManager {
public:
    ResourceManager& operator+=(const ResourceManager& other) {
        // 首先分配可能需要的资源
        auto newResource = allocateResource(value + other.value);
        
        // 然后交换，提供强异常安全保证
        std::swap(resource, newResource);
        
        // 最后释放旧资源（不会抛出）
        releaseResource(newResource);
        
        return *this;
    }
    
    // 基于+=的实现自动获得异常安全
    friend ResourceManager operator+(ResourceManager lhs, const ResourceManager& rhs) {
        lhs += rhs;  // 如果抛出异常，lhs保持不变
        return lhs;  // 返回值优化确保安全
    }
};

💡 关键实践原则

  1. 优先实现复合赋值操作符
    遵循"op=优先"原则：

    class BestPractice {
public:
    // 首先实现+=
    BestPractice& operator+=(const BestPractice& other) {
        // 实现核心逻辑
        return *this;
    }
    
    // 然后基于+=实现+
    friend BestPractice operator+(BestPractice lhs, const BestPractice& rhs) {
        return lhs += rhs;
    }
};

  2. 利用传值方式获得左操作数副本
    优化单独操作符的实现：

    // 高效实现：传值获得左操作数副本
friend Value operator+(Value lhs, const Value& rhs) {
    lhs += rhs;  // 直接修改副本
    return lhs;  // 可能应用返回值优化
}

// 传统实现：传const引用
friend Value operator+(const Value& lhs, const Value& rhs) {
    Value result(lhs);  // 需要显式创建副本
    result += rhs;
    return result;      // 可能应用返回值优化
}

  3. 确保操作符行为一致性
    通过单一实现确保一致性：

    class Consistent {
public:
    Consistent& operator+=(const Consistent& other) {
        // 唯一实现核心逻辑的地方
        data = data + other.data;
        return *this;
    }
    
    // +的行为完全由+=定义
    friend Consistent operator+(Consistent lhs, const Consistent& rhs) {
        return lhs += rhs;
    }
    
    // 确保相关操作符的一致性
    friend Consistent operator-(Consistent lhs, const Consistent& rhs) {
        return lhs -= rhs;  // 假设已实现-=
    }
};

性能测试对比：

void benchmarkOperators() {
    const int iterations = 1000000;
    
    // 测试传统实现
    auto start1 = std::chrono::high_resolution_clock::now();
    Traditional a(1), b(2), c(3);
    for (int i = 0; i < iterations; ++i) {
        Traditional result = a + b + c;
    }
    auto end1 = std::chrono::high_resolution_clock::now();
    
    // 测试优化实现
    auto start2 = std::chrono::high_resolution_clock::now();
    Optimized x(1), y(2), z(3);
    for (int i = 0; i < iterations; ++i) {
        Optimized result = x + y + z;
    }
    auto end2 = std::chrono::high_resolution_clock::now();
    
    // 比较性能差异
}

代码审查要点：

  1. 检查是否优先实现了复合赋值操作符
  2. 确认单独操作符是否基于复合操作符实现
  3. 评估操作符实现的异常安全性
  4. 检查是否充分利用了返回值优化机会
  5. 确认相关操作符的行为一致性
  6. 测试性能关键路径的操作符效率

总结：
通过优先实现复合赋值操作符（op=）并基于它们实现单独操作符（op），我们可以获得显著的性能优势、代码简洁性和行为一致性。这种实现方式减少了代码冗余，提高了效率（通过减少临时对象创建），并提供了更好的异常安全保证。

现代C++的特性（如移动语义和返回值优化）进一步增强了这种模式的效率优势。通过传值方式获取左操作数副本，我们可以充分利用编译器的优化能力，同时保持代码的清晰和简洁。

在实际开发中，应该将这一模式作为操作符实现的标准做法，特别是在性能敏感的数值计算、资源管理和自定义类型领域。这不仅能提高代码效率，还能减少错误并提高可维护性。

标签
#c++
[More Effective C++]条款22有关返回值优化的验证结果
_____________________________________simanstar____
10-10 497
转自：http://blog.sina.com.cn/s/blog_5dbb2c470100xapn.html 不知结果是否正确，有待进一步确认 （这里的验证结果是针对返回值优化的，其实和条款22本身所说的，考虑以操作符复合形式（op=）取代其独身形式（op），关系不大。书生注） 在[More Effective C++]条款22的最后，在返回值的返回方式上，大师Meyers推荐使用
More Effective C++ 条款22 考虑以操作符复合形式(op=)取代其独身形式(op)
ddzai7557的博客
09-25 239
1. 一般来说,重载了算数操作符(以下称"独身形式"),那么也就要重载复合赋值操作符(以下称"复合形式").要确保操作符的复合形式例如(operator+=)和独身形式(例如operator+)行为相一致,基于前者实现后者是一个好方法.例如: class Rational{ public: Rational operator+=(const Rational&amp...
More Effective C++ （条款22：考虑以操作符复合形式(op=)取代其独身形式(op)）
Unique-You的博客
03-15 323
1. 一般来说,重载了算数操作符(以下称"独身形式"),那么也就要重载复合赋值操作符(以下称"复合形式").要确保操作符的复合形式例如(operator+=)和独身形式(例如operator+)行为相一致,基于前者实现后者是一个好方法.例如:class Rational{ public: Rational operator+=(const Rational&amp;); ... } ...
《More Effective C++》总结笔记（三）
吴尼玛cs
03-07 293
效率 条款16：谨记80-20法则 80-20法则说：一个程序80%的资源用于20%的代码身上。是的。80%的执行时间花在大约20%的代码身上，80%的内存被大约20%的代码使用，80%的磁盘访问动作由20%的代码执行，80%的维护力气花在20%的代码上面。 不必拘泥于法则的数字，其基本重点是：软件的整体性能几乎总是由其构成要素（代码）的一小部分决定。 从某个角度看，80-20法则暗示，大部分时候你所产出的代码，其性能坦白说是平凡的，因为80%的时间中，其效率不会影响系统整体性能。或许这不至于对你的自尊心
More Effective C++之效率Efficiency_中
chnming1987的博客
12-22 1262
但是观念和实物之间，有一个名为“优化”的黝黯地带，有时候我们可以以某种方式撰写“返回值为一个对象”的函数，使编译器得以将临时对象优化，使它不复存在。“以一组输入数据作为程序或程序库的典型用途”不只是件困难的事，就算有这样的数据，也是没用的，除非我们有一个可信赖的方法足以决定客户的“典型”程度。命名对象、匿名对象、编译器优化等相关讨论度相当有趣，但是我们不要忘了本条款的主题：操作符的“复合版本”（例如，operator+=）比其对应的“独身版本”（例如，operator+）有着更高效率的倾向。
Effective C++ 第三版 所有条款总结及对应代码描述（纯干货）
Warren++的博客
04-29 1109
Effective C++ 第三版 所有条款总结及对应代码描述（纯干货）
More Effective C++之22
李永亮的专栏
06-18 946
条款22：考虑以操作符复合形式（op=）取代其独身形式（op）一般而言，操作符的复合版本比独立的版本效率要高，独立版本一般会返回一个新对象，所以要承担这个新对象带来的构造和析构成本；复合版本一般直接把数据写进左值。我们需要注意的是编译器一般会对不具名的对象进行优化，而对具名对象通常无能为力。所以对同样的实现，template const T operator+(const T& lhs ,
效率：条款22 考虑以操作符复合形式op+= 取代其独身形式op=
self_mind的记事本
02-29 468
在c++程序中，我们已知x=x+y 可以写成x+=y;但是在C++中，operator+,operator=和operator+=之间并没有设立任何互动关系，所以如果你希望这3个操作符都存在并且有着你所期望的互动关系，你就必须自己来实现。同理-,*,/也是一样。 要确保操作符的复合形式和其独身形式之间的自然关系能够存在，一个好方法就是以复合形式为基础来实现独身形式。如： Rational& o
《More Effective C++》读书笔记-效率
爱橙子的OK绷的专栏
04-30 804
条款16-18省略。19、了解临时对象的来源临时对象产生的两种条件：1、为了使函数成功调用而进行隐式类型转换时。 2、函数返回对象时。临时对象是有开销的，因此要尽可能去消除它们，然而更重要的是训练自己寻找可能建立临时对象的地方，在任何时候只要见到常量引用参数，就存在建立临时对象而绑定在参数上的可能性，在任何时候只要见到函数返回对象，就会有一个临时对象被建立（以后被释放）。20、协助完成返回值优化略
More Effective C++：改善编程与设计（下）
Dai_renwen的博客
05-19 1077
有关More effective C++后10条改善编程与设计的有效方法
【C++】万字详解Effective C++
Friday
10-28 4103
本文为前段时间读《Effective C++》（侯捷译）时做的个人笔记。
《More Effective C++：35个改善编程与设计的有效方法》(中文版)
weixin_30649641的博客
07-07 412
《More Effective C++：35个改善编程与设计的有效方法》(中文版)china-pub计算机新书推荐 基本信息原书名： More Effective C++: 35 New Ways to Improve Your Programs and Designs 原出版社： Addison-Wesley Professional 作者： (美)Scott Meyers 译者...
More Effective C++：4、效率
qq_30534935的博客
10-14 248
我怀疑一些人在 C++ 软件开发人员身上进行秘密的巴甫洛夫试验，否则为什么当提到 “效率” 这个词时，许多程序员都会流口水。(Scott Meyers 真幽默译者注) 事实上,效率可不是一个开玩笑的事情。一个太大或太慢的程序它们的优点无论多么引人注目都不会为人们所接受。本来就应该这样。软件是用来帮助我们更好地工作，说运行速度慢才是更好的，说需要 32MB 内存的程序比仅仅需要16MB 内存的程序...
More Effective C++ 学习笔记（4）
qq_20507961的博客
12-29 267
效率 一些漠视的简单规则： 循环可以手动展开 乘法可以用以为运算代替 减少非必要的对象产生和销毁 条款16：谨记8-2法则 一个程序80%的资源用在20%的代码身上，软件整体性能几乎总是由构成要素的一小部分决定 条款17：考虑使用缓释评估 核心点：拖延战术 在你真正需要之前，不必着急为某物做一个副本 应用场景： 引用计数 string s1 = "hello"; string s2 = s1; //复制运算符如果直接做副本拷贝操作则称之为急式评估
More effective C++读书笔记
qq_45487715的博客
04-27 1605
条款13 抛出一个异常和函数调用之间的区别 在抛出异常时，异常对象总是会被复制，无论抛出的是一个指针、对象还是引用。抛出的是指针时，将复制这个指针的内容（仅仅是地址，而不是对象，类似于浅拷贝），注意千万不要抛出局部对象的指针，不然外部捕获的将是一个悬垂的对象；抛出引用时，将以引用的静态类型（而不是动态类型）为蓝本进行复制；抛出一个对象时，还是会复制一个该对象，如果在捕获函数对象的时候，使用值传递的方式，甚至会复制2次。 捕获异常的时候，允许的转换动作要少一些。只允许2种形式：1.异常继承体系中的类转换。2
C++ | 一文整理Effective C++ 55条款内容（全）
weixin_45926547的博客
11-19 5537
前言 文章目录前言1. 视C++为一个语言联邦2. const、enum、inline3.尽可能使用const4. 确定对象初始化】5. 了解C++默默编写并调用那些函数6. 不自动生成的函数，就明确拒绝7. 多态基类声明virtual析构函数8. 别让异常逃离析构函数9. 不在构造析构过程中调用virtual函数10. operator=返回reference to *this11. operator=处理自我赋值12. 赋值对象勿忘其每一个成分13. 以对象管理资源14. 资源管理类中小心coping
More Effective C++笔记（二）
m0_49688739的博客
08-20 294
三、异常 条款9：利用destructor避免泄露资源 把资源封装在对象内，通常可以在exception出现时避免资源泄露 条款10：在构造函数内阻止资源泄露 C++仅仅能删除被完全构造的对象(fully constructed objects)，只有一个对象的构造函数完全运行完毕，这个对象才被完全地构造。C++拒绝为没有完成构造操作的对象调用析构函数。 在构造函数中可以使用try catch throw捕获所有的异常。更好的解决方法是通过智能指针的方式。 如果你用对应的std::unique_
C++ STL之set/multiset详解：从使用到底层，再到面试八股
最新发布
Rick_Theseusr的博客
06-30 296
本文详细介绍了C++ STL中的set和multiset容器的使用方法和底层原理。主要内容包括：容器的初始化、插入操作（insert返回值特性）、删除操作（erase的不同用法）、查找方法（find/count/contains）、边界查询（lower_bound/upper_bound/equal_range）以及遍历方式。特别强调了set自动去重和排序的特性，multiset允许重复元素的区别，以及二者在不同操作上的表现差异。文章还提供了常用函数的时间复杂度参考，适合面试准备和日常开发查阅。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值