관리 메뉴

Kim's Programming

STL(Standard Template Library) - Container - Vector 본문

STL - Container

STL(Standard Template Library) - Container - Vector

Programmer. 2016. 1. 22. 02:52
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
#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(101);
    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 *= Vector.data();//set pointer
 
    *= 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()+8123456);
    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(1015);
    std::cout << Vector_Cpoy.capacity() << std::endl;
    Vector_Cpoy.assign(1515);
    std::cout << Vector_Cpoy.capacity() << std::endl;
    Vector_Cpoy.assign(2015);
    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);
    
 
}
cs


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


    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 를 완전히 바꿉니다.