c++（四）

运算符重载
- 可重载的运算符
- 不可重载的运算符
- 运算符重载的格式
- 运算符重载的方式
- - 友元函数进行运算符重载
  - 成员函数进行运算符重载
模板
- 定义的格式
- 函数模板
- 类模板
标准模板库
- vector向量容器
- STL中的list
- map向量容器

运算符重载

运算符相似，运算符相同，操作数不同，与返回值无关的一组函数
目的：让参与运算的数据类型更多样化—>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;//获取第二个位置的iteratorit = ++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;//删除某一位置上的元素//获取第二个位置的iteratorit = ++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;
}