【C++】运算符重载 二 （实例）

最新推荐文章于 2026-03-26 02:22:20 发布
原创 最新推荐文章于 2026-03-26 02:22:20 发布 · 560 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详细介绍了C++中的运算符重载，包括一元运算符、二元运算符、关系运算符、输入/输出运算符、赋值运算符、函数调用运算符、下标运算符和类成员访问运算符的重载实例，帮助读者深入理解运算符重载的概念和应用。

前接文章：【C++】运算符重载 一

值得注意的是:

  • 1、运算重载符不可以改变语法结构。
  • 2、运算重载符不可以改变操作数的个数。
  • 3、运算重载符不可以改变优先级。
  • 4、运算重载符不可以改变结合性。
  •  

类重载、覆盖、重定义之间的区别：

重载指的是函数具有的不同的参数列表，而函数名相同的函数。重载要求参数列表必须不同，比如参数的类型不同、参数的个数不同、参数的顺序不同。如果仅仅是函数的返回值不同是没办法重载的，因为重载要求参数列表必须不同。（发生在同一个类里）

 覆盖是存在类中，子类重写从基类继承过来的函数。被重写的函数不能是static的。必须是virtual的。但是函数名、返回值、参数列表都必须和基类相同（发生在基类和子类）

 重定义也叫做隐藏，子类重新定义父类中有相同名称的非虚函数 ( 参数列表可以不同 ) 。（发生在基类和子类）

运算符重载实例

下面提供了各种运算符重载的实例，帮助您更好地理解重载的概念。

C++ 一元运算符重载

一元运算符只对一个操作数进行操作，下面是一元运算符的实例：

  • 递增运算符（ ++ ）和递减运算符（ -- ）是 C++ 语言中两个重要的一元运算符。下面的实例演示了如何重载递增运算符（ ++ ），包括前缀和后缀两种用法。类似地，您也可以尝试重载递减运算符（ -- ）。一元运算符通常出现在它们所操作的对象的左边，比如 !obj、-obj 和 ++obj，但有时它们也可以作为后缀，比如 obj++ 或 obj--。
#include <iostream>
using namespace std;

class Time
{
private:
	int hours;             // 0 到 23
	int minutes;           // 0 到 59
public:
	// 所需的构造函数
	Time() {
		hours = 0;
		minutes = 0;
	}
	Time(int h, int m) {
		hours = h;
		minutes = m;
	}
	// 显示时间的方法
	void displayTime()
	{
		cout << "H: " << hours << " M:" << minutes << endl;
	}

	// 重载前缀递增运算符（ ++ ）
	Time operator++ ()
	{
		++minutes;          // 对象加 1
		if (minutes >= 60)
		{
			++hours;
			minutes -= 60;
		}
		return Time(hours, minutes);
	}

	// 重载后缀递增运算符（ ++ ）
	Time operator++(int)
	{
		// 保存原始值
		Time T(hours, minutes);
		// 对象加 1
		++minutes;
		if (minutes >= 60)
		{
			++hours;
			minutes -= 60;
		}
		// 返回旧的原始值
		return T;
	}
};

int main()
{
	Time T1(11, 59), T2(10, 40);

	++T1;                    // T1 加 1
	T1.displayTime();        // 显示 T1
	++T1;                    // T1 再加 1
	T1.displayTime();        // 显示 T1

	T2++;                    // T2 加 1
	T2.displayTime();        // 显示 T2
	T2++;                    // T2 再加 1
	T2.displayTime();        // 显示 T2
	return 0;
}

--------------------------------------------------
H: 12 M:0
H: 12 M:1
H: 10 M:41
H: 10 M:42
--------------------------------------------------

注意前缀和后缀的写法！！！

  • 一元减运算符，即负号（ - ）
#include <iostream>
using namespace std;

class Distance
{
private:
	int feet;             // 0 到无穷
	int inches;           // 0 到 12
public:
	// 所需的构造函数
	Distance() {
		feet = 0;
		inches = 0;
	}
	Distance(int f, int i) {
		feet = f;
		inches = i;
	}
	// 显示距离的方法
	void displayDistance()
	{
		cout << "F: " << feet << " I:" << inches << endl;
	}

	// 重载负运算符（ - ）
	Distance operator- ()
	{
		feet = -feet;
		inches = -inches;
		return Distance(feet, inches);
	}
};

int main()
{
	Distance D1(11, 10), D2(-5, 11);

	-D1;                     // 取相反数
	D1.displayDistance();    // 距离 D1

	-D2;                     // 取相反数
	D2.displayDistance();    // 距离 D2

	return 0;
}

-----------------------------------------------
F: -11 I:-10
F: 5 I:-11
-----------------------------------------------
  • 希望上面的实例能够帮您更好地理解一元运算符重载的概念，类似地，您可以尝试重载逻辑非运算符（ ！ ）。

C++ 二元运算符重载

二元运算符需要两个参数，下面是二元运算符的实例。我们平常使用的加运算符（ + ）、减运算符（ - ）、乘运算符（ * ）和除运算符（ / ）都属于二元运算符。就像加(+)运算符。下面的实例演示了如何重载加运算符（ + ）。类似地，您也可以尝试重载减运算符（ - ）和除运算符（ / ）。

#include <iostream>
using namespace std;
 
class Box
{
   double length;      // 长度
   double breadth;     // 宽度
   double height;      // 高度
public:
 
   double getVolume(void)
   {
      return length * breadth * height;
   }
   void setLength( double len )
   {
       length = len;
   }
 
   void setBreadth( double bre )
   {
       breadth = bre;
   }
 
   void setHeight( double hei )
   {
       height = hei;
   }
   // 重载 + 运算符，用于把两个 Box 对象相加
   Box operator+(const Box& b)
   {
      Box box;
      box.length = this->length + b.length;
      box.breadth = this->breadth + b.breadth;
      box.height = this->height + b.height;
      return box;
   }
};
// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1，类型为 Box
   Box Box2;                // 声明 Box2，类型为 Box
   Box Box3;                // 声明 Box3，类型为 Box
   double volume = 0.0;     // 把体积存储在该变量中
 
   // Box1 详述
   Box1.setLength(6.0); 
   Box1.setBreadth(7.0); 
   Box1.setHeight(5.0);
 
   // Box2 详述
   Box2.setLength(12.0); 
   Box2.setBreadth(13.0); 
   Box2.setHeight(10.0);
 
   // Box1 的体积
   volume = Box1.getVolume();
   cout << "Volume of Box1 : " << volume <<endl;
 
   // Box2 的体积
   volume = Box2.getVolume();
   cout << "Volume of Box2 : " << volume <<endl;
 
   // 把两个对象相加，得到 Box3
   Box3 = Box1 + Box2;
 
   // Box3 的体积
   volume = Box3.getVolume();
   cout << "Volume of Box3 : " << volume <<endl;
 
   return 0;
}

-----------------------------------
Volume of Box1 : 210
Volume of Box2 : 1560
Volume of Box3 : 5400
-----------------------------------

C++ 关系运算符重载

C++ 语言支持各种关系运算符（ < 、 > 、 <= 、 >= 、 == 等等），它们可用于比较 C++ 内置的数据类型。您可以重载任何一个关系运算符，重载后的关系运算符可用于比较类的对象。下面的实例演示了如何重载 < 运算符，类似地，您也可以尝试重载其他的关系运算符。

#include <iostream>
using namespace std;
 
class Distance
{
   private:
      int feet;             // 0 到无穷
      int inches;           // 0 到 12
   public:
      // 所需的构造函数
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      // 显示距离的方法
      void displayDistance()
      {
         cout << "F: " << feet << " I:" << inches <<endl;
      }
      // 重载负运算符（ - ）
      Distance operator- ()  
      {
         feet = -feet;
         inches = -inches;
         return Distance(feet, inches);
      }
      // 重载小于运算符（ < ）
      bool operator <(const Distance& d)
      {
         if(feet < d.feet)
         {
            return true;
         }
         if(feet == d.feet && inches < d.inches)
         {
            return true;
         }
         return false;
      }
};

int main()
{
   Distance D1(11, 10), D2(5, 11);
 
   if( D1 < D2 )
   {
      cout << "D1 is less than D2 " << endl;
   }
   else
   {
      cout << "D2 is less than D1 " << endl;
   }
   return 0;
}


-----------------------------
D2 is less than D1
-----------------------------

C++ 输入/输出运算符重载

C++ 能够使用流提取运算符 >> 和流插入运算符 << 来输入和输出内置的数据类型。您可以重载流提取运算符和流插入运算符来操作对象等用户自定义的数据类型。在这里，有一点很重要，我们需要把运算符重载函数声明为类的友元函数，这样我们就能不用创建对象而直接调用函数。下面的实例演示了如何重载提取运算符 >> 和插入运算符 <<。

#include <iostream>
using namespace std;

class Distance
{
private:
	int feet;             // 0 到无穷
	int inches;           // 0 到 12
public:
	// 所需的构造函数
	Distance() 
	{
		feet = 0;
		inches = 0;
	}
	Distance(int f, int i) 
	{
		feet = f;
		inches = i;
	}

	friend ostream &operator<<(ostream &output,	const Distance &D)
	{
		output << "F : " << D.feet << " I : " << D.inches;
		return output;
	}
	friend istream &operator >> (istream  &input, Distance &D)
	{
		input >> D.feet >> D.inches;
		return input;
	}
};

int main()
{
	Distance D1(11, 10), D2(5, 11), D3;

	cout << "Enter the value of object : " << endl;
	cin >> D3;
	cout << "First Distance : " << D1 << endl;
	cout << "Second Distance :" << D2 << endl;
	cout << "Third Distance :" << D3 << endl;

	return 0;
}

----------------------
Enter the value of object :
70
10
First Distance : F : 11 I : 10
Second Distance :F : 5 I : 11
Third Distance :F : 70 I : 10
----------------------

C++ 赋值运算符重载

就像其他运算符一样，您可以重载赋值运算符（ = ），用于创建一个对象，比如拷贝构造函数。下面的实例演示了如何重载赋值运算符。

#include <iostream>
using namespace std;
 
class Distance
{
   private:
      int feet;             // 0 到无穷
      int inches;           // 0 到 12
   public:
      // 所需的构造函数
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      void operator=(const Distance &D )
      { 
         feet = D.feet;
         inches = D.inches;
      }
      // 显示距离的方法
      void displayDistance()
      {
         cout << "F: " << feet <<  " I:" <<  inches << endl;
      }
      
};
int main()
{
   Distance D1(11, 10), D2(5, 11);
 
   cout << "First Distance : "; 
   D1.displayDistance();
   cout << "Second Distance :"; 
   D2.displayDistance();
 
   // 使用赋值运算符
   D1 = D2;
   cout << "First Distance :"; 
   D1.displayDistance();
 
   return 0;
}

----------------------------
First Distance : F: 11 I:10
Second Distance :F: 5 I:11
First Distance :F: 5 I:11
----------------------------

C++ 函数调用运算符 () 重载

函数调用运算符 () 可以被重载用于类的对象。当重载 () 时，您不是创造了一种新的调用函数的方式，相反地，这是创建一个可以传递任意数目参数的运算符函数。下面的实例演示了如何重载函数调用运算符 ()。

#include <iostream>
using namespace std;
 
class Distance
{
   private:
      int feet;             // 0 到无穷
      int inches;           // 0 到 12
   public:
      // 所需的构造函数
      Distance(){
         feet = 0;
         inches = 0;
      }
      Distance(int f, int i){
         feet = f;
         inches = i;
      }
      // 重载函数调用运算符
      Distance operator()(int a, int b, int c)
      {
         Distance D;
         // 进行随机计算
         D.feet = a + c + 10;
         D.inches = b + c + 100 ;
         return D;
      }
      // 显示距离的方法
      void displayDistance()
      {
         cout << "F: " << feet <<  " I:" <<  inches << endl;
      }
      
};
int main()
{
   Distance D1(11, 10), D2;

   cout << "First Distance : "; 
   D1.displayDistance();

   D2 = D1(10, 10, 10); // invoke operator()
   cout << "Second Distance :"; 
   D2.displayDistance();

   return 0;
}
-----------------------------------------
First Distance : F: 11 I:10
Second Distance :F: 30 I:120
-----------------------------------------

C++ 下标运算符 [] 重载

下标操作符 [] 通常用于访问数组元素。重载该运算符用于增强操作 C++ 数组的功能。下面的实例演示了如何重载下标运算符 []。

#include <iostream>
using namespace std;
const int SIZE = 10;

class safearay
{
   private:
      int arr[SIZE];
   public:
      safearay() 
      {
         register int i;
         for(i = 0; i < SIZE; i++)
         {
           arr[i] = i;
         }
      }
      int& operator[](int i)
      {
          if( i > SIZE )
          {
              cout << "索引超过最大值" <<endl; 
              // 返回第一个元素
              return arr[0];
          }
          return arr[i];
      }
};
int main()
{
   safearay A;

   cout << "A[2] 的值为 : " << A[2] <<endl;
   cout << "A[5] 的值为 : " << A[5]<<endl;
   cout << "A[12] 的值为 : " << A[12]<<endl;

   return 0;
}
-----------------------
A[2] 的值为 : 2
A[5] 的值为 : 5
A[12] 的值为 : 索引超过最大值
0
-----------------------

C++ 类成员访问运算符 -> 重载

类成员访问运算符（ -> ）可以被重载，但它较为麻烦。它被定义用于为一个类赋予"指针"行为。运算符 -> 必须是一个成员函数。如果使用了 -> 运算符，返回类型必须是指针或者是类的对象。运算符 -> 通常与指针引用运算符 * 结合使用，用于实现"智能指针"的功能。这些指针是行为与正常指针相似的对象，唯一不同的是，当您通过指针访问对象时，它们会执行其他的任务。比如，当指针销毁时，或者当指针指向另一个对象时，会自动删除对象。间接引用运算符 -> 可被定义为一个一元后缀运算符。也就是说，给出一个类：

class Ptr{
   //...
   X * operator->();
};

类 Ptr 的对象可用于访问类 X 的成员，使用方式与指针的用法十分相似。例如：

void f(Ptr p )
{
   p->m = 10 ; // (p.operator->())->m = 10
}

语句 p->m 被解释为 (p.operator->())->m。同样地，下面的实例演示了如何重载类成员访问运算符 ->。

#include <iostream>
#include <vector>
using namespace std;
 
// 假设一个实际的类
class Obj {
   static int i, j;
public:
   void f() const { cout << i++ << endl; }
   void g() const { cout << j++ << endl; }
};
 
// 静态成员定义
int Obj::i = 10;
int Obj::j = 12;
 
// 为上面的类实现一个容器
class ObjContainer {
   vector<Obj*> a;
public:
   void add(Obj* obj)
   { 
      a.push_back(obj);  // 调用向量的标准方法
   }
   friend class SmartPointer;
};
 
// 实现智能指针，用于访问类 Obj 的成员
class SmartPointer {
   ObjContainer oc;
   int index;
public:
   SmartPointer(ObjContainer& objc)
   { 
       oc = objc;
       index = 0;
   }
   // 返回值表示列表结束
   bool operator++() // 前缀版本
   { 
     if(index >= oc.a.size() - 1) return false;
     if(oc.a[++index] == 0) return false;
     return true;
   }
   bool operator++(int) // 后缀版本
   { 
      return operator++();
   }
   // 重载运算符 ->
   Obj* operator->() const 
   {
     if(!oc.a[index])
     {
        cout << "Zero value";
        return (Obj*)0;
     }
     return oc.a[index];
   }
};
 
int main() {
   const int sz = 10;
   Obj o[sz];
   ObjContainer oc;
   for(int i = 0; i < sz; i++)
   {
       oc.add(&o[i]);
   }
   SmartPointer sp(oc); // 创建一个迭代器
   do {
      sp->f(); // 智能指针调用
      sp->g();
   } while(sp++);
   return 0;
}
------------------------------------------------------
10
12
11
13
12
14
13
15
14
16
15
17
16
18
17
19
18
20
19
21
------------------------------------------------------

参考来源：C++ 重载运算符和重载函数

C++初阶讲解—运算符重载汇总+实例（上）
m0_57781768的博客
11-17 1629
运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
C++运算符重载详解及代码示例
weixin_46935110的博客
10-14 2461
c++运算符重载详解及代码示例
Apache Doris实战：如何用Doris替代传统数据仓库的5个关键场景（附性能对比）
最新发布
weixin_30500105的博客
03-26 451
本文探讨了Apache Doris在替代传统数据仓库中的5个关键场景，包括实时分析、高并发查询、即席分析、日志处理和统一数仓。通过详细的性能对比和实战案例，展示了Doris在亚秒级响应、高并发支持和架构简化方面的优势，助力企业提升数据分析效率。
运算符重载的几个小例子
weixin_30388677的博客
03-14 287
0.重载运算符时，*必须首先决定是将其声明为类的成员函数（有一个this指针）还是非成员函数！！！* 一般有下面的这样一些规则： 必须这样做的： =，[ ]，( ) ， -> 必须是成员函数 希望为类自定义IO运算符时 ，输入 >> 和输出 << 运算符必须是友元非成员函数 按你的想法和要求做的： +...
c++ 运算符重载实例
m0_63121505的博客
06-30 236
【代码】c++ 运算符重载实例。
每日一练20210716
upon120的博客
07-18 1172
1、在支持多线程的系统中，进程P创建的若干个线程不能共享的是（）。 2021-07-17 23:28:57 A、 进程P的代码段 B、 进程P中打开的文件 C、 进程P的全局变量 D、 进程P中某线程的栈指针 回答正确正确答案:D 解析: 进程是资源分配的基本单位，线程是处理机调度的基本单位。因此，进程的代码段、进程打开的文件、进程的全局变量等都是进程的资源，唯有进程中某线程的栈指针是属于线程的，属于进程的资源可以共享，属于线程的栈是独享的，对其他线程透明。 2、安全的使用复制...
C++——重载运算符（二）（实例）
qq_36640480的博客
12-02 464
要求，重载“–”运算符，使得可以类自减。 例子采用上一篇，连接如下： C++——重载运算符（一）（实例） 学了运算符重载，才想知道类是否知道自减，我们做了如下尝试 代码如下：（不可以，会报错） #include<iostream> #include<string> using namespace std; //写一个简单的类 class Show{ friend o...
《C++实战小练》**02：运算符重载实例（二）
qq_45766916的博客
05-12 143
前言 其实运算符重载这一块大家还是忽略了他的重要性。熟练地掌握运算符重载可以更好地理解类的概念，更好地使用。 题目 其实本质上就是向量相加，注意要对两个运算符重载。 源码 #include <iostream> #include<cstdlib> using namespace std; class test { protected: int x1, y1, x2, y2; public: test() { x1 = 0;
C++重载运算符
Hans的博客
02-18 401
#include "stdafx.h" using namespace std; class Complax { public: Complax(int a = 0, int b = 0) { this-&gt;a = a; this-&gt;b = b; } void printC() { cout &lt...
C++运算符重载（类内、外重载）
热门推荐
u014583317的博客
10-27 7万+
1.概念   运算符的重载，实际是一种特殊的函数重载，必须定义一个函数，并告诉C++编译器，当遇到该运算符时就调用此函数来行使运算符功能。这个函数叫做运算符重载函数（常为类的成员函数）。 2.运算符重载的基本格式    返回值类型 类名::operator重载的运算符(参数表)    {    ……    }    operator是关键字，它与重载的运算符一起构成函数名。 3.运算符重载的两种方法 1.类内重载 #include <iostream> using namespa
牛客网中值得记下的C++错题
m0_60492395的博客
09-21 548
如简介
通过类实现矩阵加减法、乘法、转置（C++））
fzy2003的博客
03-19 7614
定义一个二维方阵类 matrix 通过重载二元运算符“+”、“-”、“*”和一元运算符“~”， 来实现矩阵加、矩阵减、矩阵乘以及矩阵转置。 matrix类的构造、拷贝构造及析构 1.由于矩阵的行与列都是未知的，首先需要通过动态分配内存实现创建任意大小的矩阵，由于类中默认的构造函数无法满足我们的需求，因此首先应该改写构造函数 matrix(int a, int b) { r = a; c = b; mem = new int* [a]; for (int i = 0; i < a; i+
虚函数与运算符重载(Virtual Operator Overloading)
hopegrace的博客
01-28 1162
虚函数与运算符重载(VirtualOperatorOverloading) 一、相关日志 运算符重载 http://blog.163.com/zhoumhan_0351/blog/static/399542272010027113311390 多态性与虚函数 http://blog.163.com/zhoumhan_0351/blog/static/39954227201002902...
c++中重载，重写，赋值运算符重载函数
是鲤鱼啊
09-05 1564
一.重载与重写的区别 1.重载 重载从overload翻译过来，是指同一可访问区内被声明的几个具有不同参数列表（参数的类型，个数，顺序不同）的同名函数，根据参数列表确定调用哪个函数，重载不关心函数返回类型。 相同的范围（在同一个作用域中） 函数名字相同 参数不同列表 virtual 关键字可有可无 返回类型可以不同 int test(); int test(int a); int test(int a,double b); int test(double a,int a); int tes.
运算符重载
Summer的博客
11-30 589
1、C++中运算符实际也是函数，只是在描述运算符函数时，使用了关键字operator，其他跟普通函数是一致的，故遵守函数重载的原则。 2、运算符重载原则  1 除了*,.,sizeof ,?:,::这五个运算符外，其他所有的C++运算符都可以重载，但不允许重载非C++的运算符，如#,##等 2运算符重载不改变运算符的优先级和结合性，也不改变其语法结构，即单目运算符只能重载为单目运算符，双目运...
C++期末试题（一）
Rachel_IS的博客
02-26 1561
买的教材都没到…C++课上看学弟学妹讨论好无聊，先刷题巩固一下叭～ 今天的习题是https://wenku.baidu.com/view/7232fb0f7cd184254b353523.html 虚函数 在基类中声明为 virtual ，在派生类中被重新定义的成员函数 （Java中的抽象函数abstract） 定义一个函数为纯虚函数，才代表函数没有被实现 实现动态联编，虚函数通过对象指针调用 &...
C++期末考试选择题题库100道&&C++期末判断题的易错知识点复习
yaosichengalpha的博客
04-22 1万+
C++期末考试选择题题库100道&&C++期末判断题的易错知识点复习
十个 C++ 运算符重载示例，看完不懂打我...
程序员「阿基米东」的编程之旅
11-28 4万+
下面是一些 C++ 运算符重载示例，包括算术运算符、赋值运算符、逻辑运算符、成员运算符、关系运算符等等，这些都是使用频率较高的几个运算符重载案例。 ⭐️ 所有示例代码均存放于 GitHub: getiot/cpp-courses/operator_overloading 。 示例 1：一元运算符重载 一元运算符即只对一个操作数进行操作的运算符，例如：!obj、-obj、++obj 、obj++ 或 obj-- 等等。 下面示例将对负号（-）进行重载： #include <iostream> u
（十）重载输入输出流运算符（友元函数）
曾几何时的博客
11-27 2347
输出流重载函数引入友元函数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值