1. 为什么运算符重载值得单独开一章来啃如果你正在学C翻到谭浩强那本经典教材的第十章大概率会有两种反应一种是“终于讲到点上了”另一种是“这玩意儿到底有啥用”。我当年属于后者。课本上那些operator、operator的语法看着不难但真到写习题的时候脑子里全是问号——为什么ab能直接作用于自定义对象为什么有的运算符必须写成友元函数有的又必须是成员函数为什么的前置和后置版本长得几乎一样编译器却能分得清运算符重载是C里少数几个“看起来简单、用起来讲究”的特性。它的本质是让自定义类型拥有和内置类型一样的表达力。比如你写了一个复数类你希望c1 c2能像1 2一样自然而不是写成c1.add(c2)。这种表达上的统一在数学计算、矩阵运算、字符串处理、迭代器设计等场景里价值极大。但问题也恰恰出在这里。运算符重载给了你“改写语言规则”的权力而权力越大踩坑的概率越高。我见过太多人把重载成减法、把重载成赋值、把重载得连自己都看不懂。更隐蔽的坑在于有些运算符重载后编译器会自动生成对应的版本导致行为和你预期完全不一致。比如你重载了但没管拷贝构造函数浅拷贝的问题就会在某个深夜让你抓狂。这篇内容就是围绕谭浩强第十章的那些习题展开的。我不会只给你一份“标准答案”而是把每道题背后的设计意图、常见错误、以及我在实际编码中总结出来的改进方案一并讲清楚。适合正在学C、正在做这一章习题、或者虽然学过但一直没搞明白运算符重载到底该怎么用的人。如果你已经能熟练写出一个安全的复数类、一个支持流输出的日期类那这篇内容可以帮你查漏补缺如果你还在为“为什么我的operator编译不过”发愁那正好我们从最根上的东西开始捋。2. 从习题里长出来的核心规则哪些运算符能重载哪些不能谭浩强第十章的开篇就列了一张表告诉你哪些运算符可以重载哪些不行。很多人扫一眼就过去了结果写代码的时候才发现?:不能重载、::不能重载、.不能重载。这些限制不是随便定的背后有很实在的理由。2.1 不能重载的运算符及其原因先看一张我整理的对照表把“能不能重载”和“为什么”放在一起运算符能否重载原因::否作用域解析编译期确定重载会破坏名字查找规则.否成员访问重载后无法保证对象模型的稳定性.*否成员指针访问同上?:否三目运算符重载后短路求值语义难以保证sizeof否编译期求值重载没有意义typeid否类型信息查询属于RTTI机制-*/是算术运算最常见的重载对象是赋值但必须作为成员函数[]是下标访问必须作为成员函数()是函数调用必须作为成员函数-是智能指针的核心是流操作通常重载为友元这张表里最容易被忽略的是、[]、()、-这四个——它们必须作为成员函数重载不能写成友元。为什么因为这几个运算符的语义和对象本身绑定得太紧。比如[]它返回的是对象内部的某个元素的引用如果写成友元你没法保证访问的是“这个对象”的内部数据。再比如赋值操作必须修改当前对象的状态友元函数没有this指针做不到这一点。2.2 成员函数 vs 友元函数选择背后的逻辑习题里经常出现这样的要求“重载运算符使其能够计算两个复数之和”。这时候你有两种写法// 写法一成员函数 class Complex { public: Complex operator(const Complex other) const { return Complex(real other.real, imag other.imag); } private: double real, imag; }; // 写法二友元函数 class Complex { public: friend Complex operator(const Complex a, const Complex b); private: double real, imag; }; Complex operator(const Complex a, const Complex b) { return Complex(a.real b.real, a.imag b.imag); }两种写法都能让c1 c2编译通过。但如果你要支持1.5 c1这种“左操作数是内置类型、右操作数是自定义类型”的表达式成员函数版本就歇菜了。因为成员函数的左操作数必须是当前类的对象1.5不是Complex编译器找不到匹配的operator。而友元函数版本可以因为它的两个参数都是显式声明的编译器可以通过隐式转换把1.5变成Complex(1.5, 0)。所以选择规则可以总结成一句话如果运算符需要支持左操作数为内置类型的情况或者需要访问多个对象的私有成员且不想写一堆getter就用友元否则优先用成员函数。成员函数的好处是封装性更好而且能直接访问this写起来更自然。2.3 习题中关于运算符重载的常见错误我批改过不少人的习题答案发现几个高频错误第一个是返回值类型写错。比如重载有人写成void operator(const Complex other)然后试图在函数里修改当前对象。这完全违背了的语义——a b不应该改变a或b它应该产生一个新的值。正确的返回值应该是Complex值返回而不是引用。返回引用只有在重载这种复合赋值运算符时才合适。第二个是忘记处理自赋值。重载的时候如果写成Complex operator(const Complex other) { real other.real; imag other.imag; return *this; }对于复数类这种没有动态资源的类这样写没问题。但如果类里有指针成员就必须先判断if (this ! other)否则当other就是自己时先释放资源再访问就会出问题。第三个是前置和后置的区分。C规定后置的声明里要加一个int参数作为标记Complex operator(); // 前置 Complex operator(int); // 后置这个int参数没有任何实际作用纯粹是语法上的占位符。很多人第一次看到operator(int)的时候完全懵了不知道这个int是干嘛的。记住后置版本返回的是旧值临时对象前置版本返回的是新值引用这是两者的核心区别。3. 复数类习题的完整拆解与改进方案谭浩强第十章里关于复数类的习题有好几道从最简单的、-重载到后来的、--、流输入输出层层递进。我把它们串起来讲顺便给出我在实际编码中会采用的改进版本。3.1 基础版本只重载加减法课本上的基础要求通常是这样的定义一个复数类重载、-、*、/实现复数的四则运算。先看一个能跑通但不够健壮的版本class Complex { public: Complex(double r 0, double i 0) : real(r), imag(i) {} Complex operator(const Complex other) const { return Complex(real other.real, imag other.imag); } Complex operator-(const Complex other) const { return Complex(real - other.real, imag - other.imag); } Complex operator*(const Complex other) const { return Complex(real * other.real - imag * other.imag, real * other.imag imag * other.real); } Complex operator/(const Complex other) const { double denom other.real * other.real other.imag * other.imag; return Complex((real * other.real imag * other.imag) / denom, (imag * other.real - real * other.imag) / denom); } void display() const { std::cout ( real , imag i) std::endl; } private: double real, imag; };这段代码能通过编译也能算出正确结果。但有几个问题值得注意除法没有处理除数为零的情况。如果other是(0, 0)denom就是0程序会得到inf或nan。在实际项目里这种边界条件必须处理。改进方案是在除法里加一个判断Complex operator/(const Complex other) const { double denom other.real * other.real other.imag * other.imag; if (denom 0) { throw std::invalid_argument(Division by zero complex number); } // ... }构造函数没有用explicit。这意味着Complex c 3.5;这种写法是合法的编译器会把3.5隐式转换成Complex(3.5, 0)。有时候这是你想要的效果比如支持1.5 c但有时候不是。如果你希望只允许显式构造就加上explicit。不过对于复数类来说隐式转换通常是合理的因为数学上实数就是虚部为0的复数。3.2 进阶版本加入、-和自增自减课本后面的习题会要求重载复合赋值运算符和自增自减。这部分是考试和面试的高频考点因为能同时考察你对引用返回、前置后置区分、以及运算符语义的理解。class Complex { public: Complex(double r 0, double i 0) : real(r), imag(i) {} // 复合赋值返回引用支持链式调用 Complex operator(const Complex other) { real other.real; imag other.imag; return *this; } Complex operator-(const Complex other) { real - other.real; imag - other.imag; return *this; } // 前置先加返回新值 Complex operator() { real; return *this; } // 后置先保存旧值再加返回旧值 Complex operator(int) { Complex temp(*this); real; return temp; } // 前置-- Complex operator--() { --real; return *this; } // 后置-- Complex operator--(int) { Complex temp(*this); --real; return temp; } private: double real, imag; };这里有几个细节值得展开说为什么返回引用而返回值因为a b的语义是“修改a然后返回a本身”。返回引用可以避免一次拷贝而且支持(a b) c这种链式写法。而a b的语义是“产生一个新的值”这个新值是一个临时对象返回引用会导致悬空引用所以必须返回值。后置为什么要先拷贝因为后置的语义是“返回加之前的值但对象本身已经加了”。所以你必须先把当前状态存下来然后修改自己最后返回那个存下来的副本。这个副本是值返回不能是引用因为它是一个局部变量函数结束后就销毁了。前置为什么返回引用因为前置返回的是修改后的自己直接返回*this的引用即可不需要拷贝。这也是为什么前置通常比后置效率高——后者多了一次拷贝构造和一次析构。3.3 流运算符重载为什么必须用友元课本里有一道题要求重载和让复数能直接用cout c输出、用cin c输入。这道题的关键在于流运算符必须重载为友元函数不能是成员函数。原因很简单cout c这个表达式里左操作数是ostream对象右操作数是Complex对象。如果写成成员函数它必须是ostream类的成员但你没法修改标准库的ostream类。所以只能写成全局函数再声明为Complex的友元让它能访问私有成员。class Complex { public: Complex(double r 0, double i 0) : real(r), imag(i) {} friend std::ostream operator(std::ostream os, const Complex c); friend std::istream operator(std::istream is, Complex c); private: double real, imag; }; std::ostream operator(std::ostream os, const Complex c) { os ( c.real; if (c.imag 0) os ; os c.imag i); return os; } std::istream operator(std::istream is, Complex c) { // 假设输入格式为real imag is c.real c.imag; return is; }注意operator的第二个参数是const Complex因为输出不应该修改对象。而operator的第二个参数是Complex因为输入需要修改对象。两个函数都返回流的引用这样才能支持cout a b c这种链式输出。我在实际使用中发现一个容易忽略的点输入流的错误处理。如果用户输入的不是数字is会进入失败状态后续的输入都会失效。健壮的做法是在读取后检查流的状态std::istream operator(std::istream is, Complex c) { double r, i; if (is r i) { c.real r; c.imag i; } return is; }这样如果读取失败c保持不变流的状态由调用者决定怎么处理。4. 赋值运算符重载浅拷贝与深拷贝的分水岭谭浩强第十章里关于赋值运算符的习题往往是最容易出错的部分。因为课本前面的例子大多用复数、日期这种没有动态资源的类到了字符串类或者动态数组类浅拷贝的问题就暴露出来了。4.1 一个看似正确的赋值运算符先看一个典型的错误示范。假设我们有一个简单的字符串类class MyString { public: MyString(const char* s ) { len strlen(s); data new char[len 1]; strcpy(data, s); } ~MyString() { delete[] data; } MyString operator(const MyString other) { if (this ! other) { delete[] data; len other.len; data new char[len 1]; strcpy(data, other.data); } return *this; } private: char* data; int len; };这个版本已经比课本上的基础版本好了因为它处理了自赋值。但还有一个隐藏的问题如果new char[len 1]抛出异常比如内存不足data已经被delete[]了对象就处于一个无效状态。更安全的做法是先分配新内存成功后再释放旧内存MyString operator(const MyString other) { if (this ! other) { char* newData new char[other.len 1]; strcpy(newData, other.data); delete[] data; data newData; len other.len; } return *this; }这个版本被称为“异常安全”的赋值运算符。虽然对于课本习题来说可能有点过度设计但在实际项目里这种细节决定了你的代码在极端情况下会不会崩溃。4.2 拷贝构造函数赋值运算符的孪生兄弟很多人只记得重载却忘了拷贝构造函数。结果就是MyString a(hello); MyString b a; // 调用拷贝构造函数不是赋值运算符如果没写拷贝构造函数编译器会生成一个默认的执行浅拷贝。b.data和a.data指向同一块内存析构时就会double free。所以只要类里有指针成员就必须同时提供拷贝构造函数和赋值运算符重载这就是所谓的“三法则”Rule of Three。拷贝构造函数的写法和赋值运算符类似但不需要处理自赋值因为对象还没构造完也不需要释放旧资源MyString(const MyString other) { len other.len; data new char[len 1]; strcpy(data, other.data); }4.3 移动语义C11之后的改进方向如果你用的是C11或更新的标准还可以给字符串类加上移动构造函数和移动赋值运算符。移动语义的核心思想是“窃取”临时对象的资源而不是拷贝一份。对于MyString来说移动版本可以这样写MyString(MyString other) noexcept : data(other.data), len(other.len) { other.data nullptr; other.len 0; } MyString operator(MyString other) noexcept { if (this ! other) { delete[] data; data other.data; len other.len; other.data nullptr; other.len 0; } return *this; }移动版本把other的指针直接拿过来然后把other置空。这样当other析构时delete[] nullptr是安全的不会释放已经被转移的资源。加上移动语义后MyString b std::move(a)或者MyString c a b这种表达式的效率会大幅提升。谭浩强的教材因为出版较早没有涉及移动语义。但如果你在学这一章的时候已经接触了C11我建议把移动版本也写一遍作为对自己的拔高训练。5. 类型转换运算符容易被忽略的第十章考点谭浩强第十章的最后几道习题会涉及类型转换运算符也就是operator Type()这种形式。它的作用是把自定义类型转换成其他类型。比如你希望double d complexObj;能编译通过就需要在Complex类里定义一个operator double()。5.1 基本用法与陷阱class Complex { public: Complex(double r 0, double i 0) : real(r), imag(i) {} operator double() const { return real; // 只返回实部或者返回模长 } private: double real, imag; };有了这个转换运算符double d c;就会调用operator double()把c转换成double。但这里有一个经典的陷阱隐式类型转换可能导致二义性。比如你同时定义了Complex(double)构造函数和operator double()那么c 1.5这个表达式就有两种解释把1.5转成Complex再调用operator或者把c转成double再做加法。编译器不知道选哪个就会报错。解决办法是给构造函数加explicit或者给转换运算符加explicitC11支持。对于复数类来说我通常会把operator double()标记为explicit只允许显式转换explicit operator double() const { return std::sqrt(real * real imag * imag); // 返回模长 }这样double d c;会编译失败但double d static_castdouble(c);可以。虽然麻烦一点但避免了隐式转换带来的意外。5.2 习题中的类型转换场景课本里有一道题要求实现一个分数类支持把分数转换成double。这个场景比复数更自然因为分数和实数之间的转换是数学上的常规操作。实现的时候要注意转换运算符通常应该是const的因为它不修改对象。如果分母为0转换时应该抛出异常或者返回一个特殊值。转换运算符和构造函数同时存在时要小心二义性。class Fraction { public: Fraction(int n 0, int d 1) : num(n), den(d) { if (den 0) throw std::invalid_argument(Denominator cannot be zero); } explicit operator double() const { return static_castdouble(num) / den; } private: int num, den; };注意这里用了static_castdouble(num)而不是直接num / den。因为num和den都是int直接相除会执行整数除法得到的结果再转成double就丢失了小数部分。这是新手常犯的错误我在习题答案里见过不止一次。6. 运算符重载的边界什么时候不该重载写到这里你已经看到了运算符重载的各种用法。但我想专门用一节来讲“什么时候不该重载”因为这是课本上不会强调、但在实际工程中极其重要的判断力。6.1 不要为了炫技而重载我见过有人给一个“学生类”重载表示“两个学生的成绩相加”。这种重载在语法上没问题但在语义上很别扭。的直觉是“合并”或“累加”两个学生相加得到什么一个成绩总和还是一个包含两个学生的新学生这种模糊的语义会让代码的读者困惑。运算符重载的第一原则是重载后的行为必须符合该运算符的直觉语义。应该表示某种形式的“加法”或“合并”应该表示“相等比较”应该表示“输出”。如果你需要停顿三秒才能解释清楚某个重载的含义那大概率不该重载。6.2 不要重载、||和,这三个运算符在C里有特殊的短路求值规则。和||的右操作数可能根本不会被求值而,有严格的从左到右求值顺序。一旦你重载了它们这些规则就失效了因为重载后的版本是函数调用所有参数都会被求值。这会导致极其隐蔽的bug所以除非你有非常特殊的理由否则不要碰这三个。6.3 保持运算符的对称性如果你重载了通常也应该重载!。如果你重载了可能也需要、、。C20之前这些运算符需要一个个手动实现C20之后你可以只定义三路比较运算符编译器会自动生成其他的比较运算符。如果你在学谭浩强这本教材可能还没接触到C20但知道这个方向对以后有帮助。// C20之前需要手动实现所有比较运算符 bool operator(const Complex other) const { return real other.real imag other.imag; } bool operator!(const Complex other) const { return !(*this other); } // C20之后只需要一个 auto operator(const Complex other) const default;7. 我在做这一章习题时踩过的坑最后这部分我想分享几个我在做谭浩强第十章习题时真实踩过的坑。这些坑在课本的答案里通常不会提到但每一个都让我花了至少半小时才爬出来。第一个坑operator返回引用导致程序崩溃。我一开始觉得返回引用效率高就把operator写成了Complex operator(const Complex other)然后在函数里创建了一个局部Complex对象并返回它的引用。结果就是函数结束后局部对象被销毁返回的引用指向一块已经释放的内存。程序在输出的时候输出了乱码调试了半天才发现问题。记住局部对象的引用绝对不能返回。第二个坑后置忘记加int参数。我写了一个Complex operator()以为这就是后置版本。结果编译器把它当成前置版本c和c的行为完全一样。后来查了资料才知道后置版本必须有一个int参数作为标记哪怕你根本不用它。第三个坑流运算符的返回值写成了void。我一开始写void operator(ostream os, const Complex c)然后发现cout a b编译不过。因为cout a返回voidvoid b没有意义。流运算符必须返回流的引用才能支持链式调用。第四个坑赋值运算符没有处理自赋值。这个坑在复数类上不会暴露因为复数类没有动态资源。但当我后来写字符串类的时候s s这种操作直接让程序崩溃了。原因就是先delete[] data然后strcpy(data, other.data)而other就是自己data已经被释放了。第五个坑类型转换运算符和构造函数同时隐式转换导致二义性。这个坑最隐蔽因为代码单独看都没问题只有把两个类放在一起编译的时候才会报错。解决办法就是给其中一个加explicit切断隐式转换的路径。这些坑的共同特点是编译器不会给你明确的错误提示或者提示的位置和真正的问题相隔很远。所以我的建议是在做这一章习题的时候不要只满足于“编译通过”要多问自己几个问题这个返回值类型合理吗自赋值会出问题吗隐式转换会不会导致意外把这些问题想清楚了运算符重载才算真正入门。如果你正在做这一章的习题我建议你把每个运算符重载都当成一个小设计题来对待。先想清楚它的语义是什么再决定用成员函数还是友元返回值是值还是引用要不要处理边界情况。这样练下来你对C对象模型的理解会比单纯做题深得多。