运算符重载编程基础

运算符重载编程基础

• 运算符重载的两种方法
• 定义运算符重载函数名的步骤
• 友元函数实现操作符重载的应用场景
• • 友元函数和成员函数选择方法
  • 用友元函数 重载 << >>操作符
• 友元函数重载操作符使用注意点
• • 友元函数案例vector类

例如:
//全局函数 完成 +操作符 重载
Complex operator+(Complex &c1, Complex &c2)
//类成员函数 完成 -操作符 重载
Complex operator-(Complex &c2)

运算符重载的两种方法

例如1:
//通过类成员函数完成-操作符重载
//函数声明 Complex operator-(Complex &c2)
//函数调用分析
//用类成员函数实现-运算符重载
	Complex c4 = c1 - c2;
	c4.printCom();
	//c1.operator-(c2);

例如2:
//通过全局函数方法完成+操作符重载
Complex operator+(Complex &c1, Complex &c2) //函数声明 
//函数调用分析
int main()
{
		Complex c1(1, 2), c2(3, 4);
		//Complex c31 = operator+(c1, c2);
Complex c3 = c1 + c2; 
c3.printCom();
}

例如3
//前置++操作符 用全局函数实现 
Complex& operator++(Complex &c1) 
{
	c1.a ++;   
	c1.b ++;
	return c1;  
}
//调用方法
	++c1 ; //需要写出操作符重载函数原形
	c1.printCom();

//运算符重载函数名定义
	//首先承认操作符重载是一个函数 定义函数名operator++
	//分析函数参数 根据左右操作数的个数,operator++(Complex &c1)
	//分析函数返回值 Complex& operator++(Complex &c1) 返回它自身

例如4
//4.1前置—操作符 成员函数实现
Complex& operator--()
{
	this->a--;
	this->b--;
	return *this;
}

	//4.2调用方法
		--c1;
		c1.printCom();
	//4.3前置—运算符重载函数名定义
	//c1.operator--()

例如5 
	//5.1 //后置++ 操作符 用全局函数实现
Complex operator++(Complex &c1, int) 
{
	Complex tmp = c1;
	c1.a++;
	c1.b++;
	return tmp;
}
//5.2 调用方法
c1 ++ ; //先使用 后++
//5.3 后置++运算符重载函数名定义
 Complex operator++(Complex &c1, int) //函数占位参数 和 前置++ 相区别

例如6
//6.1 后置— 操作符 用类成员函数实现
	Complex operator--(int) 
	{
		Complex tmp = *this;
		this->a--;
		this->b--;
		return tmp;
	}
//6.2 调用方法
c1 ++ ; //先使用 后++
//6.3 后置--运算符重载函数名定义
 Complex operator--(int) //函数占位参数 和 前置-- 相区别

前置和后置运算符总结

C++中通过一个占位参数来区分前置运算和后置运算

定义运算符重载函数名的步骤

全局函数、类成员函数方法实现运算符重载步骤

1. 要承认操作符重载是一个函数，写出函数名称operator+ ()
2. 根据操作数，写出函数参数
3. 根据业务，完善函数返回值(看函数是返回引用 还是指针 元素)，及实现函数业务

友元函数实现操作符重载的应用场景

友元函数和成员函数选择方法

1. 当无法修改左操作数的类时，使用全局函数进行重载
2. =, [], ()和->操作符只能通过成员函数进行重载

用友元函数 重载 << >>操作符

1. istream 和 ostream 是 C++ 的预定义流类
2. cin 是 istream 的对象，cout 是 ostream 的对象
3. 运算符 << 由ostream 重载为插入操作，用于输出基本类型数据
4. 运算符 >> 由 istream 重载为提取操作，用于输入基本类型数据
5. 用友员函数重载 << 和 >> ，输出和输入用户自定义的数据类型

用全局函数方法实现 << 操作符 
ostream& operator<<(ostream &out, Complex &c1)
{
	//out<<"12345，生活真是苦"<<endl;
	out<<c1.a<<" + "<<c1.b<<"i "<<endl;
	return out;
}
//调用方法
cout<<c1;
//链式编程支持
cout<<c1<<"abcc";
//cout.operator<<(c1).operator<<("abcd");
//函数返回值充当左值 需要返回一个引用
b）类成员函数方法无法实现 << 操作符重载
//因拿到cout这个类的源码
//cout.operator<<(c1);

友元函数重载操作符使用注意点

友员函数重载运算符常用于运算符的左右操作数类型不同的情况

其他

1. 在第一个参数需要隐式转换的情形下，使用友员函数重载运算符是正确的选择
2. 友员函数没有 this 指针，所需操作数都必须在参数表显式声明，很容易实现类型的隐式转换
3. C++中不能用友员函数重载的运算符有
   = （） ［］ －>

友元函数案例vector类

#include <iostream>
using namespace std;

//为vector类重载流插入运算符和提取运算符 
class vector
{ 
public :
	vector( int size =1 ) ;       
	~vector() ;
	int & operator[]( int i ) ;
	friend ostream & operator << ( ostream & output , vector & ) ;
	friend istream & operator >> ( istream & input, vector & ) ;
private :  
	int * v ;     
	int len ;
};

vector::vector( int size ) 
{ 
	if (size <= 0 || size > 100 )
	{ 
		cout << "The size of " << size << " is null !\n" ; abort() ;  
	}
	v = new int[ size ] ;  len = size ;
}

vector :: ~vector() 
{ 
	delete[] v ;  
	len = 0 ; 
}

int &vector::operator[]( int i ) 		
{ 
	if( i >=0 && i < len )  return v[ i ] ;
	cout << "The subscript " << i << " is outside !\n" ;  abort() ;
}
ostream & operator << ( ostream & output, vector & ary )
{ 
	for(int i = 0 ; i < ary.len ; i ++ )  
		output << ary[ i ] << "  " ;
	output << endl ;
	return output ;
}
istream & operator >> ( istream & input, vector & ary )	
{ 
	for( int i = 0 ; i < ary.len ; i ++ )  
		input >> ary[ i ] ;
	return  input ;
}

void main()
{ 
	int k ;
	cout << "Input the length of vector A :\n" ;     
	cin >> k ;
	vector A( k ) ;
	cout << "Input the elements of vector A :\n" ;     
	cin >> A ;
	cout << "Output the elements of vector A :\n" ;
	cout << A ;
	system("pause");
}