C++学习笔记 入门篇-7

前言

本系列内容为程序媛学习C++时做的笔记。以代码为主，并备注了打印结果以及详尽的解释注释。希望对你有所帮助。

Vector

vector : 向量 容器 （内部：封装动态大小数组作为容器，能够存放任意的动态数组【数据结构】）

#include <vector>

vector<int> v1;
vector<int> v2(10);//指定10的空间大小
vector<int> v3(10, 0);//大小为10，并指定每个值为0

//迭代器 v1.begin():插在前 / v1.end()：插在后
v1.insert(v1.begin(), 10);
v1.insert(v1.begin(), 20);
v1.insert(v1.begin(), 30);
v1.insert(v1.begin(), 40);
//打印
for (int i = 0; i < v1.size(); ++i) {
    cout << v1[i] << endl;//40  30  20  10
}
//擦除第一个
v1.erase(v1.begin());//删除40
//修改第一个
v1.front() = 3;//30改成3
//修改最后一个
v1.back() = 1;//10改成1

//迭代器遍历循环打印（迭代器当作指针操作）
//auto：自动类型推导，这里是指vector<int>::iterator
for (auto iterator = v1.begin(); iterator < v1.end(); iterator++) {
    cout << *iterator << endl;//3  20  1
}

Stack

栈：先进后出，后进先出，手枪子弹上膛的一个思路。

#include <stack>

stack<int> stack;
//压栈
stack.push(10);//stack无法指定那个位置去压栈
stack.push(20);
stack.push(30);

//遍历
//不能用[]遍历，内部没有重载[]运算符
//也不能用迭代器遍历，它没有迭代器
while (!stack.empty()) {
    //top：获取栈顶的元素
    cout << stack.top() << endl;//30  20  10
    stack.pop();//获取完把栈顶的元素弹出去（删除）
}

Queue

队列：先进先出（FIFO:first in first out）。相当于排队付款，先排先买。

#include <queue>

queue<int> queue;
queue.push(10);
queue.push(20);
queue.push(30);//到这里顺序为：10 20 30
//修改第一个元素 10->1
queue.front() = 1;
//修改第二个 30->3
queue.back() = 3;

//遍历（同stack，没[]，没iterator）
while (!queue.empty()) {
    //front：获取第一个元素
    cout << queue.front() << endl;//1  20  3
    queue.pop();//把前面的元素 给消费掉  【删除】
}

priority_queue

优先级队列，queue的子集，内部对vector有一定的封装

#include <queue>

//priority_queue<int>默认是从大到小排序，相当于priority_queue<int,vector<int>,less<int>>
//从小到大排序：priority_queue<int,vector<int>,greater<int>>。（less:return _x < _y /greater:return _x > _y）
priority_queue<int, vector<int>, less<int>> queue;
queue.push(10);
queue.push(30);
queue.push(20);
queue.push(50);
while (!queue.empty()) {
    cout << queue.top() << endl;//50 30 20 10
    queue.pop();
}

List

Java：ArrayList采用Object[]数组， C++的list 内部：采用链表。

#include <list>

list<int> listVar;
listVar.push_front(1);//插在前：1
listVar.push_back(2);//插在后：1 2
listVar.insert(listVar.begin(), 3);//插在前：3 1 2
listVar.insert(listVar.end(), 4);//插在后：3 1 2 4

//修改
listVar.front() = 10;
listVar.back() = 40;//10 1 2 40
//删除
listVar.erase(listVar.begin());//1 2 40

//迭代器遍历（没有[]）,begin()返回迭代器
for (list<int>::iterator it = listVar.begin(); it != listVar.end(); it++) {
    cout << *it << endl;
}

Set

内部：红黑树结构，会对你存入的数据进行排序，但是绝对不允许元素相同

#include <set>

//greater:从大到小排序  less：从小到大。set<int>：默认为less
set<int, greater<int>> s;
s.insert(1);
s.insert(2);
s.insert(3);

pair<set<int, less<int>>::iterator, bool> res = s.insert(2);//返回false
//res.first:返回pair的第一个元素迭代器；second是第二个元素
cout << res.second << endl;//重复插入，bool返回0：false;否则返回1

//遍历
for (set<int, less<int>>::iterator it = s.begin(); it != s.end(); it++) {
    cout << *it << endl;//3 2 1
}

自定义函数谓词

C++都是一些常规的谓词，不能满足所有对象大小的比较，所以模仿源码自定义谓词来解决。

先看下系统的less：

template<typename _Tp>
  struct less : public binary_function<_Tp, _Tp, bool>
  {
    _GLIBCXX14_CONSTEXPR
    bool
    operator()(const _Tp& __x, const _Tp& __y) const
    { return __x < __y; }
  };

自定义Person的大小排序比较谓词：

#include <set>
using namespace std;

class Person {
public:
    string name;
    int id;

    Person(string name, int id) : name(name), id(id) {}
};

struct personLess {
    bool operator()(const Person &x, const Person &y) const { return x.id < y.id; }
};

int main() {
    set<Person, personLess> persons;
    persons.insert(Person("张三", 22));
    persons.insert(Person("李四", 21));
    persons.insert(Person("王五", 20));

    //auto：这里指set<Person>::iterator
    for (auto it = persons.begin(); it != persons.end(); it++) {
    //string通过c_str转换为可打印的char*
        cout << it->name.c_str() << "," << it->id << endl;
    }
    return 0;
}

输出：

王五,20
李四,21
张三,22