STL(Standard Template Library) - Container - Vector

#include<iostream>
#include<vector>
 
void print(std::vector<int> Target_Vector)
{
    std::vector<int>::iterator Iter_Begin = Target_Vector.begin();
    for (std::vector<int>::iterator Iter_pos = Iter_Begin; Iter_pos != Target_Vector.end(); Iter_pos++)
        std::cout << *Iter_pos << " ";
    std::cout << std::endl;
}
void main()
{
    std::vector<int> Vector_Cpoy;
    std::vector<int> Vector;
    std::vector<int>::iterator Iter;
 
 
    //if Vector is empty, empty() function return true
    std::cout << std::endl << "empty()" << std::endl;
    if (Vector.empty())
    {
        std::cout << "Vector is empty" << std::endl;
    }
    //assign(x,y) function write y datas in x nodes, privious datas will be deleted
    std::cout << std::endl << "assign()" << std::endl;
    Vector.assign(10, 1);
    print(Vector);
 
    //push_back(x) function write x to back of the Vector
    std::cout << std::endl << "push_back()" << std::endl;
    Vector.push_back(4);
    Vector.push_back(5);
    print(Vector);
    
    //at(x) function display x+1(th) data
    std::cout << std::endl << "at()" << std::endl;
    std::cout << "Data in 10th Array -> "<<Vector.at(10) << std::endl;
 
    //back() function return data that exist end of the Vector
    std::cout << std::endl << "back()" << std::endl;
    std::cout << "Data in back of the Vector -> " << Vector.back() << std::endl;
 
    //begin() function return Iterator that point data that in front of Vector
    std::cout << std::endl << "begin()" << std::endl;
    std::cout << "Data in front of the Vector(Iterator) ->" << *Vector.begin()<<std::endl;
    std::cout << "Data in front of the Vector(Array Pointer) ->" << Vector[0] << std::endl;
 
    //capacity() function display current Max size of Array (if you write data when it is full, capacity will be more big
    std::cout << std::endl << "capacity()" << std::endl;
    std::cout << "Capacity  ->" << Vector.capacity() << std::endl;//15
 
    Vector.push_back(12);
    Vector.push_back(17);
    Vector.push_back(20);
    Vector.push_back(15);
    print(Vector);
    std::cout << "Capacity  ->" << Vector.capacity() << std::endl;//22
 
    //cbegin() function return const Iterator that point data that in front of vector
    std::cout << std::endl << "cbegin()" << std::endl;
    std::cout << "Data in front of the Vector(const Iterator) ->" << *Vector.cbegin() << std::endl;
    std::cout << "Data in front of the Vector(Array Pointer) ->" << Vector[0] << std::endl;
 
    //cend() function return const Iterator that point next to data that locate end of vector
    std::cout << std::endl << "cend()" << std::endl;
    std::cout << "Data in end of the Vector(const Iterator) ->" << *(Vector.cend() - 1) << std::endl;
    std::cout << "Data in end of the Vector(Array Pointer) ->" << Vector[(Vector.size())-1] << std::endl;
 
    //operator '=' copy x to y
    std::cout << std::endl << "operator '='" << std::endl;
    std::cout << "Vector (Previous) -> "; print(Vector);
    std::cout << "Vector_Cpoy (Previous) -> "; print(Vector_Cpoy);
    Vector_Cpoy = Vector;
    std::cout << "Vector (After) -> "; print(Vector);
    std::cout << "Vector_Cpoy (After) -> "; print(Vector_Cpoy);
 
    //clear() function clear all data in this Vectory
    std::cout << std::endl << "clear()" << std::endl;
    std::cout << "Vector_Cpoy (Previous) -> "; print(Vector_Cpoy);
    Vector_Cpoy.clear();
    if (Vector_Cpoy.empty())
        std::cout << "Vector_Copy is empty" << std::endl;
 
    //crbegin() function return const Iterator that point next to data that locate end of vector
    std::cout << std::endl << "crbegin()" << std::endl;
    std::cout << *(Vector.rbegin()) << std::endl;
 
    //cend() function return const Iterator that point data that in front of vector
    std::cout << std::endl << "crend()" << std::endl;
    std::cout<<*(Vector.crend()-1);
 
    //data() function is pointer that point int front of data and can control specific array, can modify Vector but doesn't change  
    std::cout << std::endl << "data()" << std::endl;
    print(Vector);
    int *p = Vector.data();//set pointer
 
    *p = 30;//=Vector[0] = p[0]
    print(Vector);
    p++; 
    *p=40;//= p[0] = Vector[1]
    print(Vector);
    p[2] = 12;//= Vector[3]
    print(Vector);
    p[4] = 14;// = Vector[5]
    print(Vector);
 
    //emplace(x,y) function write 'y' in x(th) position
    std::cout << std::endl << "emplace()" << std::endl;
    Vector.emplace(Vector.begin()+8, 123456);
    print(Vector);
 
    //emplace_back(x) function write 'x' in the end of this Vector
    std::cout << std::endl << "emplace_back(1234)" << std::endl;
    Vector.emplace_back(1234);
    print(Vector);
 
    //end() function return Iterator that point data that in front of vector
    std::cout << std::endl << "end()" << std::endl;
    std::cout << *(Vector.end() - 1) << std::endl;
 
    //erase(x) function erase data that x Iterator points
    std::cout << std::endl << "erase(Vector.begin())" << std::endl;
    Vector.erase(Vector.begin());
    print(Vector);
 
    //front() function return value locate in front of Vector
    std::cout << std::endl << "front()" << std::endl;
    std::cout << Vector.front() << std::endl;
 
    //get_allocator()
    std::cout << std::endl << "get_allocator(???)" << std::endl;
    std::cout << Vector.get_allocator().address(2) << std::endl;
    
    //insert(x,y) function insert data specific position that x Iterator points
    std::cout << std::endl << "insert()" << std::endl;
    Vector.insert(Vector.begin(), 4);
 
    //max_size() function returns the maximum number of elements that the vector can hold.
    std::cout << std::endl << "max_size()" << std::endl;
    std::cout << Vector.max_size()<< std::endl;
 
    //operator[1] point Vector's 2rd data(not pointer)
    std::cout << std::endl << "operator[1]" << std::endl;
    std::cout << Vector[1] << std::endl;
 
    //pop_back() function remove last data
    std::cout << std::endl << "pop_back()" << std::endl;
    std::cout << "Previous -> "; print(Vector);
    Vector.pop_back();
    std::cout << "After -> "; print(Vector);
 
    //rbegin() function is Iterator that point first data(reverse)
    std::cout << std::endl << "rbegin()" << std::endl;
    std::cout << *Vector.rbegin() << std::endl;
 
    //rend() function is literator that point next to last data(reverse)
    std::cout << std::endl << "rend()" << std::endl;
    std::cout << *(Vector.rend()-1) << std::endl;
 
    //reserve(x) function resize capacity to x (over basic size 16 , cannot resize under 16)
    std::cout << std::endl << "reserve()" << std::endl;
    Vector_Cpoy.reserve(100);
    std::cout << Vector_Cpoy.capacity() << std::endl;
    Vector_Cpoy.assign(101, 5);
    std::cout << Vector_Cpoy.capacity() << std::endl;
    Vector_Cpoy.assign(151, 5);
    std::cout << Vector_Cpoy.capacity() << std::endl;
    Vector_Cpoy.assign(201, 5);
    std::cout << Vector_Cpoy.capacity() << std::endl;
 
    //resize(x) function remain x datas 
    std::cout << std::endl << "resize()" << std::endl;
    std::cout << "Previous ->"; print(Vector);
    Vector.resize(10);
    std::cout << "After ->"; print(Vector);
 
    //shrink_to_fit() function resize capacity to number of data in vector
    std::cout << std::endl << "shrink_to_fit()" << std::endl;
    std::cout << "Previous ->"; std::cout << Vector.capacity() << std::endl;
    Vector.shrink_to_fit();
    std::cout << "After ->"; std::cout << Vector.capacity() << std::endl;
 
    //Vector.size() function display number of data in vector
    std::cout << std::endl << "size()" << std::endl;
    std::cout << "Vectory Size -> " << Vector.size() << std::endl;
 
    //x1.swap(x2) function swap x1 and x2;
    std::cout << std::endl << "swap()" << std::endl;
    std::cout << "Vector (Previous) -> "; print(Vector);
    std::cout << "Vector_Cpoy (Previous) -> "; print(Vector_Cpoy);
    Vector.swap(Vector_Cpoy);
    std::cout << "Vector (After) -> "; print(Vector);
    std::cout << "Vector_Cpoy (After) -> "; print(Vector_Cpoy);
    
 
}

각 함수들의 기능을 알아보겠습니다.

1. empty()
   
   벡터가 비었을 경우 true를 리턴하며 데이터가 있을 경우 false를 리턴합니다.
   
   
2. assign(x,y)
   
   기존의 데이터는 모두 삭제하고 y 데이터를 x개를 벡터에 삽입합니다.
   
   
3. push_back(x)
   
   벡터에 마지막에 데이터 x를 대입합니다.
   
   
4. at(x)
   
   x+1번째 데이터를 리턴합니다.
   
   
5. back()
   
   벡터의 가장 마지막에 있는 데이터를 리턴합니다.
   
   
6. begin()
   
   벡터의 가장 앞에 있는 데이터를 가리키는 이터레이터를 리턴합니다.
   
   
7. capacity()
   
   현재의 최대 크기를 리턴합니다. 최대크기는 꽉 찼을 때 조금 더 커집니다.
   
   
8. cbegin()
   
   벡터에 제일 앞에 있는 데이터를 가리키는 const 이터레이터를 리턴합니다.
   
   
9. cend()
   
   벡터에 제일 뒤에 있는 데이터 다음을 가리키는 const 이터레이터를 리턴합니다.
   
   
10. operator =
    
    x = y 의 경우 x 벡터에 y 벡터 그대로 복사합니다.
    
    
11. clear()
    
    벡터내의 데이터를 모두 지웁니다.
    
    
12. crbegin()
    
    반대로 본 벡터에서 가장 앞에 있는 데이터를 가리키는 이터레이터를 리턴합니다.
    
    
13. crend()
    
    반대로 본 벡터에서 가장 뒤에 있는 데이터 바로 다음을 가리키는 이터레이터를 리턴합니다.
    
    
14. data()
    
    포인터를 통해서 배열처럼 이용할 수 있게 해줍니다.
    
    
15. emplace(x,y)
    
    x번째 위치에 y 데이터를 삽입합니다.
    
    
16. emplace_back(x)
    
    벡터의 가장 마지막 위치에 x를 대입합니다.
    
    
17. end()
    
    벡터의 가장 마지막 데이터 바로 다음을 가리키는 이터레이터를 리턴합니다.
    
    
18. erase(x)
    
    이터레이터 x가 가리키는 데이터를 삭제합니다.
    
    
19. front()
    
    벡터 제일 앞에 있는 데이터를 리턴합니다.
    
    
20. insert(x,y)
    
    x가 가리키는 위치에 y를 삽입합니다.
    
    
21. max_size()
    
    최대 사이즈를 리턴합니다.
    
    
22. Operator []
    
    벡터는 배열처럼 이용할 수 있습니다. Vector[0]은 첫데이터를 가리킵니다.
    
    
23. pop_back()
    
    벡터 제일 제일 뒤에 있는 데이터를 삭제합니다.
    
    
24. rbegin()
    
    반대로 본 벡터에서 가장 처음의 데이터를 가리키는 이터레이터를 리턴합니다.
    
    
25. rend()
    
    반대로 본 벡터에서 가장 마지막 데이터 바로 다음을 가리키는 이터레이터를 리턴합니다.
    
    
26. reserve()
    
    벡터가 꽉찼을 때 벡터가 늘어나는 사이즈를 지정합니다. 16 이하로 설정시에 16씩 늘어납니다.
    
    
27. resize()
    
    벡터의 크기를 재조정 합니다.
    
    
28. shrink_to_fit()
    
    벡터 capacity를 데이터가 들어있는 만큼으로 조정합니다.
    
    
29. size()
    
    현재 벡터의 크기를 리턴합니다.
    
    
30. x.swap(y)
    
    벡터 x와 벡터 y 를 완전히 바꿉니다.