`vector` 클래스

아티클
09/02/2023

C++ 표준 라이브러리 벡터 클래스는 시퀀스 컨테이너에 대한 클래스 템플릿입니다. 벡터는 지정된 형식의 요소를 선형 배열에 저장하고 모든 요소에 대한 빠른 임의 액세스를 허용합니다. 임의 액세스 성능이 프리미엄인 경우 벡터는 시퀀스에 대한 기본 컨테이너입니다.

구문

template <class Type, class Allocator = allocator<Type>>
class vector

매개 변수

Type
벡터에 저장되는 요소 데이터 형식입니다.

Allocator
벡터의 메모리 할당 및 할당 취소에 대한 세부 정보를 캡슐화하는 저장된 할당자 개체를 나타내는 형식입니다. 이 인수는 선택 사항이며 기본값은 allocator<Type>입니다.

설명

벡터를 사용하면 시퀀스 끝에서 상수 시간 삽입 및 삭제할 수 있습니다. 벡터 중간에 요소를 삽입하거나 삭제하려면 선형 시간이 필요합니다. deque 클래스 컨테이너는 시퀀스의 시작과 끝에서 삽입 및 삭제 시 더 빠릅니다. list 클래스 컨테이너는 시퀀스 내의 모든 위치에서 삽입 및 삭제 시 더 빠릅니다.

멤버 함수가 벡터 개체에 포함되는 시퀀스를 현재 스토리지 용량보다 더 크게 늘려야 할 때 벡터 다시 할당이 수행됩니다. 다른 삽입 및 지우기에서 시퀀스 내의 여러 스토리지 주소가 변경될 수 있습니다. 이러한 모든 경우 시퀀스의 변경되는 부분을 가리키는 반복기 또는 참조가 올바르지 않은 상태가 됩니다. 재할당이 수행되지 않으면 삽입/삭제 지점 앞의 반복기와 참조만 올바른 상태로 유지됩니다.

클래스는 vector<bool> 형식 요소에 대한 클래스 템플릿 벡터의 전체 특수화입니다bool. 특수화에서 사용하는 기본 형식에 대한 할당자가 있습니다.

vector<bool> 참조 클래스는 개체 내에서 요소(단일 비트)에 대한 참조를 제공할 수 있는 중첩 클래스입니다vector<bool>.

멤버

생성자

이름	설명
`vector`	특정 크기의 벡터 또는 특정 값의 요소나 특정 `allocator`가 포함된 벡터를 생성하거나 다른 벡터의 복사본으로 벡터를 생성합니다.

Typedef

이름	설명
`[allocator_type]`(#allocator_type)	벡터 개체의 `allocator` 클래스를 나타내는 형식입니다.
`const_iterator`	벡터에 있는 `const` 요소를 읽을 수 있는 임의 액세스 반복기를 제공하는 형식입니다.
`const_pointer`	벡터의 `const` 요소에 대한 포인터를 제공하는 형식입니다.
`const_reference`	벡터에 저장된 요소에 대한 참조를 `const` 제공하는 형식입니다. 읽기 및 작업 수행 `const` 에 사용됩니다.
`const_reverse_iterator`	벡터의 모든 `const` 요소를 읽을 수 있는 임의 액세스 반복기를 제공하는 형식입니다.
`difference_type`	벡터 내 두 요소 주소 간의 차이를 제공하는 형식입니다.
`iterator`	벡터에 있는 모든 요소를 읽거나 수정할 수 있는 임의 액세스 반복기를 제공하는 형식입니다.
`pointer`	벡터에서 요소에 대한 포인터를 제공하는 형식입니다.
`reference`	벡터에 저장된 요소에 대한 참조를 제공하는 형식입니다.
`reverse_iterator`	역방향 벡터에 있는 모든 요소를 읽거나 수정할 수 있는 임의 액세스 반복기를 제공하는 형식입니다.
`size_type`	벡터의 요소 수를 계산하는 형식입니다.
`value_type`	벡터에 저장된 데이터 형식을 나타내는 형식입니다.

함수

속성	설명
`assign`	벡터를 지우고 지정된 요소를 빈 벡터에 복사합니다.
`at`	벡터의 지정된 위치에 있는 요소에 대한 참조를 반환합니다.
`back`	벡터의 마지막 요소에 대한 참조를 반환합니다.
`begin`	벡터의 첫 번째 요소에 대한 임의 액세스 반복기를 반환합니다.
`capacity`	스토리지를 더 할당하지 않고 벡터가 포함할 수 있는 요소의 수를 반환합니다.
`cbegin`	벡터의 첫 번째 요소에 대한 임의 액세스 const 반복기를 반환합니다.
`cend`	벡터 끝의 바로 다음을 가리키는 임의 액세스 const 반복기를 반환합니다.
`crbegin`	역방향 벡터의 첫 번째 요소에 대해 const 반복기를 반환합니다.
`crend`	역방향 벡터 끝에 대해 const 반복기를 반환합니다.
`clear`	벡터의 요소를 지웁니다.
`data`	벡터의 첫 번째 요소에 대한 포인터를 반환합니다.
`emplace`	내부에서 생성된 요소를 벡터의 지정된 위치에 삽입합니다.
`emplace_back`	내부에서 생성된 요소를 벡터의 끝에 추가합니다.
`empty`	벡터 컨테이너가 비어 있는지 테스트합니다.
`end`	벡터 끝을 가리키는 임의 액세스 반복기를 반환합니다.
`erase`	벡터의 지정된 위치에서 요소 또는 요소 범위를 제거합니다.
`front`	벡터의 첫 번째 요소에 대한 참조를 반환합니다.
`get_allocator`	벡터에서 사용하는 `allocator` 클래스에 개체를 반환합니다.
`insert`	지정된 위치에 있는 요소 또는 여러 요소를 벡터에 삽입합니다.
`max_size`	벡터의 최대 길이를 반환합니다.
`pop_back`	벡터의 끝에 있는 요소를 삭제합니다.
`push_back`	벡터 끝에 요소를 추가합니다.
`rbegin`	역방향 벡터의 첫 번째 요소에 대한 반복기를 반환합니다.
`rend`	역방향 벡터 끝에 대해 반복기를 반환합니다.
`reserve`	벡터 개체에 대한 스토리지의 최소 길이를 예약합니다.
`resize`	벡터의 새 크기를 지정합니다.
`shrink_to_fit`	여분의 용량을 삭제합니다.
`size`	벡터에 있는 요소 수를 반환합니다.
`swap`	두 벡터의 요소를 교환합니다.

연산자

이름	설명
`operator[]`	지정된 위치에서 벡터 요소에 참조를 반환합니다.
`operator=`	벡터의 요소를 다른 벡터의 복사본으로 바꿉니다.

`allocator_type`

벡터 개체의 할당자 클래스를 나타내는 형식입니다.

typedef Allocator allocator_type;

설명

allocator_type은 템플릿 매개 변수 Allocator의 동의어입니다.

예시

를 사용하는 allocator_type예제는 예제 get_allocator 를 참조하세요.

`assign`

벡터를 지우고 지정된 요소를 빈 벡터에 복사합니다.

void assign(size_type count, const Type& value);
void assign(initializer_list<Type> init_list);

template <class InputIterator>
void assign(InputIterator first, InputIterator last);

매개 변수

first
복사할 요소의 범위에서 첫 번째 요소의 위치입니다.

last
복사할 요소의 범위를 벗어난 첫 번째 요소의 위치입니다.

count
벡터에 삽입되는 요소의 복사본 수입니다.

value
벡터에 삽입되는 요소의 값입니다.

init_list
삽입할 요소를 포함하는 initializer_list입니다.

설명

assign 먼저 벡터의 기존 요소를 지웁니다. 그런 다음 원래 assign 벡터의 지정된 요소 범위를 벡터에 삽입하거나 지정된 새 값 요소의 복사본을 벡터에 삽입합니다.

예시

/ vector_assign.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> v1, v2, v3;

    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);
    v1.push_back(50);

    cout << "v1 = ";
    for (auto& v : v1){
        cout << v << " ";
    }
    cout << endl;

    v2.assign(v1.begin(), v1.end());
    cout << "v2 = ";
    for (auto& v : v2){
        cout << v << " ";
    }
    cout << endl;

    v3.assign(7, 4);
    cout << "v3 = ";
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;

    v3.assign({ 5, 6, 7 });
    for (auto& v : v3){
        cout << v << " ";
    }
    cout << endl;
}

`at`

벡터의 지정된 위치에 있는 요소에 대한 참조를 반환합니다.

reference at(size_type position);

const_reference at(size_type position) const;

매개 변수

position
벡터에서 참조할 요소의 아래 첨자 또는 위치 번호입니다.

반환 값

인수에서 아래 첨자로 설정된 요소에 대한 참조입니다. 벡터 at 크기보다 크면 position 예외를 throw합니다.

설명

반환 값 at 이 할당 const_reference된 경우 벡터 개체를 수정할 수 없습니다. at의 반환 값이 reference에 할당되는 경우에는 vector 개체를 수정할 수 있습니다.

예시

// vector_at.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const int &i = v1.at( 0 );
   int &j = v1.at( 1 );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`back`

벡터의 마지막 요소에 대한 참조를 반환합니다.

reference back();

const_reference back() const;

반환 값

벡터의 마지막 요소입니다. 벡터가 비어 있으면 반환 값이 정의되지 않습니다.

설명

반환 값 back 이 할당 const_reference된 경우 벡터 개체를 수정할 수 없습니다. back의 반환 값이 reference에 할당되는 경우에는 vector 개체를 수정할 수 있습니다.

정의된 1 또는 2를 사용하여 _ITERATOR_DEBUG_LEVEL 컴파일하는 경우 빈 벡터의 요소에 액세스하려고 하면 런타임 오류가 발생합니다. 자세한 내용은 확인된 반복기를 참조 하세요.

예시

// vector_back.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main() {
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.back( );
   const int& ii = v1.front( );

   cout << "The last integer of v1 is " << i << endl;
   i--;
   cout << "The next-to-last integer of v1 is "<< ii << endl;
}

`begin`

벡터의 첫 번째 요소에 대한 임의 액세스 반복기를 반환합니다.

const_iterator begin() const;

iterator begin();

반환 값

vector의 첫 번째 요소 또는 빈 vector 다음의 위치 주소를 지정하는 임의 액세스 반복기입니다. 항상 반환 vector::end 된 값을 비교하여 유효한지 확인합니다.

설명

반환 값 begin 이 할당 vector::const_iterator된 경우 개체를 vector 수정할 수 없습니다. 반환 값 begin 이 할당된 경우 개체를 vector::iteratorvector 수정할 수 있습니다.

예시

// vector_begin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::iterator c1_Iter;
    vector<int>::const_iterator c1_cIter;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_Iter = c1.begin();
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_Iter = c1.begin();
    *c1_Iter = 20;
    for (; c1_Iter != c1.end(); c1_Iter++)
    {
        cout << " " << *c1_Iter;
    }
    cout << endl;

    // The following line would be an error because iterator is const
    // *c1_cIter = 200;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`capacity`

스토리지를 더 할당하지 않고 벡터가 포함할 수 있는 요소의 수를 반환합니다.

size_type capacity() const;

반환 값

벡터에 할당된 스토리지의 현재 길이입니다.

설명

이를 수용하기에 충분한 메모리가 할당된 경우 멤버 함수 resize 가 더 효율적입니다. 멤버 함수 reserve 를 사용하여 할당된 메모리 양을 지정합니다.

예시

// vector_capacity.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 1 );
   cout << "The length of storage allocated is "
        << v1.capacity( ) << "." << endl;

   v1.push_back( 2 );
   cout << "The length of storage allocated is now "
        << v1.capacity( ) << "." << endl;
}

The length of storage allocated is 1.
The length of storage allocated is now 2.

`cbegin`

범위의 첫 번째 요소를 주소 지정하는 const 반복기를 반환합니다.

const_iterator cbegin() const;

반환 값

범위의 첫 번째 요소 또는 빈 범위의 끝 바로 다음 위치를 가리키는 const 임의 액세스 반복기입니다(빈 범위의 경우 cbegin() == cend()).

설명

반환 값을 cbegin사용하면 범위의 요소를 수정할 수 없습니다.

begin() 멤버 함수 대신 이 멤버 함수를 사용하여 반환 값이 const_iterator임을 보장할 수 있습니다. 일반적으로 다음 예제와 같이 형식 추론 키워드(keyword) 함께 auto 사용됩니다. 이 예제에서는 Container가 begin() 및 cbegin()를 지원하는 수정 가능(비const)한 컨테이너로 가정합니다.

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

const 벡터의 마지막 요소 다음 요소를 가리키는 마지막 반복기를 반환합니다.

const_iterator cend() const;

반환 값

const 벡터에 대한 마지막 반복기입니다. 벡터의 마지막 요소 다음에 있는 요소를 가리킵니다. 해당 요소는 자리 표시자이며 역참조해서는 안 됩니다. 비교에만 사용합니다. 벡터가 비어 vector::cend() == vector::cbegin()있으면 .

설명

cend는 반복기가 범위 끝을 통과했는지 여부를 테스트하는 데 사용됩니다.

end() 멤버 함수 대신 이 멤버 함수를 사용하여 반환 값이 const_iterator임을 보장할 수 있습니다. 일반적으로 다음 예제와 같이 형식 추론 키워드(keyword) 함께 auto 사용됩니다. 이 예제에서는 Container가 end() 및 cend()를 지원하는 수정 가능(비const)한 컨테이너로 가정합니다.

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

반환된 cend 값은 역참조하면 안 됩니다. 비교에만 사용합니다.

`clear`

벡터의 요소를 지웁니다.

void clear();

예시

// vector_clear.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "The size of v1 is " << v1.size( ) << endl;
   v1.clear( );
   cout << "The size of v1 after clearing is " << v1.size( ) << endl;
}

The size of v1 is 3
The size of v1 after clearing is 0

`const_iterator`

벡터에 있는 const 요소를 읽을 수 있는 임의 액세스 반복기를 제공하는 형식입니다.

typedef implementation-defined const_iterator;

설명

형식 const_iterator 을 사용하여 요소의 값을 수정할 수 없습니다.

예시

const_iterator를 사용하는 예제는 back의 예제를 참조하세요.

`const_pointer`

벡터의 const 요소에 대한 포인터를 제공하는 형식입니다.

typedef typename Allocator::const_pointer const_pointer;

설명

형식 const_pointer 을 사용하여 요소의 값을 수정할 수 없습니다.

iterator는 벡터 요소에 액세스하는 데 사용되는 경우가 더 많습니다.

`const_reference`

벡터에 저장된 요소에 대한 참조를 const 제공하는 형식입니다. 읽기 및 작업 수행 const 에 사용됩니다.

typedef typename Allocator::const_reference const_reference;

설명

형식 const_reference 을 사용하여 요소의 값을 수정할 수 없습니다.

예시

// vector_const_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   const vector <int> v2 = v1;
   const int &i = v2.front( );
   const int &j = v2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

   // The following line would cause an error as v2 is const
   // v2.push_back( 30 );
}

The first element is 10
The second element is 20

`const_reverse_iterator`

벡터의 모든 const 요소를 읽을 수 있는 임의 액세스 반복기를 제공하는 형식입니다.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

설명

형식 const_reverse_iterator 은 요소의 값을 수정할 수 없으며 벡터를 역방향으로 반복하는 데 사용됩니다.

예시

반복기를 선언하고 사용하는 방법의 예제를 참조 rbegin 하세요.

`crbegin`

역방향 벡터의 첫 번째 요소에 대해 const 반복기를 반환합니다.

const_reverse_iterator crbegin() const;

반환 값

역방향의 첫 번째 요소에 주소를 지정하거나 역방향 vector 의 마지막 요소인 주소를 지정하는 const 역방향 임의 vector액세스 반복기입니다.

설명

반환 값 crbegin이 있는 경우 개체를 vector 수정할 수 없습니다.

예시

// vector_crbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`crend`

const 역방향 벡터의 마지막 요소 다음 요소를 가리키는 마지막 역방향 반복기를 반환합니다.

const_reverse_iterator crend() const;

반환 값

const 역방향 벡터에 대한 역방향 마지막 반복기입니다. 역방향 벡터의 마지막 요소 다음에 있는 요소를 가리킵니다. 이 요소는 역방향이 아닌 벡터의 첫 번째 요소 앞의 요소와 동일합니다. 해당 요소는 자리 표시자이며 역참조해서는 안 됩니다. 비교에만 사용합니다.

설명

crend는 .와 함께 사용되는 것처럼 vector::cend 역방향 vector 으로 vector사용됩니다.

반환 값 crend (적절하게 감소)을 사용하면 개체를 vector 수정할 수 없습니다.

crend를 사용하여 역방향 반복기가 vector 끝에 도달했는지 여부를 테스트할 수 있습니다.

반환된 crend 값은 역참조하면 안 됩니다. 비교에만 사용합니다.

예시

// vector_crend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`data`

벡터의 첫 번째 요소에 대한 포인터를 반환합니다.

const_pointer data() const;

pointer data();

반환 값

빈 vector위치 다음에 나오는 위치 또는 첫 번째 요소 vector 에 대한 포인터입니다.

예시

// vector_data.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector<int> c1;
    vector<int>::pointer c1_ptr;
    vector<int>::const_pointer c1_cPtr;

    c1.push_back(1);
    c1.push_back(2);

    cout << "The vector c1 contains elements:";
    c1_cPtr = c1.data();
    for (size_t n = c1.size(); 0 < n; --n, c1_cPtr++)
    {
        cout << " " << *c1_cPtr;
    }
    cout << endl;

    cout << "The vector c1 now contains elements:";
    c1_ptr = c1.data();
    *c1_ptr = 20;
    for (size_t n = c1.size(); 0 < n; --n, c1_ptr++)
    {
        cout << " " << *c1_ptr;
    }
    cout << endl;
}

The vector c1 contains elements: 1 2
The vector c1 now contains elements: 20 2

`difference_type`

동일한 벡터 내의 요소를 참조하는 두 반복기 간의 차이를 제공하는 형식입니다.

typedef typename Allocator::difference_type difference_type;

설명

요소에 대한 포인터는 요소의 주소를 포함하므로, difference_type은 두 포인터 사이의 요소 수로도 설명할 수 있습니다.

iterator는 벡터 요소에 액세스하는 데 사용되는 경우가 더 많습니다.

예시

// vector_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <vector>
#include <algorithm>

int main( )
{
   using namespace std;

   vector <int> c1;
   vector <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 30 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 10 );
   c1.push_back( 30 );
   c1.push_back( 20 );

   c1_Iter = c1.begin( );
   c2_Iter = c1.end( );

   vector <int>::difference_type   df_typ1, df_typ2, df_typ3;

   df_typ1 = count( c1_Iter, c2_Iter, 10 );
   df_typ2 = count( c1_Iter, c2_Iter, 20 );
   df_typ3 = count( c1_Iter, c2_Iter, 30 );
   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";
   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";
   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";
}

The number '10' is in c1 collection 1 times.
The number '20' is in c1 collection 2 times.
The number '30' is in c1 collection 3 times.

`emplace`

내부에서 생성된 요소를 벡터의 지정된 위치에 삽입합니다.

template <class... Types>
iterator emplace(
    const_iterator position,
    Types&&... args);

매개 변수

position
vector 첫 번째 요소가 삽입되는 위치입니다.

args
생성자 인수입니다. 이 함수는 제공되는 인수에 따라 호출할 생성자 오버로드를 유추합니다.

반환 값

이 함수는 새 요소를 vector에 삽입한 위치를 가리키는 반복기를 반환합니다.

설명

모든 삽입 작업은 비용이 많이 들 수 있습니다. 성능에 대한 설명은 클래스를 참조하세요.vectorvector

예시

// vector_emplace.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.emplace( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
vv1[0] = 10 20 30

`emplace_back`

내부에서 생성된 요소를 벡터의 끝에 추가합니다.

template <class... Types>
void emplace_back(Types&&... args);

매개 변수

args
생성자 인수입니다. 이 함수는 제공되는 인수에 따라 호출할 생성자 오버로드를 유추합니다.

예시

#include <vector>
struct obj
{
   obj(int, double) {}
};

int main()
{
   std::vector<obj> v;
   v.emplace_back(1, 3.14); // obj in created in place in the vector
}

`empty`

벡터가 비어 있는지 테스트합니다.

bool empty() const;

반환 값

true 벡터가 비어 있으면 false 벡터가 비어 있지 않으면

예시

// vector_empty.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );

   if ( v1.empty( ) )
      cout << "The vector is empty." << endl;
   else
      cout << "The vector is not empty." << endl;
}

The vector is not empty.

`end`

벡터의 마지막 요소 다음 요소를 가리키는 마지막 반복기를 반환합니다.

iterator end();

const_iterator end() const;

반환 값

벡터에 대한 마지막 반복기입니다. 벡터의 마지막 요소 다음에 있는 요소를 가리킵니다. 해당 요소는 자리 표시자이며 역참조해서는 안 됩니다. 비교에만 사용합니다. 벡터가 비어 vector::end() == vector::begin()있으면 .

설명

반환 값 end 이 형식 const_iterator변수에 할당된 경우 벡터 개체를 수정할 수 없습니다. 반환 값 end 이 형식 iterator의 변수에 할당된 경우 벡터 개체를 수정할 수 있습니다.

예시

// vector_end.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>
int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_Iter = v1.begin( ) ; v1_Iter != v1.end( ) ; v1_Iter++ )
      cout << *v1_Iter << endl;
}

1
2

`erase`

벡터의 지정된 위치에서 요소 또는 요소 범위를 제거합니다.

iterator erase(
    const_iterator position);

iterator erase(
    const_iterator first,
    const_iterator last);

매개 변수

position
벡터에서 제거할 요소의 위치입니다.

first
벡터에서 제거되는 첫 번째 요소의 위치입니다.

last
벡터에서 제거되는 마지막 요소 바로 뒤의 위치입니다.

반환 값

제거되는 요소 뒤에 남아 있는 첫 번째 요소를 지정하는 반복기이거나, 남아 있는 요소가 없는 경우에는 벡터 끝에 대한 포인터입니다.

예시

// vector_erase.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );
   v1.push_back( 40 );
   v1.push_back( 50 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.erase( v1.begin( ) + 1, v1.begin( ) + 3 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
}

v1 = 10 20 30 40 50
v1 = 20 30 40 50
v1 = 20 50

`front`

벡터의 첫 번째 요소에 대한 참조를 반환합니다.

reference front();

const_reference front() const;

반환 값

벡터 개체의 첫 번째 요소에 대한 참조입니다. 벡터가 비어 있으면 반환이 정의되지 않습니다.

설명

반환 값 front 이 할당 const_reference된 경우 벡터 개체를 수정할 수 없습니다. front의 반환 값이 reference에 할당되는 경우에는 vector 개체를 수정할 수 있습니다.

예시

// vector_front.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 11 );

   int& i = v1.front( );
   const int& ii = v1.front( );

   cout << "The first integer of v1 is "<< i << endl;
   // by incrementing i, we move the front reference to the second element
   i++;
   cout << "Now, the first integer of v1 is "<< i << endl;
}

`get_allocator`

벡터를 생성하는 데 사용되는 할당자 개체의 복사본을 반환합니다.

Allocator get_allocator() const;

반환 값

벡터에서 사용되는 할당자입니다.

설명

벡터 클래스의 할당자는 클래스가 스토리지를 관리하는 방법을 지정합니다. C++ 표준 라이브러리 컨테이너 클래스와 함께 제공되는 기본 할당자를 사용하면 대부분의 프로그래밍 요구 사항을 충족할 수 있습니다. 고유한 할당자 클래스를 작성하고 사용하는 것은 고급 C++ 기능입니다.

예시

// vector_get_allocator.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects that use the default allocator.
   vector<int> v1;
   vector<int, allocator<int> > v2 = vector<int, allocator<int> >(allocator<int>( )) ;

   // v3 will use the same allocator class as v1
   vector <int> v3( v1.get_allocator( ) );

   vector<int>::allocator_type xvec = v3.get_allocator( );
   // You can now call functions on the allocator class used by vec
}

`insert`

지정된 위치에 있는 요소 또는 여러 요소 또는 요소 범위를 벡터에 삽입합니다.

iterator insert(
    const_iterator position,
    const Type& value);

iterator insert(
    const_iterator position,
    Type&& value);

void insert(
    const_iterator position,
    size_type count,
    const Type& value);

template <class InputIterator>
void insert(
    const_iterator position,
    InputIterator first,
    InputIterator last);

매개 변수

position
벡터에서 첫 번째 요소를 삽입하는 위치입니다.

value
벡터에 삽입되는 요소의 값입니다.

count
벡터에 삽입되는 요소의 수입니다.

first
복사할 요소의 범위에서 첫 번째 요소의 위치입니다.

last
복사할 요소의 범위를 벗어나는 첫 번째 요소의 위치입니다.

반환 값

처음 두 insert 함수는 새 요소가 벡터에 삽입된 위치를 가리키는 반복기를 반환합니다.

설명

전제 조건으로 first 및 last는 벡터에 대한 반복기가 아니어야 합니다. 그렇지 않으면 동작이 정의되지 않습니다. 모든 삽입 작업은 비용이 많이 들 수 있습니다. 성능에 대한 설명은 클래스를 참조하세요.vectorvector

예시

// vector_insert.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   v1.insert( v1.begin( ) + 1, 40 );
   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;
   v1.insert( v1.begin( ) + 2, 4, 50 );

   cout << "v1 =";
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

   const auto v2 = v1;
   v1.insert( v1.begin( )+1, v2.begin( )+2, v2.begin( )+4 );
   cout << "v1 =";
   for (Iter = v1.begin( ); Iter != v1.end( ); Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a vector of vectors by moving v1
   vector < vector <int> > vv1;

   vv1.insert( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
v1 = 10 40 20 30
v1 = 10 40 50 50 50 50 20 30
v1 = 10 50 50 40 50 50 50 50 20 30
vv1[0] = 10 50 50 40 50 50 50 50 20 30

`iterator`

벡터에 있는 모든 요소를 읽거나 수정할 수 있는 임의 액세스 반복기를 제공하는 형식입니다.

typedef implementation-defined iterator;

설명

형식 iterator 을 사용하여 요소의 값을 수정할 수 있습니다.

예시

에 대한 예제를 begin참조하세요.

`max_size`

벡터의 최대 길이를 반환합니다.

size_type max_size() const;

반환 값

벡터의 최대 허용 길이입니다.

예시

// vector_max_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   i = v1.max_size( );
   cout << "The maximum possible length of the vector is " << i << "." << endl;
}

`operator[]`

지정된 위치에서 벡터 요소에 참조를 반환합니다.

reference operator[](size_type position);

const_reference operator[](size_type position) const;

매개 변수

position
벡터 요소의 위치입니다.

반환 값

지정된 위치가 컨테이너의 크기보다 크거나 같을 경우 결과가 정의되지 않습니다.

설명

반환 값 operator[] 이 할당 const_reference된 경우 벡터 개체를 수정할 수 없습니다. operator[]의 반환 값이 참조로 할당되는 경우는 벡터 개체를 수정할 수 있습니다.

1 또는 2로 정의된 값을 사용하여 _ITERATOR_DEBUG_LEVEL 컴파일하는 경우 벡터의 범위 밖에 있는 요소에 액세스하려고 하면 런타임 오류가 발생합니다. 자세한 내용은 확인된 반복기를 참조 하세요.

예시

// vector_op_ref.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;

   v1.push_back( 10 );
   v1.push_back( 20 );

   int& i = v1[1];
   cout << "The second integer of v1 is " << i << endl;
}

`operator=`

벡터의 요소를 다른 벡터의 복사본으로 바꿉니다.

vector& operator=(const vector& right);

vector& operator=(vector&& right);

매개 변수

right
에 vector 복사되는 항목입니다 vector.

설명

vector는 operator=에서 기존 요소를 지운 후에 right의 내용을 vector로 복사하거나 이동합니다.

예시

// vector_operator_as.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int> v1, v2, v3;
   vector<int>::iterator iter;

   v1.push_back(10);
   v1.push_back(20);
   v1.push_back(30);
   v1.push_back(40);
   v1.push_back(50);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << *iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;
}

`pointer`

벡터에서 요소에 대한 포인터를 제공하는 형식입니다.

typedef typename Allocator::pointer pointer;

설명

형식 pointer 을 사용하여 요소의 값을 수정할 수 있습니다.

예시

// vector_pointer.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
    using namespace std;
    vector<int> v;
    v.push_back( 11 );
    v.push_back( 22 );

    vector<int>::pointer ptr = &v[0];
    cout << *ptr << endl;
    ptr++;
    cout << *ptr << endl;
    *ptr = 44;
    cout << *ptr << endl;
}

11
22
44

`pop_back`

벡터의 끝에 있는 요소를 삭제합니다.

void pop_back();

설명

코드 예제를 보려면 vector::push_back()을 참조하세요.

`push_back`

벡터 끝에 요소를 추가합니다.

void push_back(const T& value);

void push_back(T&& value);

매개 변수

value
벡터의 끝에 추가된 요소에 할당할 값입니다.

예시

// compile with: /EHsc /W4
#include <vector>
#include <iostream>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << "  " << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

int main()
{
    vector<int> v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(10 + i);
    }

    cout << "vector data: " << endl;
    print_collection(v);

    // pop_back() until it's empty, printing the last element as we go
    while (v.begin() != v.end()) {
        cout << "v.back(): "; print_elem(v.back()); cout << endl;
        v.pop_back();
    }
}

`rbegin`

역방향 벡터의 첫 번째 요소에 대한 반복기를 반환합니다.

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

반환 값

역방향 벡터에서 첫 번째 요소의 주소를 지정하거나 정방향 벡터에서 마지막 요소의 주소를 지정하는 역방향 임의 액세스 반복기입니다.

설명

반환 값 rbegin 이 할당 const_reverse_iterator된 경우 벡터 개체를 수정할 수 없습니다. rbegin의 반환 값이 reverse_iterator에 할당되는 경우에는 vector 개체를 수정할 수 있습니다.

예시

// vector_rbegin.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::iterator v1_Iter;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of vector is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.rbegin( );
   cout << "The first element of the reversed vector is "
        << *v1_rIter << "." << endl;
}

The first element of vector is 1.
The first element of the reversed vector is 2.

`reference`

벡터에 저장된 요소에 대한 참조를 제공하는 형식입니다.

typedef typename Allocator::reference reference;

예시

벡터 클래스에서 사용하는 reference 방법의 예제를 참조 at 하세요.

`rend`

역방향 벡터의 마지막 요소 다음 요소를 가리키는 마지막 역방향 반복기를 반환합니다.

const_reverse_iterator rend() const;
reverse_iterator rend();

반환 값

역방향 벡터에 대한 역방향 마지막 반복기입니다. 역방향 벡터의 마지막 요소 다음에 있는 요소를 가리킵니다. 이 요소는 역방향이 아닌 벡터의 첫 번째 요소 앞의 요소와 동일합니다. 해당 요소는 자리 표시자이며 역참조해서는 안 됩니다. 비교에만 사용합니다.

설명

rend 는 벡터와 함께 사용되는 것처럼 end 역방향 벡터와 함께 사용됩니다.

반환 값 rend 이 a const_reverse_iterator에 할당된 경우 벡터 개체를 수정할 수 없습니다. rend의 반환 값이 reverse_iterator에 할당되는 경우에는 vector 개체를 수정할 수 있습니다.

rend를 사용하여 역방향 반복기가 벡터 끝에 도달했는지를 테스트할 수 있습니다.

반환된 rend 값은 역참조하면 안 됩니다. 비교에만 사용합니다.

예시

// vector_rend.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`reserve`

벡터 개체의 최소 스토리지 길이를 예약하며 필요한 경우 공간을 할당합니다.

void reserve(size_type count);

매개 변수

count
벡터에 대해 할당할 최소 스토리지 길이입니다.

예시

// vector_reserve.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20

`resize`

벡터의 새 크기를 지정합니다.

void resize(size_type new_size);
void resize(size_type new_size, Type value);

매개 변수

new_size
벡터의 새 크기입니다.

value
새 크기가 원래 크기보다 큰 경우 벡터에 추가된 새 요소의 초기화 값입니다. 이 값이 생략되면 새 개체는 기본 생성자를 사용합니다.

설명

컨테이너의 크기가 요청된 크기보다 작으면 요청된 크기에 new_sizeresize 도달할 때까지 요소를 벡터에 추가합니다. 컨테이너의 크기가 요청된 크기 resize 보다 크면 크기에 도달할 때까지 컨테이너의 끝에 가장 가까운 요소를 삭제합니다 new_size. 컨테이너의 현재 크기가 요청된 크기와 같으면 아무 작업도 수행되지 않습니다.

size 는 벡터의 현재 크기를 반영합니다.

예시

// vectorsizing.cpp
// compile with: /EHsc /W4
// Illustrates vector::reserve, vector::max_size,
// vector::resize, vector::resize, and vector::capacity.
//
// Functions:
//
//    vector::max_size - Returns maximum number of elements vector could
//                       hold.
//
//    vector::capacity - Returns number of elements for which memory has
//                       been allocated.
//
//    vector::size - Returns number of elements in the vector.
//
//    vector::resize - Reallocates memory for vector, preserves its
//                     contents if new size is larger than existing size.
//
//    vector::reserve - Allocates elements for vector to ensure a minimum
//                      size, preserving its contents if the new size is
//                      larger than existing size.
//
//    vector::push_back - Appends (inserts) an element to the end of a
//                        vector, allocating memory for it if necessary.
//
//////////////////////////////////////////////////////////////////////

// The debugger cannot handle symbols more than 255 characters long.
// The C++ Standard Library often creates symbols longer than that.
// The warning can be disabled:
//#pragma warning(disable:4786)

#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename C> void print(const string& s, const C& c) {
    cout << s;

    for (const auto& e : c) {
        cout << e << " ";
    }
    cout << endl;
}

void printvstats(const vector<int>& v) {
    cout << "   the vector's size is: " << v.size() << endl;
    cout << "   the vector's capacity is: " << v.capacity() << endl;
    cout << "   the vector's maximum size is: " << v.max_size() << endl;
}

int main()
{
    // declare a vector that begins with 0 elements.
    vector<int> v;

    // Show statistics about vector.
    cout << endl << "After declaring an empty vector:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Add one element to the end of the vector.
    v.push_back(-1);
    cout << endl << "After adding an element:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    for (int i = 1; i < 10; ++i) {
        v.push_back(i);
    }
    cout << endl << "After adding 10 elements:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(6);
    cout << endl << "After resizing to 6 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(9, 999);
    cout << endl << "After resizing to 9 elements with an initialization value of 999:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    v.resize(12);
    cout << endl << "After resizing to 12 elements without an initialization value:" << endl;
    printvstats(v);
    print("   the vector's contents: ", v);

    // Ensure there's room for at least 1000 elements.
    v.reserve(1000);
    cout << endl << "After vector::reserve(1000):" << endl;
    printvstats(v);

    // Ensure there's room for at least 2000 elements.
    v.resize(2000);
    cout << endl << "After vector::resize(2000):" << endl;
    printvstats(v);
}

`reverse_iterator`

역방향 벡터에 있는 모든 요소를 읽거나 수정할 수 있는 임의 액세스 반복기를 제공하는 형식입니다.

typedef std::reverse_iterator<iterator> reverse_iterator;

설명

reverse_iterator 형식은 벡터를 역방향으로 반복하는 데 사용됩니다.

예시

에 대한 예제를 rbegin참조하세요.

`shrink_to_fit`

여분의 용량을 삭제합니다.

void shrink_to_fit();

예시

// vector_shrink_to_fit.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   //vector <int>::iterator Iter;

   v1.push_back( 1 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.reserve( 20 );
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
   v1.shrink_to_fit();
   cout << "Current capacity of v1 = "
      << v1.capacity( ) << endl;
}

Current capacity of v1 = 1
Current capacity of v1 = 20
Current capacity of v1 = 1

`size`

벡터에 있는 요소 수를 반환합니다.

size_type size() const;

반환 값

벡터의 현재 길이입니다.

예시

// vector_size.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1;
   vector <int>::size_type i;

   v1.push_back( 1 );
   i = v1.size( );
   cout << "Vector length is " << i << "." << endl;

   v1.push_back( 2 );
   i = v1.size( );
   cout << "Vector length is now " << i << "." << endl;
}

Vector length is 1.
Vector length is now 2.

`size_type`

벡터의 요소 수를 계산하는 형식입니다.

typedef typename Allocator::size_type size_type;

예시

에 대한 예제를 capacity참조하세요.

`swap`

두 벡터의 요소를 교환합니다.

void swap(
    vector<Type, Allocator>& right);

friend void swap(
    vector<Type, Allocator>& left,
    vector<Type, Allocator>& right);

매개 변수

right
교환할 요소를 제공하는 벡터입니다. 또는 요소를 벡터의 요소와 교환할 벡터 left입니다.

left
요소를 벡터의 요소와 교환할 벡터 right입니다.

예시

// vector_swap.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector <int> v1, v2;

   v1.push_back( 1 );
   v1.push_back( 2 );
   v1.push_back( 3 );

   v2.push_back( 10 );
   v2.push_back( 20 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
   cout << endl;

   v1.swap( v2 );

   cout << "The number of elements in v1 = " << v1.size( ) << endl;
   cout << "The number of elements in v2 = " << v2.size( ) << endl;
}

The number of elements in v1 = 3
The number of elements in v2 = 2

The number of elements in v1 = 2
The number of elements in v2 = 3

`value_type`

벡터에 저장된 데이터 형식을 나타내는 형식입니다.

typedef typename Allocator::value_type value_type;

설명

value_type은 템플릿 매개 변수 Type의 동의어입니다.

예시

// vector_value_type.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main( )
{
   using namespace std;
   vector<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

`vector`

벡터를 생성합니다. 오버로드는 특정 크기의 벡터 또는 특정 값의 요소를 사용하여 생성합니다. 또는 다른 벡터의 전부 또는 일부의 복사본으로 사용할 수 있습니다. 일부 오버로드를 사용하면 사용할 할당자를 지정할 수도 있습니다.

vector();
explicit vector(const Allocator& allocator);
explicit vector(size_type count);
vector(size_type count, const Type& value);
vector(size_type count, const Type& value, const Allocator& allocator);

vector(const vector& source);
vector(vector&& source);
vector(initializer_list<Type> init_list, const Allocator& allocator);

template <class InputIterator>
vector(InputIterator first, InputIterator last);
template <class InputIterator>
vector(InputIterator first, InputIterator last, const Allocator& allocator);

매개 변수

allocator
이 개체에 사용할 할당자 클래스입니다. get_allocator 는 개체에 대한 할당자 클래스를 반환합니다.

count
생성된 벡터에 있는 요소의 수입니다.

value
생성된 벡터에 있는 요소의 값입니다.

source
해당 복사본으로 벡터를 생성할 벡터입니다.

first
복사할 요소의 범위에서 첫 번째 요소의 위치입니다.

last
복사할 요소의 범위를 벗어난 첫 번째 요소의 위치입니다.

init_list
initializer_list 복사할 요소가 들어 있는 항목입니다.

설명

모든 생성자는 할당자 개체(allocator)를 저장하고 벡터를 초기화합니다.

처음 두 생성자는 빈 초기 벡터를 지정합니다. 두 번째 생성자는 사용할 할당자 형식(allocator)을 명시적으로 지정합니다.

세 번째 생성자는 count 클래스에 대한 기본값 요소의 지정된 반복 횟수(Type)를 지정합니다.

네 번째 및 다섯 번째 생성자는 값value의 (count) 요소의 반복을 지정합니다.

여섯 번째 생성자는 source 벡터의 복사본을 지정합니다.

일곱 번째 생성자는 source 벡터를 이동합니다.

여덟 번째 생성자는 initializer_list를 사용하여 요소를 지정합니다.

아홉 번째 및 열 번째 생성자는 벡터의 범위(first, last)를 복사합니다.

예시

// vector_ctor.cpp
// compile with: /EHsc
#include <vector>
#include <iostream>

int main()
{
    using namespace std;
    vector <int>::iterator v1_Iter, v2_Iter, v3_Iter, v4_Iter, v5_Iter, v6_Iter;

    // Create an empty vector v0
    vector <int> v0;

    // Create a vector v1 with 3 elements of default value 0
    vector <int> v1(3);

    // Create a vector v2 with 5 elements of value 2
    vector <int> v2(5, 2);

    // Create a vector v3 with 3 elements of value 1 and with the allocator
    // of vector v2
    vector <int> v3(3, 1, v2.get_allocator());

    // Create a copy, vector v4, of vector v2
    vector <int> v4(v2);

    // Create a new temporary vector for demonstrating copying ranges
    vector <int> v5(5);
    for (auto i : v5) {
        v5[i] = i;
    }

    // Create a vector v6 by copying the range v5[ first,  last)
    vector <int> v6(v5.begin() + 1, v5.begin() + 3);

    cout << "v1 =";
    for (auto& v : v1){
        cout << " " << v;
    }
    cout << endl;

    cout << "v2 =";
    for (auto& v : v2){
        cout << " " << v;
    }
    cout << endl;

    cout << "v3 =";
    for (auto& v : v3){
        cout << " " << v;
    }
    cout << endl;
    cout << "v4 =";
    for (auto& v : v4){
        cout << " " << v;
    }
    cout << endl;

    cout << "v5 =";
    for (auto& v : v5){
        cout << " " << v;
    }
    cout << endl;

    cout << "v6 =";
    for (auto& v : v6){
        cout << " " << v;
    }
    cout << endl;

    // Move vector v2 to vector v7
    vector <int> v7(move(v2));
    vector <int>::iterator v7_Iter;

    cout << "v7 =";
    for (auto& v : v7){
        cout << " " << v;
    }
    cout << endl;

    cout << "v8 =";
    vector<int> v8{ { 1, 2, 3, 4 } };
    for (auto& v : v8){
        cout << " " << v ;
    }
    cout << endl;
}

v1 = 0 0 0
v2 = 2 2 2 2 2
v3 = 1 1 1
v4 = 2 2 2 2 2
v5 = 0 0 0 0 0
v6 = 0 0
v7 = 2 2 2 2 2
v8 = 1 2 3 4

참고 항목

C++ 표준 라이브러리의 스레드 보안
C++ 표준 라이브러리 참조

vector 클래스

구문

매개 변수

설명

멤버

생성자

Typedef

함수

연산자

allocator_type

설명

예시

assign

매개 변수

설명

예시

at

매개 변수

반환 값

설명

예시

back

반환 값

설명

예시

begin

반환 값

설명

예시

capacity

반환 값

설명

예시

cbegin

반환 값

설명

cend

반환 값

설명

clear

예시

const_iterator

설명

예시

const_pointer

설명

const_reference

설명

예시

const_reverse_iterator

설명

예시

crbegin

반환 값

설명

예시

crend

반환 값

설명

예시

data

반환 값

예시

difference_type

설명

예시

emplace

매개 변수

반환 값

설명

예시

emplace_back

매개 변수

예시

empty

반환 값

예시

end

반환 값

설명

`vector` 클래스

`allocator_type`

`assign`

`at`

`back`

`begin`

`capacity`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`data`

`difference_type`

`emplace`

`emplace_back`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`push_back`

`rbegin`

`reference`

`rend`

`reserve`

`resize`

`reverse_iterator`

`shrink_to_fit`

`size`

`size_type`

`swap`