C语言运算符的重载详解

目录
  • 写一个Add函数
  • 为什么不用加号作为函数名
  • 运算符的重载
  • 上面问题解决
  • 总结

写一个Add函数

我们先讨论下面代码,并复习前面的内容

class Complex
{
private:
	double Real, Image;
public:
	Complex() :Real(0), Image(0) {}
	Complex(double r, double i) :Real(r), Image(i) {}
	~Complex() {}
	//Complex Add(const Complex* const this,const Complex &c)
	Complex Add(const Complex& x)const
	{
		Complex y;
		y.Real = Real + x.Real;
		y.Image = Image + x.Image;
		return y;
		//return Complex(this->Real + x.Real, this->Image + x.Image);
	}
	void Print()
	{
		cout << Real << "+" << Image << "i" << endl;
	}

};
int main()
{
	Complex c1(12, 23);
	Complex c2(4.5, 5.6);
	Complex c3;
	c3 = c1.Add(c2);
	c3.Print();

	return 0;
}

直接return可以使用无名函数直接代替将亡值对象,相比可以省一次对象的构建

我们再分析如果我们使用引用返回Add函数

const Complex& Add(const Complex& x)const
	{
		Complex y;
		y.Real = Real + x.Real;
		y.Image = Image + x.Image;
		return y;
		//return Complex(this->Real + x.Real, this->Image + x.Image);
	}

若我们以引用返回,将亡值对象会创建在Add函数的栈帧中,然后返回将亡值地址,函数return结束该空间会被释放、

若没有引用,构建无名对象也就是将亡值对象会构建在主函数的空间中,这里使用将亡值对象值给到c3是没有问题的

我们查看对象的构造与析构

class Complex
{
private:
	double Real, Image;
public:
	Complex() :Real(0), Image(0) {}
	Complex(double r, double i) :Real(r), Image(i)
	{
		cout << "Create:" << this << endl;
	}
	Complex(const Complex& x):Real(x.Real),Image(x.Image)
	{
		cout << "Copy Create:" << this << endl;
	}
	~Complex()
	{
		cout << "~Complex:" << this << endl;
	}
	//Complex Add(const Complex* const this,const Complex &c)
	Complex Add(const Complex& x)const
	{
		return Complex(this->Real + x.Real, this->Image + x.Image);
	}
	void Print()
	{
		cout << Real << "+" << Image << "i" << endl;
	}

};

int main()
{
	Complex c1(12, 23);
	Complex c2(4.5, 5.6);
	Complex c3;
	c3 = c1.Add(c2);
	c3.Print();

	return 0;
}

首先我们使用引用返回需要加上const修饰,这是因为我们返回将亡值在临时空间具有常性,所以普通引用是不能进行返回的,需要使用常引用返回

const Complex& Add(const Complex& x)const
{
	return Complex(this->Real + x.Real, this->Image + x.Image);
}

我们发现对临时对象的构建后马上就进行析构,那么是怎么将数据拿出给到c3的?这个在最后我们进行分析

为什么不用加号作为函数名

//Complex operator+(const Complex* const this,const Complex &c)
Complex operator+(const Complex &c) const
{
	return Complex(this->Real + x.Real, this->Image + x.Image);
}

这里是不可以的,加号是一个操作符,不能使用操作放作为有效的函数名称;但是在C++中为了使这些操作符号能够当作函数名,那么我们需要在前面加上一个关键字operator

//Complex operator+(const Complex* const this,const Complex &c)
Complex operator+(const Complex &c) const
{
	return Complex(this->Real + x.Real, this->Image + x.Image);
}
也就是告诉编译器,加号是一个有效的函数名,这就叫做运算符的重载;随后我们之间使用 c3 = c1 + c2 就是可以的
int main()
{
	Complex c1(12, 23);
	Complex c2(4.5, 5.6);
	Complex c3;
	c3 = c1 + c2;
	//编译器编译会是下面的情况
	//c3 = c1.operator+(c2);
	//c3 = operator+(&c1,c2); 加上this指针
}

运算符的重载

一个对象,编译器会给它有6个缺省函数

我们再来看下面这个问题

//我们写一个赋值运算符重载
void operator=(const Object& obj)
{
	this->value = obj.value;
}
//返回类型为void,这样不可以就不可以连等
//obja = objb = objc;
//obja = objb.operator=(objc);
//obja = operator=(&objb,objc); 返回的无类型,不能给obja赋值

且赋值函数不可以定义为const修饰

Object& operator=(const Object& obj)
{
	this->value = obj.value;
	return *this;
}
obja = objb = objc;

//改写
obja = objb.operator=(objc);
obja = operator=(&objb,objc);

obja.operator=(operator=(&objb,objc));
operator=(&obja,operator=(&objb,objc));

通过返回对象,就可以实现连等;并且我们可以通过引用返回,因为此对象的生存期并不受函数的影响,不会产生一个临时对象作为一个过度

防止自赋值
若是我们将obja给obja赋值,也就是自赋值

obja = obja
operator=(&obja,obja);

我们就需要进行一步判断

Object& operator=(const Object& obj)
{
	if(this != &obj)//防止自赋值
	{
		this->value = obj.value;
	}
	return *this;
}

上面问题解决

我们通过这段代码来看,与上面问题相同

	Object& operator=(const Object& obj)
	{
		if (this != &obj)
		{
			this->value = obj.value;
		}
		return *this;
	}

};
Object& fun(const Object& obj)
{
	int val = obj.Value() + 10;
	Object obja(val);
	return obja;
}

int main()
{
	Object objx(0);
	Object objy(0);
	objy = fun(objx);
	cout << objy.Value() << endl;
	return 0;
}

我们在这里希望通过引用返回,这里return的临时对象会构建在fun函数的栈帧中,并且在函数结束栈帧释放,随后调用赋值运算符重载,但是数值依旧是正确的

我们跟踪这个被析构对象的地址,首先我们定位在fun函数的return obja;,随后进入析构函数将我们的obja进行析构

接着运行到回到主函数进行赋值,接着进入赋值运算符重载,可以看到,这里的obj地址与已被析构的obja地址相同

可以看到这个值依旧存在,依旧可以打印给出,这是因为vs2019的特殊性质造成的;我们每次运行程序会发现每次的对象地址都在变化,逻辑地址会随机改变,被析构对象的栈帧不会被接下来的赋值运算符重载扰乱地址空间,所以即使我们引用返回的对象已经死亡依旧可以将数值正确返回

但是在vc中,我们得到的值会是随机值,这是因为vc中每次运行程序地址都不会改变,当我们从fun函数退出进入赋值语句中,就会将原本存储数据的地址扰乱,继而变成了随机值

尽管我们引用返回能够将数据正确打印,但是该对象已经死亡,这是不安全的,所以我们一定不要以引用返回对象

VS2019具有一个特点:当我们调用函数,若函数中没有定义局部变量或局部对象时,该函数基本不对栈帧进行清扫

总结

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

(0)

相关推荐

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

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

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

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

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

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

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

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

  • 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语言运算符的重载详解

    目录 写一个Add函数 为什么不用加号作为函数名 运算符的重载 上面问题解决 总结 写一个Add函数 我们先讨论下面代码,并复习前面的内容 class Complex { private: double Real, Image; public: Complex() :Real(0), Image(0) {} Complex(double r, double i) :Real(r), Image(i) {} ~Complex() {} //Complex Add(const Complex* co

  • Python的运算符重载详解

    一.前言 运算符重载:为运算符定义方法 所谓重载,就是赋予新的含义同一个运算符可以有不同的功能 二.重载作用 让自定义的实例像内建对象一样进行运算符操作让程序简介易读对自定义对象将运算符赋予新的规则 运算符和特殊方法 运算符重载 # @function:运算符重载 # @Description: 一只萤火虫 class MyInteger: """ 创建一个自定义的整数类型 """ def __init__(self, data=0): # 1.

  • C++中运算符重载详解及其作用介绍

    目录 概述 函数重载 运算符重载 C++ 的运算符 重载运算符的规则 成员函数实现 Complex 加法 运算符重载的方法 多种实现方法 实现 operator+= 三种运算符重载函数 成员函数实现 友元函数实现 输出结果 重载单元运算符 例子 重载二元运算符 例子 重载 I/O 插入运算符 << 提取运算符 >> 总结 概述 运算符重载 (Operator Overloading) 函数重载 重载: 将同一名字重新赋予新的含义. 函数重载: 对一个函数赋予新的含义, 使之实现新功

  • C++中的运算符重载详解

    目录 1.引例 2.类中自动建立的函数 3.重载赋值运算符解析 总结 1.引例 class Complex { private: double Real,Image; public: Complex():Real(0),Image(0) {} Complex(double r, double i) : Real(r),Image(i) {} ~Complex() {} }; int main() { Complex c1(1.2,2.3); Complex c2(45,56); Complex

  • Python入门教程之运算符重载详解

    目录 如何重载Python中的运算符 在 Python中重载比较运算符 重载相等和小于运算符 用于运算符重载的 Python 魔术方法或特殊函数 二元运算符 比较运算符 赋值运算符 一元运算符 运算符重载意味着赋予超出其预定义的操作含义的扩展含义.例如运算符 + 用于添加两个整数以及连接两个字符串和合并两个列表.这是可以实现的,因为 '+' 运算符被 int 类和 str 类重载.您可能已经注意到,相同的内置运算符或函数对不同类的对象显示不同的行为,这称为运算符重载. # Python 程序显示

  • 重学Go语言之运算符与控制结构详解

    目录 运算符 算术运算符 关系运算符 逻辑运算符 位运算符 赋值运算符 指针运算符 运算符的优先级 控制结构 If For Switch 小结 运算符 运算符的作用是将操作数组合成表达式,比如下面的代码中,我们通过赋值和加号组成了两个表达式: var i,j = 1,2 n := i + j Go的运算符大体分为六种:算术运算符.关系运算符.逻辑运算符.位运算符.赋值运算符和指针运算符. 算术运算符 运算符 含义 + 加号,除了用于整数,浮点数,复数外,还可以用于字符串的拼接 - 减号 * 相乘

  • C++中函数重载详解

    目录 函数重载的概念 函数重载的应用 为什么C++支持函数重载,而C语言不支持 函数重载的概念 函数重载:是函数的一种特殊情况,C++允许在同一作用域中声明几个功能类似的同名函数,这些同名函数的 形参列表(参数个数 或 类型 或 顺序)必须不同,常用来处理实现功能类似数据类型不同的问题. 函数重载的应用 1.比如以下代码,函数名一样,而参数的类型不同,在调用的时候编译器会根据传递的参数自动进行匹配. 2.在例如以下代码,我们进行编译,都可以编译成功. 3.接下来看一个有趣的现象,将上述第二个例子

  • Python入门教程之三元运算符的使用详解

    目录 使用三元运算符的简单方法 使用元组.字典和 lambda 的直接方法 三元运算符可以写成嵌套的 if-else 在三元运算符中使用打印功能 要点 三元运算符也称为条件表达式,是根据条件为真或假来评估某些内容的运算符.它在2.5 版本中被添加到 Python 中. 它只是允许在单行中测试条件,替换多行 if-else,使代码紧凑. 语法 : [on_true] if [expression] else [on_false] 使用三元运算符的简单方法 # 演示条件运算符的程序 a, b = 1

  • 基于JS脚本语言的基础语法详解

    JS脚本语言的基础语法:输出语法  alert("警告!");  confirm("确定吗?");   prompt("请输入密码");为弱类型语言: 开始时要嵌入JS代码:<script type="text/javascript"></script>: 关于写程序是需注意的基本语法: 1.所有的字符全都是英文半角的: 2.大部分情况下每条语句结束后要加分号: 3.每一块代码结束后加换行:4.程序前呼

  • C++类型转换运算符的实例详解

    C++类型转换运算符的实例详解 C++中有4个类型转换运算符,使装换过程更规范 dynamic_cast; const_cast; static_cast; reinterpret_cast; 一.dynamic_cast 该运算符我在之前的文章中已经介绍过了 http://www.jb51.net/article/123252.htm 总之,该运算符的语法如下: dynamic_cast < type-name> (expression) 如果转型失败则返回0,即空指针. 该运算符的用途是,

随机推荐