C++ 容器浅析

• vector
• stack
• queue
• list
• set

---

vector

• 向量（Vector）是一个动态大小数组的顺序容器（Sequence Container）。【元素按线性顺序排序，通过元素在序列中的位置访问对应的元素。】
• 能够存放任意类型的动态数组。
• 可以通过指针进行该操作，有在序列末尾相对快速地添加/删除元素的操作
• 用一个内存分配器对象来动态地处理它的存储需求。

函数

• 构造函数

vector():创建一个空vector

vector(int nSize):创建一个vector,元素个数为nSize

vector(int nSize,const t& t):创建一个vector，元素个数为nSize,且值均为t

vector(const vector&):复制构造函数

vector(begin,end):复制[begin,end)区间内另一个数组的元素到vector中

• 增加函数

void push_back(const T& x):向量尾部增加一个元素X

iterator insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x

iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x

iterator insert(iterator it,const_iterator first,const_iterator last):向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据

• 删除函数

iterator erase(iterator it):删除向量中迭代器指向元素

iterator erase(iterator first,iterator last):删除向量中[first,last)中元素

void pop_back():删除向量中最后一个元素

void clear():清空向量中所有元素

• 遍历函数

reference at(int pos):返回pos位置元素的引用

reference front():返回首元素的引用

reference back():返回尾元素的引用

iterator begin():返回向量头指针，指向第一个元素

iterator end():返回向量尾指针，指向向量最后一个元素的下一个位置

reverse_iterator rbegin():反向迭代器，指向最后一个元素

reverse_iterator rend():反向迭代器，指向第一个元素之前的位置

• 示例

int main(){
    vector<int> vector12;//初始化
    vector12.insert(vector12.begin(), 10);//前面插入
    vector12.insert(vector12.begin(), 20);
    vector12.insert(vector12.begin(), 30);
    vector12.insert(vector12.end(), 40);//后面插入

  //遍历
  for (int i = 0; i < vector12.size(); i++) {
        int value = vector12[i];
        cout << value << endl;
    }  

vector12.front() = 1;//修改front和back的值
vector12.back() = 2;//修改front和end的值

vector12.erase(vector12.begin() + 1);//擦除

  //迭代器遍历
    for (auto iter = vector12.begin(); iter != vector12.end(); iter++) {
        // 迭代器 当中指针操作  iteratorVar++
        cout<<*iter<<endl;
    }  


}

stack

• 栈是一种容器适配器
• LIFO

 #include <stack>  
//Initializing an Adapator；初始化
stack<int> stk(deq); // copies elements from deq into stk

//覆盖基础容器类型
 stack< string, vector<string> > str_stk;

//函数
s.empty() //Returns TRue if the stack is empty; false otherwise.



s.size()//Returns a count of the number of elements on the stack.



s.pop()//Removes, but does not return, the top element from the stack.



s.top()//Returns, but does not remove, the top element on the stack.



s.push(item)//Places a new top element on the stack.

• 示例

 stack<int> stackVar;
    stackVar.push(20);
    stackVar.push(40);
    stackVar.push(60);

    for (int i = 0; i < stackVar.size(); i++) {
//        cout << stackVar[i] << endl;//报错
    }

//    for(stack<int>::iterator iter;){//没有迭代器
//
//    }

//慎用
    while (!stackVar.empty()) {
        int ele = stackVar.top();
        cout << ele << endl;
        stackVar.pop();
    }
    //最后没有元素了
    cout << "元素：" << endl;
    int top = stackVar.top();
    cout << top << endl;
    //C++ stack 的栈是不能遍历的,需要遍历的话 可以换个容器比如list

queue

Class QueueItem will represent a node in Queue's linked list. This class has two data members: item and next:

• item holds the value of the element in the Queue; its type varies with each instance of Queue.
• **next **is a pointer to the next QueueItem object in the queue.

image.png

• 初始化方式和stack相同

• 具有如下方法

  
  image.png

• priority_queue

  queue<int> queueVar;

    queueVar.push(10);
    queueVar.push(20);

//    priority_queue<int> priority_queueVar; //默认从小到大顺序排列
//    priority_queue<int,vector<int>,less<>> priority_queueVar; //从小到大顺序排列
    priority_queue<int,vector<int>,greater<>> priority_queueVar; //从大到小顺序排列
    priority_queueVar.push(10);
    priority_queueVar.push(20);
    priority_queueVar.push(30);
    priority_queueVar.push(40);

//    for(int i = 0;i<priority_queueVar.size();i++){
//        priority_queueVar[i];
//    }

    // queue 不允许有遍历行为
    int top = priority_queueVar.top();
    cout<<top<<endl;

list

image.png image.png

set

int main(){
set<int, less<int>> setVar; //  __x < __y 从小到大，默认情况下 就是 less

    // 添加参数，不需要用迭代器，也不需要指定位置
    setVar.insert(1);
    setVar.insert(3);
    setVar.insert(2);
    setVar.insert(4);

    // 重复插入，并不会报错  std::pair<iterator, bool>
    pair<set<int, less<int>>::iterator, bool> res = setVar.insert(8);

    // res.first 获取第一个元素 迭代器   当前迭代器   最后一个位置
    // res.second 获取第二个元素 bool
    bool insert_success = res.second;
    if (insert_success) {
        cout << "恭喜你，插入成功" << endl;

        // 插入成功后，我用第一个元素遍历
        for (; res.first != setVar.end(); res.first ++) {
            cout << *res.first << endl;
        }

    } else {
        cout << "哎，插入失败.." << endl;
    }

    // 全部遍历  auto 自动推到
    for (auto it = setVar.begin(); it != setVar.end() ; it ++) {
        cout << *it << endl;
    }
}

谓词

// 谓词 设计对象的排序

#include <iostream>
#include <set>

using namespace std;

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

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

// C++ 都是一些常规的 谓词  不能满足功能， 模仿C++源码的谓词 自定义谓词 解决这个问题

// C++缔造者写的这个源码 没有对象比较的功能 【系统源码谓词 做不到对象比较功能】
// bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }

// 我们就自定义这个功能  【自定义谓词 没有达到谓词的标准】
bool doCompareAction(const Person& person1, const Person& person2) {
    return person1.id < person2.id;
};

// 真正的谓词
struct doCompareAction2 {
public:
    bool operator() (const Person& __x, const Person& __y) {
        return __x.id < __y.id;
    }
};

struct doCompareAction3 {
public:
    bool operator() (const Person& __x, const Person& __y) {
        return __x.id > __y.id;
    }
};

int main() {
    // 默认是 less  return 对象1 < 对象2;

    set<Person, doCompareAction2> setVar;

    // set<Person, doCompareAction3> setVar;

    // 构建对象
    Person p1 ("Snake", 1);
    Person p2 ("kevin", 2);
    Person p3 ("Derry", 3);

    // 把构建的对象 插入到 set 容器里面去
    setVar.insert(p1);
    setVar.insert(p2);
    setVar.insert(p3);

    // name string  ---  c_str() ---->   char *
    for (set<Person>::iterator it = setVar.begin(); it != setVar.end() ; it ++) {
        cout << it->name.c_str() << " , " << it->id << endl;
    }

    return 0;
}