//把vec的数据初始化给list
list<int> l(vec.begin(), vec.end());
//前向定位
auto it = l.begin();
advance(it, j);

pair<T1, T2> p1;            //创建一个空的pair对象（使用默认构造），它的两个元素分别是T1和T2类型，采用值初始化。
pair<T1, T2> p1(v1, v2);    //创建一个pair对象，它的两个元素分别是T1和T2类型，其中first成员初始化为v1，second成员初始化为v2。
pair<T1, T2> p2 = make_pair(v1, v2);          // 以v1和v2的值创建一个新的pair对象，其元素类型分别是v1和v2的类型。
p1 < p2;                    // 两个pair对象间的小于运算，其定义遵循字典次序：如 p1.first < p2.first 或者 !(p2.first < p1.first) && (p1.second < p2.second) 则返回true。
p1 == p2；                  // 如果两个对象的first和second依次相等，则这两个对象相等；该运算使用元素的==操作符。
p1.first;                   // 返回对象p1中名为first的公有数据成员
p1.second;                 // 返回对象p1中名为second的公有数据成员

string str="gdfd"; 
consta char* constc = NULL;
contc = str.c_tr();//string->const char*
c = const_cat<char*>(constc)//const char*->char*

//但是如果是在函数中return，因为局部变量在stack上，出了作用域就会被销毁
char* res_c = new char[res.size()];
for(int i=0; i<res.size(); i++)
    res_c[i] = res[i];
cout<<res_c;
string s1("demo1"); 

 char* str="abc";
//str指向的是静态存储区，"abcdef"是位于常量区的，指针str只是指向了这个位置
char str[]="abc";
//这个数组的存储空间是在栈中开辟的，也就是说它的每个元素一次为'a','b','c','\0'，

int v = rand()%(b-a+1)+a;
//v属于[a,b]

    string s = "12";
    int a = atoi(s.c_str());

#include <algorithm>
reverse(s.begin(),s.end());

s.substr(pos, n)//截取s中从pos开始（包括0）的n个字符的子串，并返回

s.find(s1)         //查找s中第一次出现s1的位置，并返回（包括0）

s.rfind(s1)        //查找s中最后次出现s1的位置，并返回（包括0）

s.find_first_of(s1)       //查找在s1中任意一个字符在s中第一次出现的位置，并返回（包括0）

s.find_last_of(s1)       //查找在s1中任意一个字符在s中最后一次出现的位置，并返回（包括0）

s.erase(begin_pos, size);

s.replace(pos, n, s1)    //用s1替换s中从pos开始（包括0）的n个字符的子串

// 定义一个map对象
map<int, string> mapStudent;
 
// 第一种 用insert函數插入pair
mapStudent.insert(pair<int, string>(000, "student_zero"));
//pair用.
 
// 第二种 用"array"方式插入
mapStudent[123] = "student_first";
mapStudent[456] = "student_second";

mapStudent.count("123")!
iter = mapStudent.find("123");
if(iter != mapStudent.end())
       cout<<iter->second<<endl;

//迭代器刪除
iter = mapStudent.find("123");
mapStudent.erase(iter);
 
//用关键字刪除
int n = mapStudent.erase("123"); //如果刪除了會返回1，否則返回0
 
//用迭代器范围刪除 : 把整个map清空
mapStudent.erase(mapStudent.begin(), mapStudent.end());
//等同于mapStudent.clear()

     map<int, string>::iterator  iter;
     for(iter = mapStudent.begin(); iter != mapStudent.end(); iter++){
          cout<<iter->first<<" "<<iter->second<<endl;
     }
    for(auto item:myStudent){
        cout<<item.first<<item.second;
    }
//数组方式（已有key了）
    int iSize = mapStudent.size();
    for(int i = 1; i <= iSize; i++){
        cout<<i<<" "<<mapStudent[i]<<endl;
    }

//默认排序：从小到大
//从大到小
map<string, int, greater<string> > mapStudent;

//自定义
struct CmpByKeyLength {  
  bool operator()(const string& k1, const string& k2) {  
    return k1.length() < k2.length();  
  }  
}; 
map<string, int, CmpByKeyLength > mapStudent; 

#include<limits.h>
INT_MAX
INT_MIN

set<int> s; //unordered_set 更快
s.insert(1);
s.count(1)//1出现的次数
//遍历
for(iter = s.begin() ; iter != s.end() ; ++iter)
{
    cout<<*iter<<" ";
}

//自动排序 得到第n个丑数
int nthUglyNumber(int n) {
        set<double> s;  // set 是有序的，且不重复
        double answer = 1;
        for (int i = 1; i < n; i++) {
            s.insert(answer * 2);
            s.insert(answer * 3);
            s.insert(answer * 5);
            answer = *s.begin(); s.erase(answer);
        }
        return answer;

vector<int> vec;
vec = vector<int>(size);
vec.resize(size);
vector<int> vec(size, value);
vector<vector<int>> newOne(r,vector<int>(c,0)); 

bool mycomp(int i, int j) {
    return (i < j);
}

int main() {
    std::vector<int> myvector{ 32, 71, 12, 45, 26, 80, 53, 33 };
    //调用第一种语法格式，对 32、71、12、45 进行排序
    std::sort(myvector.begin(), myvector.begin() + 4); //(12 32 45 71) 26 80 53 33
    //调用第二种语法格式，利用STL标准库提供的其它比较规则（比如 greater<T>）进行排序
    std::sort(myvector.begin(), myvector.begin() + 4, std::greater<int>()); //(71 45 32 12) 26 80 53 33
    return 0;
}

//1,2,3,4,5,6,7,8,9,10
vector<int>::iterator fist1 = Arrs.begin() + 2; // 第三个迭代器
vector<int>::iterator last1 = Arrs.end() - 1; // 倒数第二个迭代器
vector<int> Arrs2(first1, last1); // 创建整型的容器，并初始化为Arrs的第三个到第八个：{3,4,5,6,7,8}
vector<int> Arrs1(Arrs.begin(), Arrs.end());//1,2,3,4,5,6,7,8,9,10
vector<int> Arrs1(Arrs.begin(), Arrs.begin()+1);//1
vector<int> Arrs1(Arrs.begin(), Arrs.end()-1);//1,2,3,4,5,6,7,8,9

vector<int>::iterator it = vec.begin();
vec.erase(it+k);
vec.pop_back();//删除最后
//注意 vector申请的连续的空间 使用erase后后面的迭代器会失效。但是erase会返回下一个有效的迭代器

用*it访问值

 vector<int>::iterator result = find( L.begin( ), L.end( ), 3 ); //查找3

  struct ListNode {
      int val;
      ListNode *next;
      ListNode() : val(0), next(nullptr) {}
      ListNode(int x) : val(x), next(nullptr) {}
  };
//构建
ListNode *l = new ListNode();
ListNode *p = l;
for(int i=0; i<n; i++){
    p->next = new ListNode(i);
    p = p->next;
}
return l->next;

#include <stack> 
stack< int > s;
/**
empty() 堆栈为空则返回真

pop() 移除栈顶元素

push() 在栈顶增加元素

size() 返回栈中元素数目

top() 返回栈顶元素
**/

//可以利用其实现最小堆 其实set也可以！默认有序的！！！
 #include <queue>
priority_queue<long, vector<long>, greater<long>> heap;
1 //升序队列，小顶堆
2 priority_queue <int,vector<int>,greater<int> > q;
3 //降序队列，大顶堆
4 priority_queue <int,vector<int>,less<int> >q;

heap.push(next);
item = heap.top();
heap.pop();

queue <int> myQ;
myQ.push(i);
myQ.pop();
int peek =myQ.front();

deque<int> dq;
dq.push_back();
dq.push_front();
dq.pop_back();
dq.pop_front();
//并且可以自由访问每个元素 dq[k]

class MyClass
{
private:
    int m1_int;
    double m2_double;
public:
    MyClass(int m1, double m2) : m1_int(m1), m2_double(m2){}

private:
    int m1_int;
    double m2_double;
} ;
int main(){
    MyClass myclass1;//调用第一种形式的构造函数
    MyClass myclass(2,0.3);//调用第二种形式的构造函数
    
    //或者用下面的方式创建对象
    MyClass myclass1 = MyClass();//调用第一种形式的构造函数
    MyClass myclass2 = MyClass(2,0.3);//调用第二种形式的构造函
}