Language/C++

C++ STL ๋ฒกํ„ฐ(vector) ์„ค๋ช… ๋ฐ ์‚ฌ์šฉ๋ฒ•

meeeeejin 2020. 6. 2. 20:44

C++ STL ์ปจํ…Œ์ด๋„ˆ - ๋ฒกํ„ฐ (std::vector)

vector๋Š” ํ—ค๋”ํŒŒ์ผ <vector>์— ์ •์˜๋˜์–ด ์žˆ๋Š” ์ปจํ…Œ์ด๋„ˆ์˜ ํ•œ ์ข…๋ฅ˜์ž…๋‹ˆ๋‹ค. ์ปจํ…Œ์ด๋„ˆ๋Š” C++ STL์—์„œ ์ž„์˜ ํƒ€์ž…์˜ ๊ฐ์ฒด๋ฅผ ๋ณด๊ด€ํ•  ์ˆ˜ ์žˆ๋Š” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ๋งํ•ฉ๋‹ˆ๋‹ค. vector๋ฅผ ๊ฐ„๋‹จํ•˜๊ฒŒ ๋งํ•˜์ž๋ฉด ๊ฐ€๋ณ€ ๊ธธ์ด ๋ฐฐ์—ด์ด๋ผ๊ณ  ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋•Œ, ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น์€ ์ž๋™์œผ๋กœ ์ด๋ค„์ง‘๋‹ˆ๋‹ค. 

 

vector ์ปจํ…Œ์ด๋„ˆ๋Š” ๋™์  ๋ฐฐ์—ด๋กœ ๊ตฌํ˜„๋˜๋Š”๋ฐ, ๊ฐ๊ฐ์˜ ์›์†Œ๋“ค์ด ๋ฉ”๋ชจ๋ฆฌ ์ƒ์—์„œ ์—ฐ์†์ ์œผ๋กœ ์กด์žฌํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ vector ์ปจํ…Œ์ด๋„ˆ์˜ ์›์†Œ๋ฅผ ์ฐธ์กฐํ•  ๋•Œ ๋ฐ˜๋ณต์ž(iterator)๋ฅผ ์ด์šฉํ•ด์„œ ์ˆœ์ฐจ์ ์œผ๋กœ ์ฐธ์กฐํ•˜๊ฑฐ๋‚˜ ์ฒซ ๋ฒˆ์งธ ์›์†Œ๋ถ€ํ„ฐ์˜ ์ƒ๋Œ€์  ๊ฑฐ๋ฆฌ๋ฅผ ์ด์šฉํ•˜์—ฌ ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. 

 

 

vector์˜ ์žฅ์ 

  •  ๊ฐ๊ฐ์˜ ์›์†Œ๋ฅผ ์ธ๋ฑ์Šค(index) ๊ฐ’์œผ๋กœ ๋ฐ”๋กœ ์ฐธ์กฐ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค. 

  •  ์›์†Œ๋“ค์„ ์ž„์˜์˜ ์ˆœ์„œ๋กœ ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. 

  •  ๋ฒกํ„ฐ ๋์— ์ƒˆ๋กœ์šด ์›์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๊ฑฐ๋‚˜ ์ œ๊ฑฐํ•˜๊ธฐ ์šฉ์ดํ•ฉ๋‹ˆ๋‹ค. 

 

 

vector์˜ ์ƒ์„ฑ์ž์™€ ์—ฐ์‚ฐ์ž

๊ธฐ๋ณธ์ ์ธ vector์˜ ์„ ์–ธ์€ vector<์ž๋ฃŒํ˜•> ๋ณ€์ˆ˜์ด๋ฆ„ ์ž…๋‹ˆ๋‹ค. 

ex) vector<int> v;

 

๊ทธ ์™ธ์˜ ์ƒ์„ฑ์ž๋“ค์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค. 

  • vector<int> v;

    // ๋น„์–ด์žˆ๋Š” vector v๋ฅผ ์ƒ์„ฑ

  • vector<int> v(5);

    // ์›์†Œ์˜ ๊ฐœ์ˆ˜๊ฐ€ 5๊ฐœ์ธ vector v๋ฅผ ์ƒ์„ฑ (์›์†Œ๋Š” 0์œผ๋กœ ์ดˆ๊ธฐํ™”)

  • vector<int> v(5, 2);

    // ์›์†Œ์˜ ๊ฐœ์ˆ˜๊ฐ€ 5๊ฐœ์ธ vector v๋ฅผ ์ƒ์„ฑํ•˜๊ณ  ์›์†Œ๋ฅผ 2๋กœ ์ดˆ๊ธฐํ™”

  • vector<int> v2(v1);

    // v1์„ ๋ณต์‚ฌํ•ด์„œ vector v2๋ฅผ ์ƒ์„ฑ

 

๋˜ํ•œ ๋‘ vector ์‚ฌ์ด์— ์—ฐ์‚ฐ์ž  ==, !=, <, >, <=, >= ๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. 

 

 

vector์˜ ๋ฉค๋ฒ„ ํ•จ์ˆ˜

  • v.assign(n, x)
    // v์— n๊ฐœ์˜ ์›์†Œ x๋ฅผ ํ• ๋‹น

  • v.at(i)
    // v์˜ i๋ฒˆ์งธ ์›์†Œ ์ฐธ์กฐ

    // v[i]๋ณด๋‹ค ์†๋„๋Š” ๋Š๋ฆฌ์ง€๋งŒ ๋ฒ”์œ„๋ฅผ ์ ๊ฒ€ํ•จ

  • v[i]
    // v์˜ i๋ฒˆ์งธ ์›์†Œ ์ฐธ์กฐ
    // v.at(i)๋ณด๋‹ค ๋น ๋ฅด์ง€๋งŒ ๋ฒ”์œ„๋ฅผ ์ ๊ฒ€ํ•˜์ง€ ์•Š์Œ

  • v.front()
    // v์˜ ์ฒซ ๋ฒˆ์งธ ์›์†Œ ์ฐธ์กฐ

  • v.back()
    // v์˜ ๋งˆ์ง€๋ง‰ ์›์†Œ ์ฐธ์กฐ

  • p = v.begin()
    // p๋Š” v์˜ ์ฒซ๋ฒˆ์งธ ์›์†Œ๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” ๋ฐ˜๋ณต์ž(iterator)

  • p = v.end()
    // p๋Š” v์˜ ๋งˆ์ง€๋ง‰ ์›์†Œ ๋‹ค์Œ์„ ๊ฐ€๋ฆฌํ‚ค๋Š” iterator

  • p = v.rbegin()
    // p๋Š” v์˜ reverse begin(v๋ฅผ ๊ฑฐ๊พธ๋กœ ๋’ค์ง‘์—ˆ์„ ๋•Œ ์ฒซ๋ฒˆ์งธ ์›์†Œ)์„ ๊ฐ€๋ฆฌํ‚ค๋Š” iterator

  • p = v.rend()
    // p๋Š” v์˜ reverse end๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” iterator

  • v.push_back(x)
    // v์— ๋งจ ๋’ค์— ์›์†Œ x๋ฅผ ์‚ฝ์ž…

  • v.pop_back()
    // v์˜ ๋งˆ์ง€๋ง‰ ์›์†Œ ์ œ๊ฑฐ

  • v.clear()
    // v์˜ ๋ชจ๋“  ์›์†Œ ์ œ๊ฑฐ

    // ์›์†Œ๋งŒ ์ œ๊ฑฐํ•˜๊ณ  ๋ฉ”๋ชจ๋ฆฌ๋Š” ๋‚จ์•„์žˆ์Œ => size๋Š” ์ค„์–ด๋“ค์ง€๋งŒ capacity๋Š” ๊ทธ๋Œ€๋กœ

  • v.reserve(n)
    // n๊ฐœ์˜ ์›์†Œ๋ฅผ ์ €์žฅํ•  ๊ณต๊ฐ„ ์˜ˆ์•ฝ

  • v.resize(n)
    // v์˜ ํฌ๊ธฐ๋ฅผ n์œผ๋กœ ๋ณ€๊ฒฝํ•˜๊ณ  ํ™•์žฅ๋˜๋Š” ๊ณต๊ฐ„์˜ ๊ฐ’์„ ๊ธฐ๋ณธ๊ฐ’(default: 0)์œผ๋กœ ์ดˆ๊ธฐํ™”

  • v.resize(n, x)
    // v์˜ ํฌ๊ธฐ๋ฅผ n์œผ๋กœ ๋ณ€๊ฒฝํ•˜๊ณ  ํ™•์žฅ๋˜๋Š” ๊ณต๊ฐ„์˜ ๊ฐ’์„ x๋กœ ์ดˆ๊ธฐํ™”

  • v.size()
    // v์˜ ์›์†Œ์˜ ๊ฐœ์ˆ˜ ๋ฐ˜ํ™˜

  • v.capacity()
    // v์— ํ• ๋‹น๋œ ๊ณต๊ฐ„์˜ ํฌ๊ธฐ ๋ฐ˜ํ™˜

  • v.swap(v2)
    // v์™€ v2๋ฅผ swap (capacity ํฌํ•จํ•ด์„œ ๋‹ค swap)

  • p = v.insert(i, x)
    // v์˜ i๋ฒˆ์งธ์— ์›์†Œ x๋ฅผ ์‚ฝ์ž…

    // p๋Š” ์‚ฝ์ž…ํ•œ ์›์†Œ๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” iterator

  • v.insert(i, n, x)
    // v์— i๋ฒˆ์งธ์— n๊ฐœ์˜ ์›์†Œ x๋ฅผ ์‚ฝ์ž…
    // ๊ทธ ์ž๋ฆฌ์— ์›๋ž˜ ์žˆ๋˜ ์›์†Œ๋“ค์€ ๋’ค๋กœ ๋ฐ€๋ฆผ

  • q = v.erase(p)
    // p๊ฐ€ ๊ฐ€๋ฆฌํ‚ค๋Š” ์›์†Œ ์ œ๊ฑฐ

    // q๋Š” ๋‹ค์Œ ์›์†Œ๋ฅผ ๊ฐ€๋ฆฌํ‚ค๋Š” iterator

  • v.empty()
    // v๊ฐ€ ๋น„์—ˆ์œผ๋ฉด(v.size() == 0) true ๋ฐ˜ํ™˜

 

 

vector์˜ ๋ฉค๋ฒ„ ํ˜•์‹

  • iterator

    // ๋ฐ˜๋ณต์ž ํ˜•์‹

  • const_iterator

    // const ๋ฐ˜๋ณต์ž ํ˜•์‹

  • reverse_iterator

    // ์—ญ ๋ฐ˜๋ณต์ž ํ˜•์‹

  • size_type

    // index ๋˜๋Š” ์›์†Œ์˜ ๊ฐœ์ˆ˜ ๋“ฑ์˜ ํ˜•์‹

  • value_type

    // ์›์†Œ์˜ ํ˜•์‹

 

 

vector ์‚ฌ์šฉ ์˜ˆ์‹œ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include <vector>
using namespace std;
 
int main() {
    vector<int> v;    // intํ˜• vector v ์„ ์–ธ
 
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    v.push_back(4);
    v.push_back(5);
 
    cout << "v์˜ ์›์†Œ: ";
    for (vector<int>::size_type i = 0; i < v.size(); i++)
        cout << v[i] << ' ';
    cout << endl;
 
    cout << "v์˜ size: " << v.size() << endl;
    cout << "v์˜ capacity: " << v.capacity() << endl;
 
    return 0;
}
cs

 

---------------์ถœ๋ ฅ--------------

 v์˜ ์›์†Œ: 1 2 3 4 5

 v์˜ size: 5

 v์˜ capacity: 6

 

 

 

 

์ฐธ๊ณ : https://hyeonstorage.tistory.com/324

https://blockdmask.tistory.com/7

 

728x90