C++순서 용기

순차 용기 종류
vector
list
deque
string
개술
vector,string 은 무 작위 접근 을 지원 합 니 다.속도 가 빠 르 고 끝 에 삽입/삭제 속도 가 빠 릅 니 다.
list 양 방향 링크,양 방향 순서 접근 만 지원
deque 양 방향 대기 열,빠 른 랜 덤 접근 을 지원 합 니 다.머리 끝 에 삽입/삭제 속도 가 빠 릅 니 다.
용기 선택
일반적인 상황 에서 vector 선택
요소 가 작 으 면 list 를 사용 하지 마 십시오.
무 작위 접근 을 요구 하면 vector 나 deque 를 사용 해 야 합 니 다.
중간 에 요 소 를 삽입 하려 면 list 를 사용 해 야 합 니 다.
중간 삽입 후 무 작위 접근 이 필요 하 다 면 list 로 vector 로 복사 하 십시오.
순차 용기 공통 동작(C11)

//    
iterator                    //         
const_iterator              //            
size_type                   //     
difference_type             //     ，            
reference                   //       ； value_type&    
const_reference             // const value_type&

//    
C c;                        //      
C c1(c2);                   //  c2   
C c(b, e);                  //     b e     ,    e     ， [b, e)
C c{a, b, c...};            //     

//   swap
c1 = c2;                    // c1       c2   
c1 = {a, b, c...};          // c1             
a.swap(b);                  //  a b   
swap(a, b);

//  
c.size()                    //c      
c.max_size()                //c          
c.empty()                   //        

//    
c.push_back(t)              //       ,  void
c.emplace(args)             //            ，  void
c.insert(p, t)              // p      ，           
c.emplace(p, args)          //  
c.insert(p, n, t)           //    p    n   t   ，                 ， n 0，  p
c.insert(p, b, e)           // b e        p  ，     
c.insert(p, il)             //il      {a, b, c...}，     

//    
c.back()                    //        
c.front()                   //   
c[n]                        //   n      
c.at(n)                     //  

//    
c.pop_back()                //     ，  void
c.pop_front()               //
c.erase(p)                  //     p     ，  p         
c.erase(b, e)               //  [b, e)，  e
c.clear()                   //      ，  void

//      
c.resize(n)                 // n < c.size(),       ，  ，        
c.resize(n, t)              //         t   

//     
==, !=
, >=

//     
c.begin(), c.end()
c.cbegin(), c.cend()

//         
reverse_iterator
const_reverse_iterator
c.rbegin(), c.rend()
c.crbegin(), c.crend()

사용 순서 용기

#include 
using std::vector;

class Person{
    Person(){
        name = "";
        age = -1;
    }
    Person(const std::string name_, int age_):
        name(name_), age(age_) {}
    string name;
    int age;
};
//        
vector<int> vi1;                    //      
vector<vector<int>> vvi;
vector<int> vi2 = {1, 2, 3};        //  vector vi2{1, 2, 3};
vector<int> vi3(vi2);
vector<int> vi4(vi3.begin(), vi3.end());
vector<int> vi5(10, -1);            //10   -1   
//           
vector<int>::iterator b = vi2.begin(), e = vi2.end();
for(vector<int>::iterator i = b; i != e; i++){
    (*i)++;
    std::cout << *i;
}
//   swap，                 、  、    
vi1 = vi2;
vi1 = {1, 2, 3};
swap(vi1, vi2);                     //swap    vi2 vi1       
vi1.swap(vi2);
vi3.assign(vi1.cbegin(), vi1.cend());
vi3.assign(10, -1);                 //10 -1
//       
vi1.empty();
vi1.size();
vi1.max_size();
vi1 == vi2
vi1 < vi2
//  
vector p("xxx", 20);
p.push_back(Person("xxx", 21));     //       
p.emplace_back("xxx", 22);          //               ，  push_back 
                                    //emplace_back   
p.insert(p.begin(), Person("xxx", 23));     //insert(x, y)   x    y
p.emplace(p.begin(), "xxx", 24);            // insert

//