c++（四）

运算符重载

运算符相似，运算符相同，操作数不同，与返回值无关的一组函数
目的：让参与运算的数据类型更多样化—>c++可拓展性的体现

可重载的运算符

不可重载的运算符

运算符重载的格式

运算符重载的方式

友元函数进行运算符重载

案例1：复数 a+bi

#include <iostream>
using namespace std;
class CComplex
{
public:
	CComplex(int rear = 2, int img = 3) :rear(rear), img(img)
	{
	cout << "CComplex(int,int)" << endl;
	}
	~CComplex()
	{
	cout << "~CComplex()" << endl;
	cout << this << endl;
	}
	void show()
	{
	cout << this->rear << "+" << this->img << "*i" << endl;
	}
	friend CComplex operator+(CComplex& obj1, CComplex& obj2);
private:
	int rear;//实部
	int img;//虚部
};
CComplex operator+(CComplex& obj1, CComplex& obj2)
{
	CComplex obj3;
	cout << &obj3 << endl;
	obj3.rear = obj1.rear + obj2.rear;
	obj3.img = obj1.img + obj2.img;
	return obj3;
}
int main()
{
	CComplex c1(1,2);
	cout << &c1 << endl;
	CComplex c2(2,3);
	cout << &c2 << endl;
	//Complex c3 = c1 + c2;//隐式调用
	CComplex c3 = operator+(c1, c2);//显示调用
	cout << &c3 << endl;
	c3.show();
	return 0;
}

案例2：重载前置++

#include <iostream>
using namespace std;
//使用友元函数实现++符号的自增
class CComplex
{
public:
	CComplex(int rear = 1, int img = 1);
	~CComplex();
	void show();
	friend void operator++ (CComplex& demo);
private:
	int rear;
	int img;
};
CComplex::CComplex(int rear, int img)
{
	this->rear = rear;
	this->img = img;
	cout << "构造" << endl;
}
CComplex::~CComplex()
{
	cout << "析构" << endl;
}
void CComplex::show()
{
	cout << this->rear << "+" << this->img << "*i" << endl;
}
void operator++ (CComplex& demo)
{
	++demo.rear;
	++demo.img;
}
int main()
{
	CComplex c1(2,3);
	//++c1;//隐式调用
	operator++(c1);
	c1.show();
}

成员函数进行运算符重载

案例1：重载前置++，后置++

#include <iostream>
using namespace std;
//使用成员函数实现++符号的自增，后++
class CComplex
{
public:
	CComplex(int rear = 1, int img = 1);
	~CComplex();
	void show();
	CComplex& operator++ ();
	CComplex& operator++(int n);
private:
	int rear;
	int img;
};
CComplex::CComplex(int rear, int img)
{
	this->rear = rear;
	this->img = img;
	cout << "构造" << endl;
}
CComplex::~CComplex()
{
	cout << "析构" << endl;
}
void CComplex::show()
{
	cout << this->rear << "+" << this->img << "*i" << endl;
}
CComplex& CComplex::operator++ ()
{
	++this->rear;
	++this->img;
	return *this;
}
CComplex& CComplex::operator++(int n)
{
	CComplex temp = *this;
	this->rear++;
	this->img++;
	return temp;
}
int main()
{
	CComplex c1(2, 3);
	//++c1;//隐式调用
	c1.operator++();//显示调用
	c1.show();

	CComplex c2(3, 4);
	c2.operator++(1).show();
	c2.show();
}

总结：
<1>友元重载参数要比成员重载的参数多一个,因为成员函数默认有一个this指针
<2>并不是所有的运算符都可以通过友元或者成员重载

cin >> 变量;//只能通过友元函数进行重载

#include <iostream>
using namespace std;
//重载cin，实现可以输入对象
class CComplex
{
private:
	int rear;
	int img;
public:
	void show();
	friend CComplex& operator >> (istream& tmp, CComplex& c1);
protected:
};

void CComplex::show()
{
	cout << this->rear << "+" << this->img << "*i" << endl;
}
CComplex& operator>>(istream& tmp, CComplex& c1)
{
	cout << "rear:" << endl;
	tmp >> c1.rear;
	cout << "img:" << endl;
	tmp >> c1.img;
	return c1;
}

int main()
{
	CComplex c1;
	cin >> c1;
	c1.show();
}

模板

• 模板是支持参数化多态的工具，就是让类或者函数声明为一种通用类型，使得类中的某些数据成员或者成员函数的参数、返回值在实际使用时可以是任意类型
• 减少代码冗余，提高开发效率

定义的格式

template<class/typename T>
返回值类型 函数名(参数列表)
{
;
}

函数模板

• 函数模板是真正的函数吗？不是
• 什么时候才能变成真正的函数呢？
  

#include <iostream>
using namespace std;
template<typename T>
T MAX(T a, T b) //不占内存空间
{
	return a > b ? a : b;
}
int main()
{
	//实例化模板
	cout << MAX<int>(1, 2) << endl;
	cout << MAX<string>("hello", "c++");
	cout << MAX<int>(3, 4) << endl;//类型相同的模板函数只会生成一次
	return 0;
}

总结：
<1>调用函数时，将模板的数据类型具体化的时候，才会变成真正的函数，此时占内存空间，称为模板
函数
<2>类型相同的模板函数只会生成一次
<3>函数模板可以重载

案例：用模板实现数组的输出

#include <iostream>
using namespace std;
//模板实现数组的输出
template<typename T>
void output(T arr[],int n)
{
	int i;
	for (i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}

int main()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	int length = sizeof(arr) / sizeof(int);
	output<int>(arr, length);

	string brr[] = { "hello", "c++" };
	length = sizeof(brr) / sizeof(string);
	output<string>(brr, length);

	char crr[] = { 'a', 'b', 'c'};
	length = sizeof(crr) / sizeof(char);
	output<char>(crr, length);

	
	return 0;
}

类模板

实现：链表：带头节点的单向不循环列表
<1>节点类（数据域、指针域）
<2>链表的类(增（尾插法）、删、改、查)、头结点

#include <iostream>
using namespace std;
//结点
class linkNode
{
public:
	int data;
	linkNode* next;
	//构造
	linkNode();
	//析构
	~linkNode();
protected:
};
//操作
class Handle
{
private:
	linkNode* head;
public:
	//构造
	Handle();
	//析构
	~Handle();
	//插入（尾插）
	void insert(int data);
	//查
	void search();

protected:
};


linkNode::linkNode()
{
	this->data = 0;
	this->next = nullptr;
	cout << "构造" << endl;
}
linkNode::~linkNode()
{
	cout << "析构" << endl;
}
Handle::Handle()
{
	this->head = new linkNode;
}
Handle::~Handle()
{
	
}
void Handle::insert(int data)
{
	 //创建一个新结点
	linkNode* pNew = new linkNode;
	//赋值
	pNew->data = data;
	//找尾结点
	linkNode* pFind = this->head;
	while (pFind->next != nullptr)
	{
		pFind = pFind->next;
	}
	//插入
	pFind->next = pNew;
}
void Handle::search()
{
	linkNode* pFind = this->head->next;
	if (pFind == nullptr)
	{
		return;
	}
	while (pFind != nullptr)
	{
		cout << pFind->data << " ";
		pFind = pFind->next;
	}
	cout << endl;
}


int main()
{
	Handle han;
	han.insert(10);
	han.insert(20);
	han.insert(30);

	han.search();
	return 0;
}

类模板：

#include <iostream>
using namespace std;
template <typename T>
//结点
class linkNode
{
public:
	T data;
	linkNode<T>* next;
	//构造
	linkNode();
	//析构
	~linkNode();
protected:
};
//操作
template <typename T>
class Handle
{
private:
	linkNode<T>* head;
public:
	//构造
	Handle();
	//析构
	~Handle();
	//插入（尾插）
	void insert(T data);
	//查
	void search();

protected:
};

template <typename T>
linkNode<T>::linkNode()
{
	//this->data = 0;
	this->next = nullptr;
	cout << "构造" << endl;
}
template <typename T>
linkNode<T>::~linkNode()
{
	cout << "析构" << endl;
}
template <typename T>
Handle<T>::Handle()
{
	this->head = new linkNode<T>;
}
template <typename T>
Handle<T>::~Handle()
{

}
template <typename T>
void Handle<T>::insert(T data)
{
	//创建一个新结点
	linkNode<T>* pNew = new linkNode<T>;
	//赋值
	pNew->data = data;
	//找尾结点
	linkNode<T>* pFind = this->head;
	while (pFind->next != nullptr)
	{
		pFind = pFind->next;
	}
	//插入
	pFind->next = pNew;
}
template <typename T>
void Handle<T>::search()
{
	linkNode<T>* pFind = this->head->next;
	if (pFind == nullptr)
	{
		return;
	}
	while (pFind != nullptr)
	{
		cout << pFind->data << " ";
		pFind = pFind->next;
	}
	cout << endl;
}


int main()
{
	Handle<int> han;
	han.insert(10);
	han.insert(20);
	han.insert(30);

	han.search();

	Handle<string> han2;
	han2.insert("hello");
	han2.insert("c++");
	han2.search();
	return 0;
}

总结：
<1>类模板中使用一个或多个虚拟类型作为其成员数据类型的时候
<2>类模板不能分文件实现

标准模板库

即标准模板库，惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和DavidR Musser在惠普实验室工作时所开发出来的。STL主要是一些“容器”的集合，这些“容器”有list、vector、set、map，等等，STL也是算法和其他一些组件的集合，是世界上顶级C++程序员多年的杰作，是泛型编程的一个经典范例。

STL可分为六个部分：
容器(containers)
迭代器(iterators)
空间配置器(allocator)
配接器(adapters)
算法(algorithms)
仿函数(functors)

容器(containers)//类模板
特殊的数据结构，实现了数组、链表、队列、等等，实质是模板类
迭代器(iterators)//对象指针
一种复杂的指针，可以通过其读写容器中的对象，实质是运算符重载
算法(algorithms)//对象的操作
读写容器对象的逻辑算法：排序、遍历、查找、等等，实质是模板函数
空间配置器(allocator)
容器的空间配置管理的模板类
配接器(adapters)
用来修饰容器、仿函数、迭代器接口
仿函数(functors)
类似函数，通过重载（）运算符来模拟函数行为的类
组件间的关系
container（容器） 通过 allocator（配置器） 取得数据储存空间，algorithm（算法）通过iterator（迭代器）存取 container（容器） 内容，functor（仿函数） 可以协助 algorithm（算法） 完成不同的策略变化，adapter（配接器） 可以修饰或套接 functor（仿函数)

vector向量容器

底层实现：数组
特点：<1>地址连续
<2>a、通过索引的方式去访问 b、通过迭代器访问
<3>访问方便
<4>插入、删除需要移动元素，不方便
<5>大小不固定
本质：vector是对数组的封装

#include <iostream>
#include <vector>
using namespace std;
/*
* 类似于数组
* 地址连续，可以使用索引访问，也可以使用迭代器访问，查询方便，增加和删除不方便，大小不固定
*/


int main()
{
	//实例化vector类模板
	vector<string> list_vect;
	//增加元素
	//void push_back(const T& x)在容器的末尾插入一个元素
	list_vect.push_back("hello");
	list_vect.push_back("world");
	list_vect.push_back("c++");
	//访问
	//使用索引方式
	//size_type size() const;用来返回容器中元素个数
	for (int i = 0; i < list_vect.size(); i++)
	{
		//const_reference at ( size_type n ) const;获取容器某个位置上的元素值
		cout << list_vect.at(i) << " ";
	}
	cout << endl;

	//使用迭代器访问
	vector<string>::iterator it;
	//获取第二个位置的iterator
	it = ++list_vect.begin();
	//在某位置上增加元素
	list_vect.insert(it, "hahaha");
	//iterator begin()返回第一个元素的迭代器
	//iterator end()返回最后一个元素的下一个位置的迭代器
	for (it = list_vect.begin(); it < list_vect.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;


	//删除某一位置上的元素
	//获取第二个位置的iterator
	it = ++list_vect.begin();
	list_vect.erase(it);
	for (it = list_vect.begin(); it < list_vect.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;

	//修改第二个位置的值
	/*it = ++list_vect.begin();
	list_vect.erase(it);
	it = ++list_vect.begin();
	list_vect.insert(it, "hahaha");*/

	list_vect.at(1) = "hahaha";
	for (it = list_vect.begin(); it < list_vect.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	
	return 0;
}

STL中的list

底层结构：双向链表
特点：
<1>内存中的地址是不连续–>不能通过索引的方式去访问–>访问效率没有vector高
<2>频繁的插入、删除不需要移动元素，效率比vector

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

class Stu
{
public:
	Stu(int sno = 1, string name = "张三") :sno(sno), name(name)
	{
		cout << "构造" << endl;
	}
	~Stu()
	{
		cout << "析构" << endl;
	}
	void show()
	{
		cout << "学号：" << this->sno << ",姓名：" << this->name << endl;
	}
private:
	int sno;
	string name;
protected:
};
void showList(list<Stu>& list_s)
{
	list<Stu>::iterator it;
	for (it = list_s.begin(); it != list_s.end(); it++)
	{
		it->show();
	}
}

int main()
{
	//实例化类模板
	list<Stu> list_s;
	//插入
	//void push_back ( const T& x );在列表的末尾插入一个元素
	list_s.push_back(Stu());
	//void push_front ( const T& x );在列表的头部插入一个元素
	list_s.push_front(Stu(2, "李四"));
	//iterator insert ( iterator position, const T& x ); 在列表的指定位置插入一个元素
	list<Stu>::iterator it;
	it = ++list_s.begin();//获取第二个位置
	list_s.insert(it, Stu(3, "王五"));

	//查看，只能以迭代器的方式
	/*for (it = list_s.begin(); it != list_s.end(); it++)
	{
		it->show();
	}*/
	showList(list_s);

	//删除
	//iterator erase ( iterator position );删除某个位置的元素
	//it = ++list_s.begin();//获取第二个位置
	it = list_s.begin();
	advance(it, 1);
	list_s.erase(it);
	//查看，只能以迭代器的方式
	/*for (it = list_s.begin(); it != list_s.end(); it++)
	{
		it->show();
	}*/
	showList(list_s);
	//修改
	it = ++list_s.begin();//获取第二个位置
	list_s.erase(it);
	it = ++list_s.begin();//获取第二个位置
	list_s.insert(it, Stu(3, "王五"));
	//查看，只能以迭代器的方式
	/*for (it = list_s.begin(); it != list_s.end(); it++)
	{
		it->show();
	}*/
	showList(list_s);

	return 0;
}

map向量容器

底层结构：红黑树—>二叉树的一种
以键值对的形式存储
key—>value，key值是唯一的
特点：
<1>查找的速度特别快
<2>自动按照从小到大的顺序去排序
应用场景：频繁的查找

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

class Stu
{
public:
	Stu(int sno = 1, string name = "张三") :sno(sno), name(name)
	{
		cout << "构造" << endl;
	}
	~Stu()
	{
		cout << "析构" << endl;
	}
	void show()
	{
		cout << "学号：" << this->sno << ",姓名：" << this->name << endl;
	}
	void setname(string name)
	{
		this->name = name;
	}
	
private:
	int sno;
	string name;
protected:
};
void showList(map<int, Stu*> mymap)
{
	map<int, Stu*>::iterator it;
	for (it = mymap.begin(); it != mymap.end(); it++)
	{
		cout << "key:" << it->first << " ";
		it->second->show();
	}
	cout << endl;
}

int main()
{
	//实例化类模板
	map<int, Stu*> mymap;
	map<int, Stu*>::iterator it;
	//插入
	Stu stu1;
	mymap.insert(pair<int, Stu*>(2, &stu1));
	it = mymap.begin();
	Stu stu2(2, "王五");
	mymap.insert(it, pair<int, Stu*>(1, &stu2));
	Stu stu3(3, "李四");
	mymap.insert(pair<int, Stu*>(3, &stu3));
	showList(mymap);

	//删除
	mymap.erase(2);
	showList(mymap);

	//修改
	it = mymap.find(1);
	if (it != mymap.end())
	{
		(*it).second->setname("刘六");
	}

	showList(mymap);

	return 0;
}