C++ 提高编程

参考笔记：https://blog.csdn.net/ClaireSy/article/details/108423061

视频：https://www.bilibili.com/video/BV1et411b73Z

1. 模板
2. string 
3. vector
4. deque
5. stack
6. queue
7. list
8. set /multiset
9. map /multimap

一、模板

C++ 除了面向对象编程外，还有一种编程思想为泛型编程

模板的作用：建立通用函数，返回类型与参数类型都不指定，用虚拟的类型代表

语法

template <typename T>

#include<iostream>
using namespace std;

template<typename T>
void swapNumber(T &a, T &b) {
    T temp = a;
    a = b;
    b = temp;
}

int main() {
    int a = 10;
    int b = 20;
    //1.隐士类型转换
    //swapNumber(a,b);

    //2.显示类型指定
    swapNumber<int>(a, b);
    cout << a << endl;
    cout << b << endl;
    return 0;
}

普通函数可以发生隐式类型转换 

函数模板自动类型推导不会发生隐式类型转换，但是显示指定类型可以发生隐士类型转换

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

1. 普通函数与函数模板都可以调用，优先调用普通函数
2. 可以通过空模板参数列表强制调用函数模板
3. 函数模板可以发生函数重载
4. 如果函数模板有更好的匹配，优先调用函数模板

类模板：类模板没有自动类型推导，类模板参数列表可以有默认参数

定义: template<T>  类

类模板成员函数的创建时机1

类模板成员函数在调用时才创建

备注：

typeid（） 获取指定数据的类型 

climit 头文件包含数据类型的极值

类模板与继承

子类继承父类，如果父类是类模板，那么需要指定父类的模板类型

 二、string

string 本质上是一个类，内部维护了一个 char *

string 赋值可以通过 = 或者 assign  

string 字符串拼接 ， 通过 += 或者 appent

查找与替换  find  rfind ,区别是find 从左往右边查，rfind 从右往左查询 。replace ,替换，可以将指定位置的字符替换为目标字符串

string 字符串比较 compare ，相等为0 ，逐个字符比较

string 内部重载了 [] , 也可以通过 at 访问单个字符

字符串插入与删除  insert  ，erase 删除 ，下标都是从 0 开始计数

子串，substr ，指定开始位置与长度，截取子串

三、vector 容器

特点：

Vector 数据结构和数组非常相似，称为单端数组

vector 可以动态扩展

使用需要包含头文件 <vector>

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

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

int main() {

    vector<int> v1;
    for (int i = 0; i < 10; i++) {
        v1.push_back(i);
    }
    printVector(v1);
    return 0;
}

四、deque

使用需要先包含头文件 <deque>

双端数组，可以对头端与尾端进行操作

deque 内部工作原理：

deque 内部有个中控器，维护每端缓冲区的地址

deque 容器的迭代器也支持随机访问

deque 没有容量的概念，可以无限扩大

算法头文件 <algorithm> ,可以使用 sort 排序 ，支持随机访问的容器都可以通过 sort 进行排序

rand() 可以获取随机数， 伪随机，

rand((unsigned int)time(null))

void printDeque(deque<int> &d) {
    for (deque<int>::iterator it = d.begin(); it != d.end(); it++) {
        cout << *it << " ";
    }
}

void printDeque2(const deque<int>& d) {
    for (deque<int>::const_iterator  it = d.begin(); it != d.end(); it++) {
        cout << *it << " ";
    }
}

int main() {
    deque<int>d;
    d.push_front(10);
    d.push_front(20);
    d.push_back(30);
    d.push_back(40);
    cout << d.size() <<endl;
    printDeque2(d);
    return 0;
}

五、stack 

 栈容器 stack ,是一种 先进后出 FILO 的数据结构，栈不允许有遍历的行为，每次只能访问栈顶元素

#include<iostream>
#include<stack>
int main04() {
    using namespace std;
    stack<int>s;
    s.push(10);
    s.push(20);
    s.push(30);
    s.push(40);
    cout << s.size() << endl;
    while (!s.empty()) {
        cout << s.top() << endl;
        s.pop();
    }
    return 0;
}

 STL 中使用栈，需要包含头文件 <stack>

六、queue

队列，是一种先进先出的数据结构 FIFO，一端只能进数据，一端只能出数据。访问数据也只能访问2端的数据

#include<iostream>
#include<queue>
int main05() {
    using namespace std;

    queue<int>q;
    q.push(10);
    q.push(20);
    q.push(30);
    q.push(40);
    cout << q.size() << endl;
    while (!q.empty()) {
        cout << q.front() << endl;
        q.pop();
    }
    return 0;
}

 七、list

功能：将数据进行链式存储

链表：是一种物理上存储非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针实现的

#include<iostream>
#include<list>
#include<algorithm>
using namespace std;
int main() {

    list<int> in;
    in.push_back(50);
    in.push_back(10);
    in.push_back(20);
    in.push_back(30);
    in.push_back(40);
    in.sort();
    in.reverse();
    for (list<int>::iterator it = in.begin(); it != in.end(); it++) {
        cout << *it<<endl;
    }
    //sort(); 标准算法的排序只能够随机访问的数据结构
    return 0;
}

 八、set /multiset

包含头文件 <set>

set 容器，不允许存储重复的元素 multiset 允许插入重复的元素

set 容器特点

1. 容器元素插入会自动排序
2. 不允许插入重复元素

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

class MyCompare {
public:
    bool operator()(int a,int b)const {
        return a > b;
    }
};

int main() {
    
    set<int, MyCompare> s;
    s.insert(10);
    s.insert(40);
    s.insert(20);
    s.insert(30);
    s.insert(50);

    for (set<int, MyCompare>::iterator it = s.begin(); it != s.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
    return 0;
}

在 visio studio 下编译会报错，需要在仿函数中加入 const

九、map / multimap

包含头文件 <map>

map 中所有的元素都是 pair(对组)

所有的元素都会根据元素的键自动排序

map 与 multimap 区别是key 值是否允许重复

队组： pair<int,int>(1,10) ,make_pair(1,20)

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

class Mycompare {
public:
    bool operator()(int x,int y)const {
        return x > y;
    }
};

int main() {
    map<int, int, Mycompare>m;
    m.insert(make_pair(1, 10));
    m.insert(make_pair(2, 20));
    m.insert(make_pair(3, 30));
    m.insert(make_pair(4, 40));

    for (map<int, int, Mycompare>::iterator it = m.begin(); it != m.end(); it++) {
        cout << it->first << "," << it->second << endl;
    }
    return 0;
}

十