聊聊C++ 运算符重载知识

前言

1.运算符重载是一种形式的C++多态。
2.重载运算符可以使代码看起来更加自然。

回顾类

在正常构造类的时候,有些成员方法可以不用写出来,例如在这样一个表示时间的类中,拷贝构造函数只是浅拷贝,和系统默认的步骤是一样的,可以不用写了。 同样,析构函数如果在对象死亡之前没有必须要做的事情,也可以不用写。

所以在下面的例子中,拷贝构造和析构函数可以省略。

class Time
{
public:
	Time();
	Time(const Time& src)
	{
		_hour = src._hour;
		_minutes = src._minutes;
	}
	~Time();
private:
	int _hour;
	int _minutes;
};

通过示例引入运算符重载

示例

若要将两个等数组中各个下标对应的字符相加,普通写法为:

#include<iostream>
using namespace std;
int main(void)
{
	const int SIZE = 10;
	int ch1[SIZE] = { 0,1,2,3,4,5,6,7,8,9 };
	int ch2[SIZE] = { 9,8,7,6,5,4,3,2,1,0 };
	int ch3[SIZE];

	for (int i = 0; i < SIZE; ++i)
	{
		ch3[i] = ch1[i] + ch2[i];
	}

	for (int i = 0; i < SIZE; ++i)
	{
		cout << ch3[i] << " ";
	}
	cout << endl;
	return 0;
}

这样是可以正常输出的:

再来看看运算符重载的示例,这里使用的是 string 类。

#include<iostream>
#include<string>
using namespace std;

int main(void)
{
	string s1 = "aaaa";
	string s2 = "bbbb";
	string s3 = s1 + s2;

	cout << s3 << endl;
	return 0;
}

这里的 s1 + s2就是运用的加法运算符重载,内部实现也是对应的下标再加,但这样简单的写法,强调了实质。

定义

要重载运算符,需要使用被称为运算符函数的特殊函数形式。

格式:

 ret_form operator op(argument-list)

例如加法运算符:

operator +();

可重载的运算符

这里开个玩笑,列出这写可重载的,大家有兴趣可以自己实现。

本文讲述的类

下面是文章示例的一个类:

表示一个复数

class Complex
{
public:
	//默认构造
	Complex();

	//构造函数
	Complex(int a, int b)
	{
		_a = a;
		_b = b;
	}

	//打印
	void show()
	{
		cout << _a << "+" << _b << endl;
	}
	//析构函数
	~Complex()
	{
		cout << "Program Exit" << endl;
	}

private:
	int _a; //实部
	int _b; //虚部
}

加法运算符

如果要使用到加法,如

int main(void)
{
	Complex s1(1, 2);
	Complex s2(2, 3);

	Complex s3 = s1 + s2;

	return 0;
}

那首先要确定,我不能改变加数原本的值,其次,我需要返回一个加完之后的类。

那重载加法运算符声明就可写成:

1.返回类型为 类 类型
2.this指针声明成const
3.第二个加数声明为const

Complex operator +(const Complex& src)const;

函数实现:
这里还用到了构造函数,将其构造后返回。

//加法运算符
	Complex operator +(const Complex& src)const
	{
		int a = _a + src._a;
		int b = _b + src._b;
		return Complex(a, b);
	}

使用运算符的两种方式:

s3和s4用到的方式都可以

	Complex s1(1, 2);
	Complex s2(2, 3);

	Complex s3 = s1 + s2;
	Complex s4 = s1.operator+(s2);

运行示例:
输出了 s3 和s4, 并且析构。

&& 运算符

比如要写一个方法来判断两个复数的实部是否都为0.

	if (s1 && s2)
	{
		cout << "all zero" << endl;
	}

实现:

	//&&
	bool operator &&(const Complex& src)const
	{
		return _a && src._a;
	}

cout<<运算符

想要重载输出运算符,首先想到的是将 cout 当作参数传递给函数。

简易版(相当于show())

	//cout <<
	void operator <<(ostream& out)
	{
		out << _a << "+" << _b << "i" << endl;
	}

这样重载的话,就只能当作show()方法一样调用。而不能直接使用cout。

臻享版

首先要知道,cout是一个二元运算符,那我们传递参数的时候,也是传递两个参数,向上面的简易版,第一个参数为this指针, 第二个才是cout ,如果想把this指针移到第二个参数位置,是办不到的,所以只能当作show方法的样子来写。

void operator <<(/*this*/ostream& out)
	{
		out << _a << "+" << _b << "i" << endl;
	}

解决方法:
把要输出的参数放在第二个位置。

这里就需要在类外实现,实现的方法利用友元性质,放入类中。

如图所示,我确实是在类外写的。

运行示例:
这里直接写cout << s1

int main(void)
{
	Complex s1(1, 2);
	Complex s2(2, 3);

	Complex s3 = s1 + s2;
	Complex s4 = s1.operator+(s2);

	s3.show();
	s4.show();
	//s1.operator<<(cout);
	cout << s1;

	return 0;
}

没有问题,把 1+2i 输出了

但如果想要连续输出,例如:

cout << s1 << s2;

我像上面那样写就不行了,因为这个方法的返回类型是void,函数参数先接收 cout 和 s1, 然后返回void,将void 和 s2又当作参数传递过去,显然是不行的。

解决方法:
将这个方法的返回类型写成输出流对象, 即ostream

ostream& operator <<(ostream& out, const Complex& src)
{
	out << src._a << "+" << src._b << "i" << endl;
	return out;
}

同样友元函数也写成:

friend ostream& operator <<(ostream& out, const Complex& src);

这样写的话就可以连续输出

示例:若要输出三个对象

cout << s1 << s2 << s3;

运行结果

++运算符 前置++

前置++的意思是先 自加1,再返回。

实现:
这里只针对复数的实部

	//前置++
	Complex& operator ++()
	{
		++_a;
		return *this;
	}

后置++

后置++的意思是先传值,再自增1 。

实现:
参数列表里的int没有实质意义,只是让编译器区分前置还是后置。

	//后置++
	Complex operator ++(int)
	{
		int tmp = _a;
		_a++;
		return Complex(tmp, _b);
	}

练习

通过上面介绍的这些运算符重载,可以写出其他一些。

这里可以实现有
减法运算符、 ||运算符、 >>运算符 和 自减运算符(- -)。

例如减法运算符:和加法一样的写法:

	//减法运算符
	Complex operator -(const Complex& src)const
	{
		int a = _a - src._a;
		int b = _b - src._b;
		return Complex(a, b);
	}

到此这篇关于C++ 运算符重载 简介的文章就介绍到这了,更多相关C++ 运算符重载内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • C++运算符重载图文详解

    目录 1. 运算符重载 1.1 运算符重载为普通函数 1.2 运算符重载为成员函数 2. 赋值运算符=的重载 2.1浅复制与深复制 2.2返回值的讨论 3. 动态可变长度数组 总结 1. 运算符重载 C++的运算符只能用于基本的数据类型 表达形式 返回值类型 operator 运算符 (形参表) { ... } 1.1 运算符重载为普通函数 1.2 运算符重载为成员函数 2. 赋值运算符=的重载 当赋值运算符两边的类型不匹配,比如int类型赋值给Complex类型,在这种情况下,就需要重载赋值运

  • C++类与对象之运算符重载详解

    目录 运算符重载 加号运算符重载 左移运算符重载 递增运算符重载 递减运算符重载 赋值运算符重载 关系运算符重载 函数调用运算符重载 总结 运算符重载 运算符重载概念:对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型 加号运算符重载 作用:实现两个自定义数据类型相加的运算 #include <iostream> using namespace std; class Person { public: // 构造函数 Person(int num1, int num2){ thi

  • C++运算符重载详情介绍

    文章转自公众号:Coder梁(ID:Coder_LT) C++当中除了函数可以重载之外,其实运算符也是可以重载的.我们之前已经接触过一些,可能大家没有意识到. 举个例子,乘号*,运用在指针上,就是取值的意思,而运用在算数当中,则是乘法的意思.同样一个符号,用在不同的地方,起到了不同的效果.这其实就是一种重载,C++根据操作数的数目和类型来决定要使用哪一种操作. 另外C++允许将运算符重载扩展到用户自定义的类型,也就是结构体和类当中.比如,我们可以将重载加号,对两个对象相加. 其实这种用法也出现过

  • C++运算符重载限制介绍

    目录 一.重载限制 1.必须至少有一个操作数是用户定义的类型 2.不能违反运算符原来的规则 3.不能创建新运算符 4.禁止名单 5.部分运算符只能通过成员函数重载  文章转自公众号:Coder梁(ID:Coder_LT) 一.重载限制 上一篇我们讲了在类和结构体当中重载运算符,关于运算符的重载并不是随心所欲的.C++给出了一些限制,从而保证了规范,以及程序运行的准确性. 下面我们就来一一来看下: 1.必须至少有一个操作数是用户定义的类型 这句话看不明白没有关系,我们只需要记住它的目的就好了.它的

  • C++双目运算符+=的重载详解

    目录 1.+=重载 2.friend重载+= 3.运算符 3.1 单目运算符 3.2 双目运算符 3.3 三目运算符 4.重载++和重载- - 总结 1.+=重载 class Complex { public: Complex(int a, int b) : _a(a) , _b(b) {} Complex& operator+= (Complex& other) { this->_a += other._a; this->_b += other._b; return *thi

  • 聊聊C++ 运算符重载知识

    前言 1.运算符重载是一种形式的C++多态. 2.重载运算符可以使代码看起来更加自然. 回顾类 在正常构造类的时候,有些成员方法可以不用写出来,例如在这样一个表示时间的类中,拷贝构造函数只是浅拷贝,和系统默认的步骤是一样的,可以不用写了. 同样,析构函数如果在对象死亡之前没有必须要做的事情,也可以不用写. 所以在下面的例子中,拷贝构造和析构函数可以省略. class Time { public: Time(); Time(const Time& src) { _hour = src._hour;

  • c++运算符重载基础知识详解

    实际上,很多C++运算符已经被重载.eg:将*运算符用于地址,将得到存储在这个地址中的值,将他用于2个数字时,得到的将是他们的乘积.C++根据操作数的数目和类型来决定采用哪种操作. C++允许将运算符重载扩展到用户定义的类型.例如,允许使用+将两个对象相加.编译器将根据操作数的数目和类型决定使用加法定义.运算符重载可以使代码看起来更自然.例如,将2个数组相加是一种常见的运算.通常,需要使用下面这样的for循环来实现: 复制代码 代码如下: for (int i = 0; i < 20; i++)

  • C++基础知识之运算符重载详解

    目录 运算符重载 方式一,使用成员函数重载运算符需求:把牛肉换猪肉,羊肉换猪肉 方式二,使用非成员函数[友元函数]重载运算符 两种方式的区别 两种方式的选择: 总结 运算符重载 为什么要使用运算符重载 -C/C++的运算符,支持的数据类型,仅限于基本数据类型. 问题:一头牛+一头马 = ?(牛马神兽?) 一个圆 +一个圆 = ? (想要变成一个更大的圆)一头牛 – 一只羊 = ? (想要变成4只羊,原始的以物易物:1头牛价值5只羊) 解决方案: 使用运算符重载 方式一, 使用成员函数重载运算符

  • 详解C++编程中的单目运算符重载与双目运算符重载

    C++单目运算符重载 单目运算符只有一个操作数,如!a,-b,&c,*p,还有最常用的++i和--i等.重载单目运算符的方法与重载双目运算符的方法是类似的.但由于单目运算符只有一个操作数,因此运算符重载函数只有一个参数,如果运算符重载函数作为成员函数,则还可省略此参数. 下面以自增运算符"++"为例,介绍单目运算符的重载. [例] 有一个Time类,包含数据成员minute(分)和sec(秒),模拟秒表,每次走一秒,满60秒进一分钟,此时秒又从0开始算.要求输出分和秒的值. #

  • C++中的四个默认成员函数与运算符重载详解

    本文主要给大家介绍了关于C++默认成员函数与运算符重载的相关内容,分享出来公的敬爱啊参考学习,话不多说,来一起看看详细的介绍: 一:类和对象的基础知识:类的定义,访问限定符,面向对象封装性,对象的大小计算等等.(编译环境为VS2015) 面向对象程序设计: 概念:(Object Oriented Programming,缩写:OOP)是一种程序设计范型,同时也是一种程序开发的方法.对象指的是类的实例,将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的重用性.灵活性和扩展性. 类:类的基

  • 详解C++中赋值,关系,函数调用运算符重载的实现

    目录 赋值运算符重载 类结构 问题的出现 具体实现 关系运算符重载 类结构 具体实现 函数调用运算符重载 类结构 具体实现 总结 赋值运算符重载 在C++中基本数据类型例如整型,可以实现连续赋值:a=b=c:而我们的对象的成员属性虽然可以相等,但是如果牵扯到堆地址,就会有深浅拷贝的问题存在.所以我们自己重载赋值运算符,实现连等的方法. 类结构 class Info { int* m_a; public: Info() { m_a = NULL; } Info(int a) { m_a = new

  • Python运算符重载详解及实例代码

    Python运算符重载 Python语言提供了运算符重载功能,增强了语言的灵活性,这一点与C++有点类似又有些不同.鉴于它的特殊性,今天就来讨论一下Python运算符重载. Python语言本身提供了很多魔法方法,它的运算符重载就是通过重写这些Python内置魔法方法实现的.这些魔法方法都是以双下划线开头和结尾的,类似于__X__的形式,python通过这种特殊的命名方式来拦截操作符,以实现重载.当Python的内置操作运用于类对象时,Python会去搜索并调用对象中指定的方法完成操作. 类可以

  • Python运算符重载用法实例分析

    本文实例讲述了Python运算符重载用法.分享给大家供大家参考.具体如下: 在Python语言中提供了类似于C++的运算符重在功能: 一下为Python运算符重在调用的方法如下: Method         Overloads         Call for __init__        构造函数         X=Class() __del__         析构函数         对象销毁 __add__         +                 X+Y,X+=Y __

  • Python运算符重载用法实例

    本文实例讲述了Python运算符重载用法.分享给大家供大家参考.具体分析如下: python中,我们在定义类的时候,可以通过实现一些函数来实现重载运算符. 例子如下: # -*- coding:utf-8 -*- ''''' Created on 2013-3-21 @author: naughty ''' class Test(object): def __init__(self, value): self.value = value def __add__(self, x): return

  • c++ *运算符重载

    运算符重载,对象和指向对象的指针 直接上code 复制代码 代码如下: #include <iostream> using namespace std;  class test {     public:         int a;         test() : a(0){}         test &operator*(){             cout << "operator*" << endl;             c

随机推荐