[C/C++] C++ STL Container [1]
์ปจํ ์ด๋(Container)?
C++ STL ์ปจํ
์ด๋๋ ๊ฐ์ ํ์
์ ๊ฐ์ฒด๋ค์ ์ ์ฅํ๊ณ ๊ด๋ฆฌํ ์ ์๊ฒ ํ๋ค. template์ ์ฌ์ฉํ์ฌ ์ ๋ค๋ฆญํ๊ฒ ๊ตฌํ๋์ด ์๊ธฐ ๋๋ฌธ์ ํน์ ํ ์๋ฃํ์ ์์กดํ์ง ์๋๋ค.
์ปจํ ์ด๋๋ค์ ๋์ ์๋ฆฌ๋ฅผ ์ดํดํ๋ ๊ฒ์ด ์ค์ํ๋ค. ์๋ฅผ ๋ค์ด vector๋ ๋งจ ์์ ์ฝ์ /์ญ์ ํ๋ ๊ฒ์ด ๋นํจ์จ์ ์ด๊ธฐ ๋๋ฌธ์ push_front(), pop_front()๋ ์ง์ํ์ง ์๋๋ค.
์ํ์ค ์ปจํ ์ด๋ : ๋ฐ์ดํฐ๊ฐ ์ ํ์ ์ผ๋ก ์ ์ฅ๋๋ ์ปจํ ์ด๋
1. ๋ฐฐ์ด (array)
ํค๋ํ์ผ <array>, namespace std
template <typename T, std::size_t Num> class array;
ํน์ง
- ๊ณ ์ ๋ ํฌ๊ธฐ์ ๋ฐฐ์ด์ ๋ด๋ ์ปจํ ์ด๋.
- ํฌ๊ธฐ๊ฐ ๊ณ ์ ์ด๊ธฐ ๋๋ฌธ์ ์์์ ์ถ๊ฐ๋ ์ญ์ ๊ฐ ๋ถ๊ฐ๋ฅํ๋ค.
- ๊ฐ๋ค์ด ๋ฉ๋ชจ๋ฆฌ ์์์ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋์ด ์๋ค.
- ์ธ๋ฑ์ค๋ฅผ ํตํ ์์ ์ ๊ทผ(Random Access)์ด ๊ฐ๋ฅํ๋ฉฐ ๋น ๋ฅด๋ค O(1).
- ์ฃผ์๋ก ์ ๊ทผํ ๊ฒฝ์ฐ *(arr1), *(arr1+1) ์ ๊ทผ ์ ๋๊ณ , *(arr1.data()), *(arr1.data() + 1) ์ด๋ ๊ฒ ์ ๊ทผํ ์ ์๋ค.
์ฌ์ฉ
#include<iostream>
#include<array>
using namespace std;
int main()
{
array<int, 5> arr1 = { 1,2,3,4,5 };
cout << arr1[2] << endl; // ๊ฒฐ๊ณผ: 3
array<double, 3> arr2;
cout << arr2[2] << endl; // ๊ฒฐ๊ณผ: ์ฐ๋ ๊ธฐ ๊ฐ
array<int, 6> arr3 = {};
for (int temp : arr3)
{
cout << temp << endl; // ๊ฒฐ๊ณผ: ๋ชจ๋ 0
}
array<int, 6> arr4 = {1};
for (int temp : arr4)
{
cout << temp << endl; // ๊ฒฐ๊ณผ: 1, 0, 0, 0, 0, 0
}
cout << *(arr1.data()) << *(arr1.data() + 1) << endl; // ๊ฒฐ๊ณผ: 1, 2
return 0;
}
2. ๋ฒกํฐ(vector)
ํค๋ํ์ผ <vector>, namespace std
template <typename T> class vector;
ํน์ง
๋์ ๋ฐฐ์ด์ด๋ค. ๋ฐฐ์ด(array)๊ณผ ๋น์ทํ๋ฐ, ๊ณ ์ ๋ ํฌ๊ธฐ๊ฐ ์๋๋ผ๋ ์ฐจ์ด๊ฐ ์๋ค.
- ๊ณ ์ ๋ ํฌ๊ธฐ๊ฐ ์๋๋ค. ์์์ ์ถ๊ฐ๋ ์ญ์ ๊ฐ ๊ฐ๋ฅํ๋ค.
-
๊ฐ๋ค์ด ๋ฉ๋ชจ๋ฆฌ ์์์ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋์ด ์๋ค.
-
์ค๊ฐ ์ฝ์ /์ญ์ ์ฝ์ ์ด๋ ์ญ์ ์์น ๋ค์ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ํ ์นธ์ฉ ๋ค๋ก ๋ฐ๊ฑฐ๋ ์์ผ๋ก ๋น๊ฒจ์ผ ํ๊ธฐ ๋๋ฌธ์ ๋๋ฆฌ๋ค.
-
์ฒ์/๋ ์ฝ์ /์ญ์ ์ฒ์์ ์ค๊ฐ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋๋ฆฌ๋ค. ๋์ ๋ฐ๊ฑฐ๋ ๋น๊ธฐ์ง ์์๋ ๋ผ์ ๋น ๋ฅด๋ค.
- ์์ ์ ๊ทผ(Random Access)์ด ๊ฐ๋ฅํ๋ค.
๋์ ์๋ฆฌ
- (์ฌ์ ๋ถ์ ๋๊ณ ) ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ค.
- ์ฌ์ ๋ถ๊น์ง ๊ฝ ์ฐผ์ผ๋ฉด, ๋ ํฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํด์ ์ด์ฌํ๋ค.
size: ์ค์ ์ฌ์ฉ ๋ฐ์ดํฐ ๊ฐ์
capacity: ์ฌ์ ๋ถ์ ํฌํจํ ์ฉ๋ ๊ฐ์
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> v1;
for (int i = 0; i < 1000; i++)
{
v1.push_back(10);
cout << v1.size() << " " << v1.capacity() << endl;
}
return 0;
}
size๋ 1๊ฐ์ฉ ๋๊ณ , size๊ฐ capacity๋ฅผ ๋๊ฒ ๋๋ฉด capacity๋ 1.5๋ฐฐ ๋์ด๋๋ค. (์ปดํ์ผ๋ฌ์ ๋ฐ๋ผ ๋ค๋ฅผ ์๋)
resize()๋ฅผ ํตํด size๋ฅผ (capacity๋ ํจ๊ป ์ฆ๊ฐ), reserve()๋ฅผ ํตํด capacity๋ฅผ ๋ฏธ๋ฆฌ ํฌ๊ฒ ๋ง๋ค ์ ์๋ค. ๋ฐ์ดํฐ ์ด์ฌ๋ฅผ ๋ง์ ์ ์๋ค.
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> v1;
v1.resize(1000);
cout << v1.size() << " " << v1.capacity() << endl; // 1000, 1000
return 0;
}
๊ทผ๋ฐ ์ด๋ ๊ฒ ํ๋ฉด ์ด๋ฏธ size๊ฐ 1000์ด๋ผ push_backํ๋ฉด 1001 ๋๋ค.
#include<iostream>
#include<vector>
using namespace std;
int main()
{
vector<int> v1;
v1.reserve(1000);
cout << v1.size() << " " << v1.capacity() << endl; // 0, 1000
return 0;
}
capacity ๋์ด๋ ์ํ์์ size ์ค์ด๋ค์ด๋ capacity๋ ์๋์ผ๋ก ์ค์ด๋ค์ง ์๋๋ค. reserve()๋ก๋ ์ค์ด๋ค์ง ์๋๋ค. (swapํ๋ ๋ฐฉ๋ฒ์ผ๋ก capacity ๋ฎ์ถ๋ ๋ฐฉ๋ฒ์ด ์๊ธด ํ๋ค.)
์ฌ์ฉ
vector
3. ๋ฆฌ์คํธ(list)
ํค๋ํ์ผ <list>, namespace std
template <typename T> class list;
ํน์ง
- ๋ ธ๋ ๊ธฐ๋ฐ ์ปจํ ์ด๋๋ค.
class Node
{
public:
Node* _next;
Node* _prev;
int _data;
};
๋์ ์๋ฆฌ
์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ. ๋ฐ์ดํฐ๊ฐ ๋ฉ๋ชจ๋ฆฌ ์์ ๋น์ฐ์์ ์ผ๋ก ์ ์ฅ๋๋ค.
-
์ค๊ฐ ์ฝ์ /์ญ์ ์ด์ ๋ ธ๋์ ๋ค์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๋ค๋ง ๋ฐ๊ฟ์ฃผ๋ฉด ๋๋๊น ๋น ๋ฆ. ๊ทผ๋ฐ ์ฌ์ค์ ์์ ์ ๊ทผ์ด ์ ๋๋ฏ๋ก ๊ทธ ์์น๋ก ๊ฐ๋ ๊ฒ ๋๋ฆผ.
-
์ฒ์/๋ ์ฝ์ /์ญ์ ์ค๊ฐ ์ฝ์ /์ญ์ ์ ๋์ผ.
-
์์ ์ ๊ทผ ์์ ์ ๊ทผ ๋ถ๊ฐ๋ฅํ๋ค.
์ฌ์ฉ
- ๋ฒกํฐ๋ ๋ค๋ฅด๊ฒ ์ฝ์
/์ญ์ ๊ฐ ํจ์จ์ ์ด๋ค ๋ณด๋ ํน์ ๊ฐ์ ๊ฐ์ง๋ ๋ฐ์ดํฐ๋ฅผ ์์ ๋ remove()๊ฐ ์๋ค.
li.remove(10); // 10 ๋ชจ๋ ์ ๊ฑฐ
Leave a comment