c++操作符重载、返回引用语法分析、临时对象

2023-03-26 21:06:49

操作符重载-1,成员函数(含this)

(Operator Overloading)

inline complex&
_doapl(complex* ths, const complex& r)//do assignment plus(doapl)
{	//右边复数r的实部加到左边复数ths的实部上
	ths ->re += r.re;
	ths ->im += r.im;
}
inline complex&
//将操作符 += 重载
//所有的成员函数都带有一个隐藏的参数,即使下一行括号中无this,但它也在
//complex::operator += (this, const complex& r)  
//代码的参数列中不能写出这里的this
//这里的this就是指c2,this是指针所以编译器会把c2的地址传进去
complex::operator += (const complex& r)
{
	return _doapl(this, r);
}

应用

{	//新建2个复数
	complex c1(2,1);
	complex c2(5);
	//c2=c2+c1
	c2 += c1;
}

操作符重载-2,非成员函数(无this)

例1:

inline complex
operator + (const complex& x, const complex& y)// +操作符的重载
{
	return complex(real(x) + real(y)),
					imag(x) + imag(y) );
}

inline complex
operator + (const complex& x, double y)
{
	return complex(real(x) + y, imag (x));
}

inline complex
operator + (double x, const complex& y)
{
	return complex(x + real(y), imag(y));
}

应用

{
	complex c1(2,1);
	complex c2;
	//inline complex operator + (const complex& x, const complex& y)
	c2 = c1 + c2;//复数+复数
	//inline complex operator + (const complex& x, double y)
	c2 = c1 + 5;//复数c2为c1实部+5,c2的虚部为c1虚部
	//inline complex operator + (double x, const complex& y)
	c2 = 7 + c1;//复数c2为7+c1的实部,c2的虚部为c1的虚部
}

例2:

inline bool
operator == (const complex& x,const complex& y)// ==操作符的重载
{
	return real(x) == real(y) && imag(x) == imag(y);
}
inline bool
operator == (const complex& x, double y)
{
	return real(x) == y && imag(x) == 0;
}
inline bool
operator == (double x, const complex& y)
{
	return x == real(y) && imag(y) ==0;
}

应用

{
	complex c1(2,1);
	complex c2;
	//inline bool operator == (const complex& x,const complex& y)
	cout << (c1 == c2);
	//inline bool operator == (const complex& x, double y)
	cout << (c1 == 2);
	//inline bool operator == (double x, const complex& y)
	cout << (0 == c2);
}

例3:

inline complex
conj (const complex& x)//共轭复数,全局函数(global)
{
	return complex (real(x), -imag(x));
}
#include <iostream.h>
ostream&   //返回类型为引用类型
operator << (ostream& os, const complex& x)// <<操作符的重载,全局函数
{   //返回的不是local变量,所以返回类型可以使用引用类型
	return os << '(' << real(x) << ','
			  << imag(x) << ')';
}

应用

{
	complex c1(2,1);
	//ostream& operator << (ostream& os, const complex& x)
	//第一个参数cout传递到ostream& os
	cout << conj(c1);        //(2,-1)
	cout << c1 << conj(c1);  //(2,1) (2,-1)
}

Note:
设计一个函数有两种想法
1.设计为成员函数
2.设计为全局函数


Return by reference 语法分析

传递者(例子中指c1)无需知道接收端(doapl函数的参数部分)是用什么形式接收,这就是传递引用的好处

inline complex&//声明返回引用
_doapl(complex* ths, const complex& r)//传进来的左侧参数是一个指针
{
	...
	//返回指针所指的东西,是value,接收端是接收什么不必在乎(上面声明接收引用)
	return *ths;
}
inline complex&
complex::operator += (const complex& r)
{
	return _doapl(this,r);
}

应用

{	
	complex c1(2,1);
	complex c2(5);
	//c1为传递者,接收者参数部分的complex& r
	c2 += c1;//执行函数inline complex& complex::operator +=(const complex& r){...}
	//c1先加到c2上的结果再加到c3上
	c3 += c2 += c1;
}

Class body之外的各种定义

inline double
imag(const complex& x)//imag前没有class字样,所以该函数为全局函数
{                     //参数通过引用来传递,比传值效率高
	return x.imag();
}
inline double
real(const complex& x)
{	
	return x.real();
}

应用

{
	complex c1(2,1);
	//取得复数c1的虚部和实部
	cout << imag(c1);
	cout << real(c1);
}

Temp object(临时对象) typename();

inline complex //优先考虑返回值类型为引用,这里complex为什么没有使用引用类型,因为他们返回的必定是个local object
operator + (const complex& x, const complex& y)
{   //这里实部加实部的结果(存在临时对象中)将值传递出去后自动死亡,所以这个结果(指下面两实(虚)部相加的结果)(这个结果会存到临时对象中),所以声明返回值类型不能为引用类型
    //复数是在函数complex中创建的
	return complex (real(x) + real(y)),
					imag(x) + imag(y) );
}

inline complex
operator + (const complex& x, double y)
{   //complex为类名称typename();
	return complex (real(x) + y, imag (x));
}

inline complex
operator + (double x, const complex& y)
{
	return complex (x + real(y), imag(y));
}

应用

{
	int(7);
	complex c1(2,1);
	complex c2;
	//typename();创建临时对象,参数为默认值
	complex();
	//typename();创建临时对象,参数为4,5
	complex(4,5);
	//以上创建的两个临时对象,在程序运行到本行时结束
	cout << complex(2);
}

Class body之外的各种定义

//取正
inline complex
operator + (const complex& x)//只有一个参数表面+含义为正号而不是加法
{
	return x;
}
//negate反相(取反)
inline complex
operator - (const complex& x)//这种函数绝对不可return by reference,因为其返回的必定是个local object
{	//对实部和虚部都取反
	return complex (-real(x), -imag(x));
}

应用

{
	complex c1(2,1);
	complex c2;
	cout << -c1;//将复数c1取反
	cout << +c1;//将复数c1取正
}

笔记来源:
https://www.bilibili.com/video/BV1aW411H7Xa?p=5

  • 作者:Uncertainty!!
  • 原文链接:https://aerobaticswu.blog.csdn.net/article/details/109742405
    更新时间:2023-03-26 21:06:49