530-C++运算符的重载(复数类和string类的实现,迭代器基础)

╰+哭是因爲堅強的太久メ 2022-09-10 13:22 94阅读 0赞

## C++的运算符重载 ##

使对象的运算表现得和编译器内置类型一样

template<typename T>
    T sum(T a, T b)
    {
        
    	return a+b;//a.operator+(b)
    }

如果T是编译器的内置类型的话，编译器对a+b是可以做的。  
但是如果T是我们自定义的对象类型，a和b是两个对象，对象和对象之间该怎么相加？？？编译器是不知道的。  
这里就要使用运算符的重载了。

return a+b;//a.operator+(b)

加法运算符的重载函数。

## 复数类的实现(运算符重载) ##

![在这里插入图片描述][e2a1aad157264470965d1424cf82e7ad.png]  
**这个构造函数相当于可以构造3种不同的复数对象。**

#include <iostream>
    using namespace std;
    
    class CComplex
    {
        
    public:
    	//CComplex() CComplex(20) CComplex(30, 30)
    	CComplex(int r = 0, int i = 0)
    		:mreal(r), mimage(i) {
        }
    	//指导编译器怎么做CComplex类对象的加法操作
    	//CComplex operator+(const CComplex &src)
    	//{
        
    	    //写法1： 
    		//CComplex comp;//局部对象 
    		//comp.mreal = this->mreal + src.mreal;
    		//comp.mimage = this->mimage + src.mimage;
    		//return comp;
    		//写法2： 
    		//return CComplex(this->mreal + src.mreal,
    			//this->mimage + src.mimage);//对象的优化 
    	//}
    	CComplex operator++(int)
    	{
        
    		//方法1： 
    		//CComplex comp = *this;
    		//mreal += 1;
    		//mimage += 1;
    		//return comp;
    		//方法2： 
    		return CComplex(mreal++, mimage++);
    	}
    	CComplex& operator++()
    	{
        
    		mreal += 1;
    		mimage += 1;
    		return *this;
    	}
    	void operator+=(const CComplex &src)
    	{
        
    		mreal += src.mreal;
    		mimage += src.mimage;
    	}
    	void show() {
         cout << "real:" << mreal << " image:" << mimage << endl; }
    private:
    	int mreal;//实部 
    	int mimage;//虚部 
    
        //这个全局的方法成了这个类的朋友，这个全局方法可以访问这个类的实部和虚部 
    	friend CComplex operator+(const CComplex &lhs, const CComplex &rhs);
    	friend ostream& operator<<(ostream &out, const CComplex &src);
    	friend istream& operator>>(istream &in, CComplex &src);
    };
    
    CComplex operator+(const CComplex &lhs, const CComplex &rhs)//加法的全局运算符重载 
    {
        
    	return CComplex(lhs.mreal + rhs.mreal, lhs.mimage + rhs.mimage);
    }
    
    ostream& operator<<(ostream &out, const CComplex &src)//输出是从左向右运算的 
    {
        
    	out << "mreal:" << src.mreal << " mimage:" << src.mimage << endl;
    	return out;
    }
    
    istream& operator>>(istream &in, CComplex &src)
    {
        
    	in >> src.mreal >> src.mimage;
    	return in;
    }
    int main()
    {
        
    	CComplex comp1(10, 10);
    	CComplex comp2(20, 20);
    	
    	//comp1.operator+(comp2) 加法运算符的重载函数
    	CComplex comp3 = comp1 + comp2;//左边是对象，优先调用成员方法 ，成员方法没有的话就去找全局方法 
    	comp3.show();
    	CComplex comp4 = comp1 + 20;//左边是对象，优先调用成员方法，成员方法没有的话就去找全局方法 
    	//comp1.operator+(20) int->CComplex 编译器会找有没有CComplex(int)生成1个临时对象 ，然后进行相加 
    	comp4.show();
    	//编译器做对象运算的时候，会调用对象的运算符重载函数（优先调用成员方法）；如果没有成员方法
    	//就在全局作用域找合适的运算符重载函数
    	//  我们在全局提供   ::operator+(30, comp1)  30和comp1都当做实参传进去 
    	CComplex comp5 = 30 + comp1;//30在里面必须要有趋势要做类型的转换！！！ 无法调用成员方法的加法运算符重载函数 
    	//看复数类型有没有带整型参数的构造函数来生成1个临时对象让lhs引用，就生成一个实部是30，虚部是0的临时对象 
    	comp5.show();
    
    	//CComplex operator++(int)
    	comp5 = comp1++;
    	// ++ --是单目运算符  operator++()表示前置++  operator++(int)表示后置++ 这个int只是为了区分，没有任何作用 
    	comp1.show(); 
    	comp5.show();
    	//CComplex operator++()
    	comp5 = ++comp1;
    	comp1.show();
    	comp5.show();
    
    	//void comp1.operator+=(comp2)   ::operator+=(comp1, comp2)
    	comp1 += comp2;
    	
    	//comp1.show();//对象信息的输出
    	//这个输出<<运算符重载，对象不在左边，所以不可以提供成员方法 ，所以定义成全局方法 
    	//cout ::operator<<(cout, comp1) 流对象是不断放，取东西，是变化的，不能加const  
    	//void << endl; 因为要连续输出，不能用void作为返回值 
    	//连续的输出，应该把cout返回：ostream& operator<<(ostream &out, const CComplex &src)
    	cout << comp1 << endl;
    	cin >> comp1 >> comp2;
    	cout << comp1 << comp2 << endl;
    
        return 0;
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16]  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 1]

## C++string类的实现 ##

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
这个写法的效率不好。ptmp指向new出来的内存，然后字符串拷贝，连接，当做参数传入tmp对象，tmp构造的时候又会根据传进来的指针进行判空，然后开辟内存，进行字符串拷贝，然后把这个ptmp指针delete掉，tmp是局部对象，return tmp，析构的时候又要把刚才构造时new出来的空间delete掉，2次new2次delete，太麻烦了。  
**我们应该这么做：**

String operator+(const String& lhs, const String& rhs)
    {
        
    	//char *ptmp = new char[strlen(lhs._pstr) + strlen(rhs._pstr) + 1];
    	String tmp;
    	tmp._pstr = new char[strlen(lhs._pstr) + strlen(rhs._pstr) + 1];
    	strcpy(tmp._pstr, lhs._pstr);//拷贝函数 
    	strcat(tmp._pstr, rhs._pstr);//连接函数 
    	//delete[]ptmp;
    	return tmp;
    }

这样就比刚才少了1次的new和delete操作。  
但是是临时对象，还是要进行大量的拷贝构造，优化的方法是调用右值引用构造。

**迭代器是容器类型的嵌套类。**  
我们假设有一个string对象，里面有一堆字符串，这些内容我们是看不见，因为是私有的。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 3]  
**我们想迭代string对象底层的字符串的字符，用迭代器是怎么做到的？**  
容器有一个begin方法，返回的是底层首元素的迭代器。  
it指向了字符串底层的首元素。  
容器的end方法，返回的是最后一个元素的后继位置的迭代器。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 4]  
我们只需要不断的遍历，遍历到最后一个元素，往后再走，遇到end（）迭代器，就退出。  
\++it，就是从当前元素跳到下一个元素去遍历。不需要管底层的数据结构。我们作为使用者只需要用迭代器++，不同的数据结构的差异都封装在迭代器++的重载运算符函数里面。  
对迭代器解引用，就是访问迭代器访问的底层的数据。  
![在这里插入图片描述][175f3b33ff594799b9c375fa61e7e7da.png]  
**不同容器底层的数据结构不一样，每一种容器都有自己的迭代器，设置成嵌套类型。**  
![在这里插入图片描述][9eeb0958f9f84aa39f24c5ea8ccc99fe.png]  
**迭代器用的都是前置++，因为返回的是\*this，效率比较高，不用生成临时对象。**  
**迭代器的功能：提供一种统一的方式，来透明的遍历容器，我们不需要知道底层的数据结构，都封装在迭代器的++操作里面**

#include <iostream>
    #include <string>
    //char arr[]="jkhsdkf";
    using namespace std;
    
    //自己实现一个字符串对象
    class String
    {
        
    public:
    	String(const char *p = nullptr)//构造函数 
    	{
        
    		if (p != nullptr)
    		{
        
    			_pstr = new char[strlen(p) + 1];
    			strcpy(_pstr, p);
    		}
    		else
    		{
        
    			_pstr = new char[1];
    			*_pstr = '\0';
    		}
    	}
    	~String()//析构函数 
    	{
        
    		delete[]_pstr;
    		_pstr = nullptr;
    	}
    	String(const String &str)//拷贝构造函数 
    	{
        
    		_pstr = new char[strlen(str._pstr) + 1];
    		strcpy(_pstr, str._pstr);
    	}
    	String& operator=(const String &str)//赋值函数 
    	{
        
    		if (this == &str)
    			return *this;
    
    		delete[]_pstr;
    
    		_pstr = new char[strlen(str._pstr) + 1];
    		strcpy(_pstr, str._pstr);
    		return *this;
    	}
    	bool operator>(const String &str)const
    	{
        
    		return strcmp(_pstr, str._pstr) > 0;
    	}
    	bool operator<(const String &str)const
    	{
        
    		return strcmp(_pstr, str._pstr) < 0;
    	}
    	bool operator==(const String &str)const
    	{
        
    		return strcmp(_pstr, str._pstr) == 0;
    	}
    
    	int length()const {
         return strlen(_pstr); }
    	const char* c_str()const {
         return _pstr; }
    	
    	//char ch = str6[6];  可以修改：str6[6] = '7'
    	char& operator[](int index) {
         return _pstr[index]; }
    	//char ch = str6[6];  不允许修改！str6[6] = '7'
    	const char& operator[](int index)const {
         return _pstr[index]; }
    
    	//给String字符串类型提供迭代器的实现
    	class iterator
    	{
        
    	public:
    		iterator(char *p = nullptr) :_p(p) {
        }
    		bool operator!=(const iterator &it)
    		{
        
    			return _p != it._p;
    		}
    		void operator++()
    		{
        
    			++_p;
    		}
    		char& operator*() {
         return *_p; }
    	private:
    		char *_p;
    	};
    	//下面2个方法是容器的方法哦！！！ 
    	//begin返回的是容器底层首元素的迭代器的表示
    	iterator begin() {
         return iterator(_pstr); }
    	//end返回的是容器末尾元素后继位置的迭代器的表示
    	iterator end() {
         return iterator(_pstr + length()); }
    private:
    	char *_pstr;
    
    	friend String operator+(const String &lhs, const String &rhs);
    	friend ostream& operator<<(ostream &out, const String &str);
    };
    String operator+(const String &lhs, const String &rhs)
    {
        
    	//char *ptmp = new char[strlen(lhs._pstr) + strlen(rhs._pstr) + 1];
    	String tmp;
    	tmp._pstr = new char[strlen(lhs._pstr) + strlen(rhs._pstr) + 1];
    	strcpy(tmp._pstr, lhs._pstr);//拷贝函数 
    	strcat(tmp._pstr, rhs._pstr);//连接函数 
    	//delete[]ptmp;
    	return tmp;
    }
    ostream& operator<<(ostream &out, const String &str)
    {
        
    	out << str._pstr;
    	return out;
    }
    int main()
    {
        
    	//迭代器的功能：提供一种统一的方式，来透明的遍历容器
    	String str1 = "hello world!";//str1叫容器吗？叫。因为底层放了一组char类型的字符
    	//容器的迭代器类型
    	auto it = str1.begin();
    	for (; it != str1.end(); ++it)
    	{
        
    		cout << *it << " ";
    	}
    	cout << endl;
    
    	//c++11 foreach的方式来遍历容器的内部元素的值=>底层，还是通过迭代器进行遍历的
    	for(char ch : str1)
    	{
        
    		cout << ch << " ";
    	}
    	cout << endl;
    
    	//vector allocator  提供迭代器iterator的实现
    
    	String str1;
    	String str2 = "aaa";//string(const char*)
    	String str3 = "bbb";
    	String str4 = str2 + str3;
    	String str5 = str2 + "ccc";
    	String str6 = "ddd" + str2;
    
    	cout << "str6:" << str6 << endl;
    	//bool operator>(const String &str)
    	if (str5 > str6)
    	{
        
    		cout << str5 << " > " << str6 << endl;
    	}
    	else
    	{
        
    		cout << str5 << " < " << str6 << endl;
    	}
    
    	int len = str6.length();
    	for (int i = 0; i < len; ++i)
    	{
        
    		//char& str6.operator[](i)
    		cout << str6[i] << " ";
    	}
    	cout << endl;
    
    	//string -> char*
    	char buf[1024] = {
         0 };
    	strcpy(buf, str6.c_str());//c_str()把对象管理的字符串返回成const char*类型 
    	cout << "buf:" << buf << endl;
    
    	return 0;
    }

**这2种写法等价。**  
![在这里插入图片描述][d67fe134571b41a6812b83bbbcc19f95.png]  
![在这里插入图片描述][f0282021a57d4e4c8592a2da6d2a5c1b.png]

**auto自动根据等号右边的类型推导左边的类型，写起来比较简单方便。**

[e2a1aad157264470965d1424cf82e7ad.png]: /images/20220829/e5825cfe7e594835b36a46bad87c15dd.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/7c6e734f5a5d48a9b9e9f1f68f024b01.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/337fe864aac442d6b2a982bf7594cc43.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220829/463a1ef1a2914681be614ee187c5dd28.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220829/b887f128aaa34aaf9b745e415ba3a550.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBALeael-azveWuhw_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220829/d2adf361e9d64da185398f24826fcfbb.png
[175f3b33ff594799b9c375fa61e7e7da.png]: /images/20220829/b878e092071f42afb8766a0273a7ed85.png
[9eeb0958f9f84aa39f24c5ea8ccc99fe.png]: /images/20220829/39b14b14724843619539829b8158269c.png
[d67fe134571b41a6812b83bbbcc19f95.png]: /images/20220829/9b0c7c592ccc470aa4d047d1d8d9bd16.png
[f0282021a57d4e4c8592a2da6d2a5c1b.png]: /images/20220829/e9d15948bf3c47c49fc97c9fad1a3f12.png