C++基础：Stanford CS106L学习笔记 12 运算符重载

最新推荐文章于 2026-06-24 20:09:52 发布

原创最新推荐文章于 2026-06-24 20:09:52 发布 · 802 阅读

5 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#c++ #学习 #笔记

C++ 专栏收录该内容

16 篇文章

订阅专栏

12.1 运算符重载

运算符重载是 C++ 允许用 “自定义方式” 重定义+、<、==等运算符的机制，让自定义类（如这里的StanfordID，推测是 “斯坦福 ID” 类）能像内置类型（如int）一样用运算符比较 / 计算。

哪些运算符不能被重载？

作用域解析
三元运算
成员访问
指向成员的指针访问
对象大小、类型和强制转换

在这里插入图片描述
.h文件

class StanfordID {
private:
    std::string name;
    std::string sunet;
    int idNumber;
public:
    // constructor for our StanfordID
    StanfordID(std::string name, std::string sunet, int idNumber);
    ... 
    bool operator < (const StanfordID& rhs) const;
}

.cpp文件

#include StanfordID.h
std::string StanfordID::getIdNumber() {
    return idNumber;
}
bool StanfordID::operator<(const StanfirdID& other) const {
    return idNumber < other.getIdNumber();
}

12.2 非成员重载

重载有两种方式：

成员重载
a. 在类的作用域内声明重载运算符
非成员重载
a. 在类定义外部声明重载运算符
b. 将左侧和右侧对象都定义为参数

非成员重载：

这实际上是 STL 所偏好的，并且更符合（C++ 的）习惯用法。

原因如下：

允许左侧为非类类型
允许我们对不属于自己的类重载运算符我们可以定义一个运算符来比较 StanfordID 与你定义的其他自定义类。

在这里插入图片描述

12.3 友元(Freind)

非成员函数的缺点是：默认无法访问类的私有（private）成员（C++ 类的封装性规定，只有类内成员 / 友元能访问私有成员）。

而friend关键字的核心作用就是 “打破封装限制”：

如果在StanfordID类的内部，用friend bool operator<(const StanfordID&, const StanfordID&);声明这个非成员的<重载函数为 “友元”；
那么这个operator<函数就能直接访问StanfordID的私有成员（比如StanfordID可能用私有变量idNum存储 ID 号，重载函数需要比较lhs.idNum和rhs.idNum，没有friend就会编译报错）。

.h文件

class StanfordID {
private:
    std::string name;
    std::string sunet;
    int idNumber;
public:
// constructor for our StudentID
StanfordID(std::string name, std::string sunet, int idNumber);
    .
    .
    . 
    // 声明友元函数
    friend bool operator < (const StanfordID& lhs, const StanfordID& rhs);
}

以下代码可以正常运行：
.cpp文件

#include StanfordID.h
bool operator< (const StanfordID& lhs, const StanfordID& rhs)
{
    return lhs.idNumber < rhs.idNumber;
}

以下代码也可以正常运行，在这种情况下，不需要使用 “friend” 关键字，因为我们没有使用私有成员函数或变量。

#include StanfordID.h
bool operator< (const StanfordID& lhs, const StanfordID& rhs)
{
    return lhs.getIdNumber() < rhs.getIdNumber();
}

12.4 实践方法

由于运算符旨在传达有关某种类型的含义，这种含义应当是显而易见的。

我们可以定义的运算符通常是算术运算符。其功能应当与其相应的运算在合理范围内保持相似。你不会希望将 operator + 定义为集合减法。如果含义不明确，那么或许可以为此定义一个函数。

这被称为最小惊讶原则（PoLA）。

有一些良好的实践方法，比如相反规则。例如，当你定义 “==” 运算符时，使用相反规则来定义 “!=” 运算符。

bool StanfordID::operator==(const StanfordID& other) const {
    return (name == other.name) && (sunet == other.sunet) &&
    (idNumber == other.idNumber);
}
bool StanfordID::operator!=(const StanfordID& other) const {
    return !(*this == other);
}