容器

c++中的容器分为两种：
1.序列化容器，元素的排序关系，和元素本身没有任何关系，是我们在添加的时候的顺序导致的排序（vector,priority_queue）
2.关联式容器，根据标识决定添加或者获取，，，类似于java中的map，set

序列化容器之vector的基本用法

首先要添加头文件
#include <vector>//c++容器中提供的
#include <string>//务必添加，否则下面用到string的地方都会报错

//3种声明方式
//    vector<int> vector01(1);//声明一个元素的空间
//    vector<string> vector02(5,"tony");//声明5个元素的空间，值都是tony


    //第三种方式常用
    vector<int> vector03;
    //添加元素
    vector03.push_back(111);
    vector03.push_back(222);
    vector03.push_back(333);
    vector03.push_back(444);

    //删除元素
    vector03.pop_back();//删除最新的，最后添加的元素，ddd

    //获取元素
    int value = vector03.at(0);
    value = vector03[1];
    LOGD("value=%d",value);

    //清空元素
    vector03.clear();

    // 是否被清空了
    if (vector03.empty()) {
        LOGD("清空");
    } else {
        LOGD("未清空");
    }

// 容器有很严重的问题
    // 此容器，占用的内存空间，是只增不减的
        LOGD("此Vector容器，占用内存空间是:%d",vector03.capacity());

如果是在函数内部声明的，函数执行完后，函数弹栈，所有在栈区申请的内存，全部释放，但是如果是全局的，需要定义一个临时容器

// 定义一个全局容器
vector<string> allName;

void test01()
{
    allName.push_back("1111");
    allName.push_back("2222");
    allName.push_back("3333");

    allName.clear(); // 清空 内存空间 还是占用的  怎么办？

    // 替换的方式：来解决此问题
    vector<string> tempVector; // 定义临时容器目的：就是为了解决 、 替换全局容器，让全局容器不占用内存空间
    tempVector.swap(allName); // 把全局的 全部移动 给临时 == 把全局的给回收了
} // 函数一弹栈  tempVector给回收了，就保证了，全局和临时全部回收完毕

序列化容器之priority_queue的基本用法

先添加头文件
#include <queue>
//    priority_queue<int> priorityQueue;
//    priorityQueue.push(6);
//    priorityQueue.push(2);
//    priorityQueue.push(333);
//    LOGD("第一个元素是：%d",priorityQueue.top());//这里输出的是333，默认排序方式是降序


    // 优先级队列priority_queue，基于vector实现的
    // greater：把最小的值，放在最前面了
    // less：把最大的值，放在最前面了
    priority_queue<int, vector<int>, greater<int>> priorityQueue2;
    priorityQueue2.push(6);
    priorityQueue2.push(2);
    priorityQueue2.push(333);
    LOGD("第一个元素是：%d",priorityQueue2.top());//这里输出的是333，默认排序方式是降序

我们也可以仿照源码，照葫芦画瓢，自定义排序类：
源码如下：(感觉很像是java中的compareTo)

#if _LIBCPP_STD_VER > 11
template <class _Tp = void>
#else
template <class _Tp>
#endif
struct _LIBCPP_TEMPLATE_VIS greater : binary_function<_Tp, _Tp, bool>
{
    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
    bool operator()(const _Tp& __x, const _Tp& __y) const
        {return __x > __y;}
};

自定义我们的：

//
// Created by ftd_g on 2020/2/18.
//

#include <iostream>
#include <android/log.h>
#include "main.h"
#include "MyExtends.h"
#include <vector>//c++容器中提供的
#include <string>
#include <queue>

#define TAG "guow"
//__VA_AGRS__ 代表...的可变参数
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, TAG,  __VA_ARGS__)
using namespace std;

class MyType{
public:
    int count;
    //构造函数
public:
    MyType(int count){
        this->count = count;
    }
};

//这个是完全仿照源码照葫芦画瓢出来的
struct MyTypeLess
{
    bool operator()(const MyType& __x, const MyType& __y) const
    {return __x.count > __y.count;}
};
int main(){
    priority_queue<MyType,vector<MyType>,MyTypeLess> priorityQueue;
    priorityQueue.push(MyType(20));
    priorityQueue.push(MyType(222222));
    priorityQueue.push(MyType(1));
    LOGD("第一个元素是：%d",priorityQueue.top());
}

关联性容器set的基本用法

首先添加头文件：
#include <set>
set<int> set1 = {1,2,3,4,5};
    set1.insert(777);
    set1.insert(888);
    set1.insert(999);

    // 删除元素
    // set1.erase(1);

    // 遍历操作
    set<int>::iterator beginResult = set1.begin(); // 指向容器中的第零个元素的意思
    set<int>::iterator endResult = set1.end(); // 指向容器中的末尾元素的下一个元素

    //这里的beginResult可以理解为set1第一个元素的内存地址，通过*内存地址取出该内存地址对应的值

    // for 遍历
    for (; beginResult != set1.end() ; beginResult++) {
        // * 取出迭代器里面内存地址所关联对应的具体元素
        LOGD("遍历set it:%d\n",*beginResult);
    }

其中vector遍历和set大同小异

vector<int> vector1;
    vector1.push_back(1);
    vector1.push_back(2);
    vector1.push_back(3);
    vector1.push_back(4);
    vector1.push_back(5);

    vector<int>::iterator it = vector1.begin();
    for (; it < vector1.end() ; it++) {
        LOGD("遍历vector:%d\n",*it);
    }

谢谢观看，有不对或者不详细的地方希望大家在评论区提出宝贵的意见。