C++提高编程

模板

模板就说简历通用的模具，提高代码复用性

1、模板不可以直接使用，它只是一个框架

2、模板的通用并不是万能

模板机制分为两种机制：函数模板和类模板。

函数模板作用：

建立一个通用函数，起函数返回值类型和形参类型可以不制定，用一个虚拟的类型来代表

语法：

template<typename T>

函数声明或定义

解释：template --- 声明创建模板

typename --- 表明其后面的符号是一种数据类型，可以用class代替

T --- 通用的数据类型，名称可以替换，通常为大写字母

template<typename T>

template<class T>

函数模板的注意事项

模板必须确定出T的数据类型，才可以使用

template<class T> //不能推导出数据类型

void func(　){

　　cout<<"hello"<<endl;//执行错误。

}

void test02()[

func();//错误

func<int>();

1、自动类型推导，必须推导出一致的数据类型T才可以使用

2、模板必须确定出T的数据类型，才可以使用

函数模板案例

案例：

1、利用函数模板封装成一个排序函数，可以对不同数据类型数组进行排序

2、排序规则从大到小，排序算法为选择排序

3、分别利用char数组和int数组进行测试

普通函数与函数模板的区别：

1、普通函数调用时可以发生自动类型转换（隐式类型转换）

2、普通模板调用时，如果利用自动类型推导，不会发生隐式类型转换

3、如果利用显示指定类型的方式，可以发生隐式的类型转换。

myfunc<int>(a,c);

普通函数与函数模板的调用规则：

1、如果函数模板和普通函数都可以实现，优先调用普通函数。

2、可以通过空模板参数列表来强制调用函数模板 myfunc<>();

3、函数模板也可以发生重载

4、如果函数模板可以产生更好的匹配，优先调用函数模板。如

template <typename T>
void ChoSort(T a,T b) {
cout << "调用函数模板" << endl;
}

void ChoSort(int a,int b){
cout << "调用普通函数" << endl;
}

编译器不做隐私转换。

总结：既然提供了函数模板，最好不要提供普通函数，否则会出现二义性。

模板的局限性

局限性：

模板的通用性并不是万能的

//对比两个数据是否相等。
template<class T>
bool myCompare(T &a, T &b) {
if (a == b) {
return true;
}
else {
return false;
}
}

具体化的模板，针对于自定义数据类型

template<> bool myCompare(Person &p1, Person &p2) {
if (p1.age == p2.age&&p1.name == p2.name) {
return true;
}
else {
return false;
}
}

总结：

1、利用具体化的模板，可以解决自定义类型的通用化

2、学习模板并不是为了些模板，而是在STL能够运用系统的模板

类模板

语法：

template <typename T>

类模板和函数模板的区别：

1、类模板没有自动推导的使用方式

Person<string, int> p1("孙悟空", 99);//只能用显示指定类型。

2、类模板在模板参数列表中可以有默认参数

template<class NameType,class AgeType=int>

类模板成员函数创建时机

类模板对象做函数参数

1、指定传入的类型 --- 直接显示对象的数据类型

2、参数模板化 --- 将对象中的参数变为模板进行传递

3、整个类模板化 --- 将这个对象类型模板化进行传递

//1、指定传入类型
void printPerson1(Person<string, int> &p) {
p.showPerson();
}
//2、参数模板化
template<class T1,class T2>
void printPerson2(Person<T1, T2> &p) {
p.showPerson();
cout << "T1的类型为：" << typeid(T1).name() << endl;
cout << "T2的类型为：" << typeid(T2).name() << endl;
}

void test01() {
Person<string, int>p("孙悟空", 200);
printPerson2(p);
}
//3、整个类模板化
template<class T>
void printPerson(T &p) {
p.showPerson();
cout << "T的数据类型为：" << typeid(T).name() << endl;
}

类模板和继承

当类模板碰到继承，需要注意一下几点：

1、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型。

2、如果不指定，编译器无法给子类分配内存。

3、如果想灵活指定出父类中T的类型，子类也需要变为类模板。

总结如果父类是类模板，子类需要指定出父类中T的数据类型。

//类成员函数的类外实现
template<class T1,class T2>
class Person {
public:
Person(T1 name, T2 age);// {
// this->m_Name = name;
// this->m_Age = age;
//}

void showPerson();/* {
cout << this->m_Name << this->m_Age << endl;
}*/
T1 m_Name;
T2 m_Age;
};

//构造函数的类外实现
template<class T1, class T2>
Person<T1,T2>::Person(T1 name, T2 age) {
this->m_Age = age;
this->m_Name = name;
}

//成员函数的类外实现
template<class T1, class T2>
void Person<T1,T2>::showPerson() {
cout << "类内函数" << endl;
}
//总结：类模板中成员函数在类外实现时，需要加上模板的参数列表
void test() {
Person<string, int> P("tom", 20);
P.showPerson();
}

类模板分文件编写

问题：类模板中成员函数创建时机是在调用阶段，导致部份文件编写时链接不到。

解决：1、直接包含cpp源文件，2、将声明和实现写到同一个文件中，并更改后缀名为.hpp,hpp是约定的名称，并不是强制。（第二种包含源文件.cpp .cpp中包含了头文件.h ）

类模板与友元

全局函数类内实现-直接在类内声明友元即可

全局函数类外实现-需要提前在编译器知道全局函数的存在

类模板案例

template<class T>
class MyArray {
private:
T *pAddress;//指针指向堆区开辟的真实数组
int m_Capacity;//数组容量
int m_Size;//数组大小
public:
//有参构造
MyArray(int capacity) {
this->m_Capacity = capacity;
this->m_Size = 0;
this->pAddress = new T[this->m_Capacity];
cout << "myArray有参构造" << endl;
}
//拷贝构造
MyArray(const MyArray& arr) {
cout << "myArray拷贝构造" << endl;
this->m_Capacity = arr.m_Capacity;
this->m_Size = arr.m_Size;
//深拷贝
this->pAddress = new T[arr.m_Capacity];
//将原array数据拷贝到现在数组中
for (int i = 0; i < this->m_Size; i++) {
pAddress[i] = arr.pAddress[i];
}
}
//operator= 防止浅拷贝问题a=b=c
MyArray& operator=(const MyArray& arr) {
//先判断原来堆区是否有数据
//如果有限释放
if (this->pAddress != NULL) {
delete[] this->pAddress;
this->pAddress = NULL;
this->m_Capacity = 0;
this->m_Size = 0;
}
//深拷贝
this->m_Capacity = arr.m_Capacity;
this->m_Size = arr.m_Size;
this->pAddress = new T[arr.m_Capacity];
for (int i = 0; i < this->m_Size; i++) {
this->pAddress[i] = arr.pAddress[i];
}
return *this;
}

//析构函数
~MyArray() {
cout << "myArray析构构造" << endl;
if (pAddress != NULL) {
delete[] this->pAddress;
this->pAddress = NULL;
}
}
};

STL基本概念

STL（standardtemplate library，标准模板库）

STL从广义上分为：容器container算法algorithm迭代器iterator

容器和算法之间通过迭代器无缝连接

STL几乎所有的代码都采用了模板类或者模板函数

STL六大组件

STL大体分为六大组件，分别为：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

1、容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据

2、算法：各种常用的算法，如sort、find、copy、for_each等

3、迭代器：扮演了容器与算法之间的胶合剂

4、仿函数：行为类似函数，可作为算法的某种策略

5、适配器：一种用来修饰容器或者仿函数或迭代器接口的东西

6、空间配置器：负责空间的配置与管理

容器分为了：

1、序列式容器：强调值的排序，序列式容器中每个元素都有固定的位置 1 3 5 4 2

2、关联式容器：二叉树结构，各元素之间没有严格的物理上的顺序关系 1 2 3 4 5

算法分为：质变算法和非质变算法

质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换、删除

非质变算法：是指运算过程中不会更改区间内的元素的内容。例如查找、计数、寻找极值

迭代器：容器和算法之间的迭代器

提供一种方法，使之能够依序寻访某个容器所含的各个元素，而无需暴露该容器的内部表示方法

每个容器都有自己专属的迭代器。

Vector存放内置数据类型

容器：vector

算法：for_each

迭代器：vector<int>::iterator

示例：

//vector容器中存放自定义数据类型
class Person {
public:
Person(string name, int age) {
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};

//存放自定义数据类型

void test01() {
vector<Person> v;
Person p1("aaa",10);
Person p2("bbb",10);
Person p3("ccc",10);
Person p4("ddd",10);
Person p5("eee",10);
Person p6("fff",10);
//向容器中添加数据
v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);
v.push_back(p5);
v.push_back(p6);
//遍历容器中的数据
for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
cout << "姓名："<<(*it).m_Name << endl;
cout << "姓名："<<it->m_Name << endl;
cout << "年龄："<<(*it).m_Age << endl;
cout << "年龄："<<it->m_Age << endl;
}
}

int main() {
test01();
}

嵌套容器

void test01() {
vector<vector<int>> v;
//创建小容器
vector<int>v1;
vector<int>v2;
vector<int>v3;
vector<int>v4;
//向小容器中添加数据
for (int i = 0; i < 4; i++) {
v1.push_back(i + 1);
v2.push_back(i + 2);
v3.push_back(i + 3);
v4.push_back(i + 4);
}
//将小容器中插入到大的容器中
v.push_back(v1);
v.push_back(v2);
v.push_back(v3);
v.push_back(v4);
//通过大容器，把所有的数据遍历一次。
for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++) {
for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++) {
cout << *vit << " ";
}
cout << endl;
}
}

String基本概念

string和char*的区别

char*是一个指针

string 是一个类，类的内部封装了char*,来管理这个字符串，是一个char*型的容器

特点

string类内部封装了很多方法

查找fInd、拷贝copy,删除delete替换replace，插入insert

string管理char*所分配的内存，不用担心复制越界和取值越界，由类内部进行负责。

string构造函数

构造函数原型

string();//创建一个空的字符串例如string str;

string(const char* s);//使用字符串S初始化

string(const string& str);//使用一个string对象初始化另一个string对象

string(int n,char c);使用n个字符c初始化

总结：灵活运用，没有可比性。

void test04() {
string s1;//默认构造
const char *str = "hello world";
string s2(str);
cout << "s2=" << s2 << endl;
string s3(10, 'a');
cout << "s4=" << s3 << endl;

}

字符串拼接

str3.append(str2,0,2); //0是起始，2是长度参数2是从那个位置开始截，参数3是截取的个数

字符串查找

rfind和find区别

rfind从右往左

find是从做往右

字符串比较大小

string字符存取

可以修改。

string插入和删除

string字串

Vector

void printVector(vector<int> &v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout << *it << " ";
}
cout << endl;
}

//复制string
void test04() {
vector<int>v1;//默认构造无参构造
for (int i = 0; i < 10; i++) {
v1.push_back(i);
}
printVector(v1);
//通过区间方式构造
vector<int> v2(v1.begin(), v1.end());
printVector(v2);

//n个elem方式构造
vector<int> v3(10, 100);//第一个参数是个数第二个是元素
printVector(v3);

//拷贝构造
vector<int> v4(v3);
printVector(v4);
}

//vector赋值
void test04() {
vector<int> v1;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
}
printVector(v1);
if (v1.empty()) {//为真代表容器为空
cout << "v1为空" << endl;
}
else {
cout << "v1不为空" << endl;
}
cout << "v1的容量:" << v1.capacity() << endl;//容量都大于等于size
cout << "v1的容量:" << v1.size() << endl;
v1.resize(15);//如果重新制定的比原来的长了，用0来进行填充新的位置。
v1.resize(15, 10);//用10来填充
v1.resize(5);//比原来短了，超出部分被删除

printVector(v1);
}

vector插入和删除

void test04() {
vector<int> v1;
v1.push_back(5);//尾插
v1.push_back(5);//尾插
v1.push_back(5);//尾插
v1.push_back(5);//尾插
v1.push_back(5);//尾插
printVector(v1);
v1.pop_back();//尾删
printVector(v1);

//插入第一个参数是迭代器
v1.insert(v1.begin(), 100);//在第一个位置插入100
printVector(v1);
//删除第一个参数也是迭代器
v1.erase(v1.begin());//删除第一个元素
printVector(v1);

v1.erase(v1.begin(), v1.end());//从头清空到尾
v1.clear();//全部清空
printVector(v1);

}

Vector数据存取

for (int i = 0; i < v1.size(); i++) {
cout << v1[i] << " "<< v1.at(i) <<endl;
}
cout << "获取第一个元素" << v1.front()<<endl;
cout << "获取最后一个元素" << v1.back()<<endl;

vector互换容器

将vec与本身互换。

reserve vector预留函数

v1.reserve(10000);

总结：如果数据量较大的时候，可以一开始利用reserve预留空间

deque容器基本概念

功能：双端数组，可以对头端进行插入删除操作。

deque与vector区别
1、vector对于头部的插入删除效率低，数据量越大，效率越低。

2、deque相对而言，对头部插入删除的速度比vector更快

3、vector访问元素时的速度会比deque快，这和两者内部实现有关