运算符重载允许为自定义类型赋予运算符新含义，提升代码可读性与自然表达；可通过成员函数（如一元、赋值运算符）或全局友元函数（如流操作、对称运算）实现；需遵循语义一致、const正确性、返回类型合理等最佳实践，避免常见陷阱。
C++中的运算符重载，简而言之，就是赋予现有运算符新的意义，让它们能作用于我们自定义的类类型对象。这让我们的代码在处理自定义数据时也能保持一种自然、直观的语法，就像处理内置类型一样。实现方式主要有两种：作为类的成员函数，或者作为非成员的全局函数（通常是友元函数）。选择哪种方式，往往取决于运算符的语义、操作数类型以及对封装性的考量，没有绝对的优劣，只有更合适的场景。
当我们需要为自定义类型（比如一个表示复数或向量的类）定义加法、减法、输出等操作时，运算符重载就显得尤为重要。它能让
Complex c3 = c1 + c2;
Complex c3 = c1.add(c2);
1. 作为成员函数实现运算符重载：
这种方式适用于那些操作天然属于对象自身，或者左操作数必须是该类对象的情况。典型的例子有：
立即学习“C++免费学习笔记（深入）”；
!
~
++
--
=
+=
-=
*=
[]
()
->
作为成员函数时，运算符的左操作数就是调用该函数的对象本身（通过
this
示例（成员函数实现 +
class MyNumber {
private:
int value;
public:
MyNumber(int v = 0) : value(v) {}
// 成员函数重载 + 运算符
MyNumber operator+(const MyNumber& other) const {
return MyNumber(this->value + other.value);
}
// 成员函数重载前置 ++ 运算符
MyNumber& operator++() { // 返回引用，可以链式操作
++value;
return *this;
}
// 成员函数重载后置 ++ 运算符 (int dummy 参数是区分前置和后置的关键)
MyNumber operator++(int) {
MyNumber temp = *this; // 保存当前状态
++(*this); // 调用前置++实现自增
return temp; // 返回之前保存的状态
}
int getValue() const { return value; }
};
// 使用
// MyNumber n1(10), n2(20);
// MyNumber n3 = n1 + n2; // 调用 n1.operator+(n2)
// ++n1; // 调用 n1.operator++()
// MyNumber n4 = n1++; // 调用 n1.operator++(0)2. 作为全局函数（非成员函数）实现运算符重载：
当运算符需要处理的左操作数不是我们类的对象，或者运算符是“对称”的（即两个操作数地位相当，不偏向任何一方），又或者需要与其他类型进行混合运算时，全局函数是更好的选择。最典型的例子是流插入/提取运算符
<<
>>
全局函数重载运算符时，所有操作数都需要作为参数显式传递。如果需要访问类的私有或保护成员，这个全局函数通常需要声明为类的
friend
示例（全局函数实现 +
<<
#include <iostream>
class MyNumber {
private:
int value;
public:
MyNumber(int v = 0) : value(v) {}
int getValue() const { return value; }
// 声明友元函数，允许其访问私有成员
friend MyNumber operator+(int lhs, const MyNumber& rhs);
friend std::ostream& operator<<(std::ostream& os, const MyNumber& num);
};
// 全局函数重载 + 运算符 (支持 int + MyNumber)
MyNumber operator+(int lhs, const MyNumber& rhs) {
return MyNumber(lhs + rhs.value); // 访问 MyNumber 的私有成员
}
// 全局函数重载 << 运算符 (通常都是友元函数)
std::ostream& operator<<(std::ostream& os, const MyNumber& num) {
os << "MyNumber(" << num.value << ")"; // 访问 MyNumber 的私有成员
return os;
}
// 使用
// MyNumber n1(10);
// MyNumber n2 = 5 + n1; // 调用 operator+(5, n1)
// std::cout << n2 << std::endl; // 调用 operator<<(std::cout, n2)C++引入运算符重载，核心目的在于提升代码的可读性、直观性以及表达力。设想一下，如果我们有一个表示复数的
Complex
Complex c3 = c1.add(c2);
Complex c3; c1.add(c2, c3);
c1 + c2
痛点在于：内置运算符无法直接作用于自定义类型。编译器只知道如何对
int
double
MyVector
MyMatrix
MyString
运算符重载的出现，完美解决了这个痛点。它允许我们为自定义类型“定制”运算符的行为，使得
vector1 + vector2
matrix * scalar
cout << myObject
选择成员函数还是全局函数来实现运算符重载，这确实是C++设计中一个值得深思的问题，并非简单的二选一，而是基于特定场景和运算符语义的权衡。
优先选择成员函数的情况：
!
~
++
--
this
// 成员函数重载前置递增
MyClass& operator++() { /* ... */ return *this; }=
+=
-=
*=
// 成员函数重载赋值运算符
MyClass& operator=(const MyClass& other) { /* ... */ return *this; }[]
()
->
// 成员函数重载下标运算符
int& operator[](size_t index) { /* ... */ return data[index]; }优先选择全局函数（通常是友元函数）的情况：
int + MyClass
operator+
MyClass + int
this
MyClass
int + MyClass
// 全局函数重载，支持 int + MyClass
MyClass operator+(int lhs, const MyClass& rhs) { /* ... */ }+
-
*
/
A + B
B + A
A
B
// 全局函数重载，支持 MyClass + MyOtherClass
MyResultClass operator+(const MyClass& lhs, const MyOtherClass& rhs) { /* ... */ }<<
>>
std::ostream
std::istream
// 全局友元函数重载 <<
std::ostream& operator<<(std::ostream& os, const MyClass& obj) { /* ... */ return os; }友元函数的考量：
全局函数要访问类的私有或保护成员时，就需要声明为友元。友元机制打破了封装性，允许非成员函数直接访问类的内部实现。这需要谨慎使用。但对于流运算符
<<
>>
getter
总结来说，一个经验法则是：如果操作改变了对象的状态，或者它是一元运算符、赋值运算符等，那么成员函数是首选。如果操作是二元的，且左操作数不一定是类类型，或者它是一个像
<<
运算符重载虽然强大，但如果不当使用，可能会引入难以察觉的bug或降低代码可读性。这里列举一些常见的“坑”和相应的最佳实践。
常见的“坑”：
operator+
operator==
true
Vector
operator*
+
-
*
/
=
+=
-=
++obj
--obj
*this
<<
>>
std::ostream&
std::istream&
++
--
int
++
*this
MyClass a = b++;
A
B
const
const
const
MyClass operator+(const MyClass& other)
const
const MyClass c1; c1 + c2;
operator=
=
obj = obj;
最佳实践：
operator*
multiply()
+=
-=
+
-
// 成员函数实现 +=
MyNumber& operator+=(const MyNumber& other) {
this->value += other.value;
return *this;
}
// 全局函数实现 +
MyNumber operator+(MyNumber lhs, const MyNumber& rhs) { // lhs 按值传递
lhs += rhs; // 调用 += 运算符
return lhs;
}这样做的好处是
operator+
operator+=
lhs
const
const
const
const
noexcept
noexcept
&&
||
,
operator=
// 假设 MyClass 有一个交换函数 swap
MyClass& operator=(MyClass other) { // 参数按值传递，利用了拷贝构造函数
swap(*this, other); // 交换内部资源
return *this;
}遵循这些实践，可以让我们在享受运算符重载带来的便利时，避免踩入常见的陷阱，写出更健壮、更易读的C++代码。
以上就是C++运算符重载 成员函数全局函数实现的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告
收藏
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
782
