`deque` 수업

아티클
10/12/2023

선형 정렬에서 지정된 형식의 요소를 정렬하고 벡터처럼 모든 요소에 대한 빠른 임의 액세스와 컨테이너 뒤쪽에서 효율적인 삽입 및 삭제를 가능하게 합니다. 그러나 벡터와 달리 deque 클래스는 컨테이너 앞에서 효율적인 삽입 및 삭제를 지원합니다.

구문

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

매개 변수

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

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

설명

컨테이너 형식은 일반적으로 애플리케이션에서 필요한 검색과 삽입의 형식을 기준으로 선택해야 합니다. Vectors 는 임의의 요소에 대한 액세스가 프리미엄이고 요소의 삽입 또는 삭제가 시퀀스의 끝에만 필요한 경우 시퀀스를 관리하기 위한 기본 컨테이너여야 합니다. 시퀀스 내의 모든 위치에서 효율적인 삽입 및 삭제(일정한 시간)가 최상일 때 목록 컨테이너의 성능이 가장 우수합니다. 시퀀스 중 이러한 작업에는 시퀀스의 요소 수에 비례하는 요소 복사본 및 할당이 필요합니다(선형 시간).

Deque 재할당은 멤버 함수가 시퀀스의 요소를 삽입하거나 지워야 하는 경우에 발생합니다.

요소가 빈 시퀀스에 삽입되거나 요소가 지워져서 빈 시퀀스를 남기면 이전에 반환 begin end 된 반복기가 잘못됩니다.
요소가 첫 번째 위치에 deque삽입되면 모든 반복기가 있지만 참조가 없으면 기존 요소를 지정하는 요소가 유효하지 않습니다.
요소의 deque끝에 삽입된 다음 end 모든 반복기를 삽입하지만 참조가 없으면 기존 요소를 지정하는 요소가 유효하지 않습니다.
요소 앞 deque면에서 요소가 지워지면 해당 반복기 및 지워진 요소에 대한 참조만 유효하지 않습니다.
마지막 요소가 끝 deque부분에서 지워지면 마지막 요소에 대한 반복기와 지워진 요소에 대한 참조만 유효하지 않습니다.

그렇지 않으면 요소를 삽입 또는 제거하는 경우 모든 반복기와 참조가 무효화됩니다.

멤버

생성자

속성 설명

deque deque를 생성합니다. 빈, 지정된 수의 빈 요소로 로드됨, 다른 deque요소에서 이동 또는 복사된 콘텐츠, 반복기를 사용하여 복사 또는 이동된 내용, 시간에 복사 count deque 된 요소 등 여러 가지 방법으로 새 deque 항목의 콘텐츠를 설정하기 위해 여러 생성자가 제공됩니다. 일부 생성자의 경우 사용자 지정 allocator를 사용하여 요소를 만들 수 있습니다.

속성	설명
`deque`	`deque`를 생성합니다. 빈, 지정된 수의 빈 요소로 로드됨, 다른 `deque`요소에서 이동 또는 복사된 콘텐츠, 반복기를 사용하여 복사 또는 이동된 내용, 시간에 복사 `count` `deque` 된 요소 등 여러 가지 방법으로 새 `deque` 항목의 콘텐츠를 설정하기 위해 여러 생성자가 제공됩니다. 일부 생성자의 경우 사용자 지정 `allocator`를 사용하여 요소를 만들 수 있습니다.

Typedef

속성	설명
`allocator_type`	`allocator` 개체의 `deque` 클래스를 나타내는 형식입니다.
`const_iterator`	`deque`의 요소를 `const`로 액세스하고 읽을 수 있는 임의 액세스 반복기를 제공하는 형식입니다.
`const_pointer`	as`const`의 요소에 대한 포인터를 제공하는 형식입니다`deque`.
`const_reference`	읽기 및 기타 작업을 위해 요소에 대한 참조를 `deque` 다음과 같이 `const`제공하는 형식입니다.
`const_reverse_iterator`	`deque`의 요소를 `const`로 액세스하고 읽을 수 있는 임의 액세스 반복기를 제공하는 형식입니다. 역 `deque` 방향으로 표시됩니다. 자세한 내용은 클래스를 참조 `reverse_iterator` 하세요.
`difference_type`	동일한 `deque` 내의 요소를 참조하는 두 임의 액세스 반복기 간의 차이를 제공하는 형식입니다.
`iterator`	`deque`에 있는 모든 요소를 읽거나 수정할 수 있는 임의 액세스 반복기를 제공하는 형식입니다.
`pointer`	`deque`의 요소에 대한 포인터를 제공하는 형식입니다.
`reference`	`deque` 내에 저장된 요소에 대한 참조를 제공하는 형식입니다.
`reverse_iterator`	`deque`에 있는 모든 요소를 읽거나 수정할 수 있는 임의 액세스 반복기를 제공하는 형식입니다. 역 `deque` 순으로 표시됩니다.
`size_type`	`deque`의 요소 수를 계산하는 형식입니다.
`value_type`	`deque` 내에 저장된 데이터 형식을 나타내는 형식입니다.

함수

속성	설명
`assign`	`deque`에서 요소를 지우고 대상 `deque`에 요소의 새 시퀀스를 복사합니다.
`at`	`deque`의 지정된 위치에 있는 요소에 대한 참조를 반환합니다.
`back`	`deque`의 마지막 요소에 대한 참조를 반환합니다.
`begin`	`deque`의 첫 번째 요소를 처리하는 임의 액세스 반복기를 반환합니다.
`cbegin`	에서 `const` 첫 번째 요소에 반복기를 반환합니다 `deque`.
`cend`	`deque` 끝의 바로 다음을 가리키는 임의 액세스 `const` 반복기를 반환합니다.
`clear`	`deque`의 모든 요소를 지웁니다.
`crbegin`	역순으로 표시된 첫 번째 요소에 `deque` 대한 임의 액세스 `const` 반복기를 반환합니다.
`crend`	역순으로 표시된 첫 번째 요소에 `deque` 대한 임의 액세스 `const` 반복기를 반환합니다.
`emplace`	내부에서 생성된 요소를 `deque`의 지정된 위치에 삽입합니다.
`emplace_back`	생성된 요소를 `deque`의 끝에 추가합니다.
`emplace_front`	생성된 요소를 `deque`의 시작 부분에 추가합니다.
`empty`	`deque`에 0개의 요소가 포함된 경우 `true`를 반환하고, 하나 이상의 요소가 포함된 경우 `false`를 반환합니다.
`end`	`deque` 끝의 바로 다음을 가리키는 임의 액세스 반복기를 반환합니다.
`erase`	`deque`의 지정된 위치에서 요소 또는 요소 범위를 제거합니다.
`front`	`deque`의 첫 번째 요소에 대한 참조를 반환합니다.
`get_allocator`	`allocator`를 생성하는 데 사용된 `deque` 개체의 복사본을 반환합니다.
`insert`	한 요소, 여러 요소 또는 요소의 범위를 `deque`의 지정된 위치에 삽입합니다.
`max_size`	`deque`의 최대 허용 길이를 반환합니다.
`pop_back`	`deque`의 끝에 있는 요소를 지웁니다.
`pop_front`	`deque`의 시작 부분에 있는 요소를 지웁니다.
`push_back`	`deque`의 끝에 요소를 추가합니다.
`push_front`	`deque`의 시작 부분에 요소를 추가합니다.
`rbegin`	역방향 `deque`의 첫 번째 요소에 대한 임의 액세스 반복기를 반환합니다.
`rend`	역방향 `deque`에서 마지막 요소 바로 다음을 가리키는 임의 액세스 반복기를 반환합니다.
`resize`	`deque`의 새 크기를 지정합니다.
`shrink_to_fit`	여분의 용량을 삭제합니다.
`size`	`deque`에 있는 요소 수를 반환합니다.
`swap`	두 `deque`의 요소를 교환합니다.

연산자

속성	설명
`operator[]`	지정된 위치에 있는 `deque` 요소에 대한 참조를 반환합니다.
`operator=`	`deque`의 요소를 다른 `deque`의 복사본으로 바꿉니다.

`allocator_type`

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

typedef Allocator allocator_type;

설명

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

예시

get_allocator에 대한 예를 참조하세요.

`assign`

A deque 에서 요소를 지우고 새 요소 집합을 대상 deque에 복사합니다.

template <class InputIterator>
void assign(
    InputIterator First,
    InputIterator Last);

void assign(
    size_type Count,
    const Type& Val);

void assign(initializer_list<Type> IList);

매개 변수

First
인수 deque에서 복사할 요소 범위의 첫 번째 요소 위치입니다.

Last
인수 deque에서 복사할 요소 범위를 벗어난 첫 번째 요소의 위치입니다.

Count
에 삽입 deque되는 요소의 복사본 수입니다.

Val
deque에 삽입되는 요소의 값입니다.

IList
에 initializer_list 삽입되는 항목입니다 deque.

설명

대상 deque 의 기존 요소가 지워지면 assign 원본 deque 또는 다른 deque 요소의 지정된 범위가 대상 deque에 삽입되거나 지정된 값의 새 요소 복사본을 대상 deque에 삽입합니다.

예시

// deque_assign.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <initializer_list>

int main()
{
    using namespace std;
    deque <int> c1, c2;
    deque <int>::const_iterator cIter;

    c1.push_back(10);
    c1.push_back(20);
    c1.push_back(30);
    c2.push_back(40);
    c2.push_back(50);
    c2.push_back(60);

    deque<int> d1{ 1, 2, 3, 4 };
    initializer_list<int> iList{ 5, 6, 7, 8 };
    d1.assign(iList);

    cout << "d1 = ";
    for (int i : d1)
        cout << i;
    cout << endl;

    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(++c2.begin(), c2.end());
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(7, 4);
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;
}

d1 = 5678c1 =102030c1 =5060c1 =4444444

`at`

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

reference at(size_type pos);

const_reference at(size_type pos) const;

매개 변수

pos
에서 참조할 요소의 아래 첨자(또는 위치 번호)입니다 deque.

Return Value

크기 dequeat 보다 크면 pos 예외가 throw됩니다.

설명

반환 값 at 이 할당 const_reference된 경우 개체를 deque 수정할 수 없습니다. 반환 값 at 이 할당 reference된 경우 개체를 deque 수정할 수 있습니다.

예시

// deque_at.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

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

   const int& i = c1.at( 0 );
   int& j = c1.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`

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

reference back();
const_reference back() const;

Return Value

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

설명

반환 값 back 이 할당 const_reference된 경우 개체를 deque 수정할 수 없습니다. 반환 값 back 이 할당 reference된 경우 개체를 deque 수정할 수 있습니다.

1 또는 2로 정의된 값을 사용하여 _ITERATOR_DEBUG_LEVEL 컴파일하는 경우 빈 deque요소에 액세스하려고 하면 런타임 오류가 발생합니다. 자세한 내용은 Checked Iterators 를 참조하세요.

예시

// deque_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

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

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

The last integer of c1 is 11
The next-to-last integer of c1 is 10

`begin`

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

const_iterator begin() const;
iterator begin();

Return Value

deque의 첫 번째 요소 또는 빈 deque 다음의 위치 주소를 지정하는 임의 액세스 반복기입니다.

설명

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

예시

// deque_begin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

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

   c1_Iter = c1.begin( );
   cout << "The first element of c1 is " << *c1_Iter << endl;

*c1_Iter = 20;
   c1_Iter = c1.begin( );
   cout << "The first element of c1 is now " << *c1_Iter << endl;

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

The first element of c1 is 1
The first element of c1 is now 20

`cbegin`

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

const_iterator cbegin() const;

Return Value

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

설명

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

begin() 멤버 함수 대신 이 멤버 함수를 사용하여 반환 값이 const_iterator임을 보장할 수 있습니다. 일반적으로 다음 예제와 같이 형식 추론 키워드와 함께 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;

Return Value

범위 끝의 바로 다음을 가리키는 임의 액세스 반복기입니다.

설명

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

end() 멤버 함수 대신 이 멤버 함수를 사용하여 반환 값이 const_iterator임을 보장할 수 있습니다. 일반적으로 다음 예제와 같이 형식 추론 키워드와 함께 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`

deque의 모든 요소를 지웁니다.

void clear();

예시

// deque_clear.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

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

   cout << "The size of the deque is initially " << c1.size( ) << endl;
   c1.clear( );
   cout << "The size of the deque after clearing is " << c1.size( ) << endl;
}

The size of the deque is initially 3
The size of the deque after clearing is 0

`const_iterator`

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

typedef implementation-defined const_iterator;

설명

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

예시

back에 대한 예를 참조하세요.

`const_pointer`

의 요소에 대한 const 포인터를 deque제공합니다.

typedef typename Allocator::const_pointer const_pointer;

설명

형식 const_pointer 을 사용하여 요소의 값을 수정할 수 없습니다. 요소는 iterator 더 일반적으로 요소에 액세스 deque 하는 데 사용됩니다.

`const_reference`

const 작업을 읽고 수행하기 위해 deque에 저장된 const 요소에 대한 참조를 제공하는 형식입니다.

typedef typename Allocator::const_reference const_reference;

설명

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

예시

// deque_const_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

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

   const deque <int> c2 = c1;
   const int &i = c2.front( );
   const int &j = c2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

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

The first element is 10
The second element is 20

`const_reverse_iterator`

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

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

설명

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

예시

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

`crbegin`

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

const_reverse_iterator crbegin() const;

Return Value

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

설명

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

예시

// deque_crbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

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

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

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

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

`crend`

역방향deque의 const 마지막 요소 다음에 나오는 위치를 해결하는 반복기를 반환합니다.

const_reverse_iterator crend() const;

Return Value

const 역 deque 방향의 마지막 요소(역방향 요소의 첫 번째 요소 앞에 있었던 위치)의 뒤를 잇는 위치를 해결하는 역방향 임의 deque액세스 반복기입니다.

설명

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

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

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

반환된 crend 값은 역참조하면 안 됩니다.

예시

// deque_crend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <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

`deque`

deque 특정 크기 또는 특정 값의 요소 또는 특정 할당자를 사용하거나 일부 다른 deque항목의 복사본으로 생성합니다.

deque();

explicit deque(const Allocator& Al);
explicit deque(size_type Count);
deque(size_type Count, const Type& Val);

deque(
    size_type Count,
    const Type& Val,
    const Allocator& Al);

deque(const deque& Right);

template <class InputIterator>
deque(InputIterator First,  InputIterator Last);

template <class InputIterator>
deque(
   InputIterator First,
   InputIterator Last,
   const Allocator& Al);

deque(initializer_list<value_type> IList, const Allocator& Al);

매개 변수

Al
이 개체에 사용할 할당자 클래스입니다.

Count
생성된 deque요소의 수입니다.

Val
생성된 deque요소의 값입니다.

Right
생성된 deque이 복사본으로 지정될 deque입니다.

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

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

IList
복사할 initializer_list입니다.

설명

모든 생성자는 할당자 개체(Al)를 저장하고 deque.

처음 두 생성자는 빈 이니셜 deque을 지정하고, 두 번째 생성자는 사용할 할당자 형식(_Al)도 지정합니다.

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

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

여섯 번째 생성자는 .의 복사본을 deque Right지정합니다.

일곱 번째 및 여덟 번째 생성자는 의 범위를 [First, Last) 복사합니다 deque.

일곱 번째 생성자는 을 deque Right이동합니다.

여덟 번째 생성자는 .의 initializer_list내용을 복사합니다.

중간 다시 할당을 수행하는 생성자는 없습니다.

예시

/ compile with: /EHsc
#include <deque>
#include <iostream>
#include <forward_list>

int main()
{
    using namespace std;

    forward_list<int> f1{ 1, 2, 3, 4 };

    f1.insert_after(f1.begin(), { 5, 6, 7, 8 });

    deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

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

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

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3(3, 1, c2.get_allocator());

    // Create a copy, deque c4, of deque c2
    deque <int> c4(c2);

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    deque <int> c5(c4.begin(), c4_Iter);

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    c4_Iter++;
    deque <int> c6(c4.begin(), c4_Iter, c2.get_allocator());

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

    initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for (int i : c1)
        cout << i << " ";
    cout << endl;

    cout << "c2 = ";
    for (int i : c2)
        cout << i << " ";
    cout << endl;

    cout << "c3 = ";
    for (int i : c3)
        cout << i << " ";
    cout << endl;

    cout << "c4 = ";
    for (int i : c4)
        cout << i << " ";
    cout << endl;

    cout << "c5 = ";
    for (int i : c5)
        cout << i << " ";
    cout << endl;

    cout << "c6 = ";
    for (int i : c6)
        cout << i << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7(move(c6));
    deque <int>::iterator c7_Iter;

    cout << "c7 =";
    for (int i : c7)
        cout << i << " ";
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    for (int i : c9)
        cout << i << " ";
    cout << endl;

    int x = 3;
}
// deque_deque.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
    using namespace std;
   deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

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

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

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3( 3, 1, c2.get_allocator( ) );

    // Create a copy, deque c4, of deque c2
    deque <int> c4( c2 );

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin( );
    c4_Iter++;
    c4_Iter++;
    deque <int> c5( c4.begin( ), c4_Iter );

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin( );
   c4_Iter++;
   c4_Iter++;
   c4_Iter++;
   deque <int> c6( c4.begin( ), c4_Iter, c2.get_allocator( ) );

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

        initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
        cout << *c1_Iter << " ";
    cout << endl;

    cout << "c2 = ";
    for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
        cout << *c2_Iter << " ";
    cout << endl;

    cout << "c3 = ";
    for ( c3_Iter = c3.begin( ); c3_Iter != c3.end( ); c3_Iter++ )
        cout << *c3_Iter << " ";
    cout << endl;

    cout << "c4 = ";
    for ( c4_Iter = c4.begin( ); c4_Iter != c4.end( ); c4_Iter++ )
        cout << *c4_Iter << " ";
    cout << endl;

    cout << "c5 = ";
    for ( c5_Iter = c5.begin( ); c5_Iter != c5.end( ); c5_Iter++ )
        cout << *c5_Iter << " ";
    cout << endl;

    cout << "c6 = ";
    for ( c6_Iter = c6.begin( ); c6_Iter != c6.end( ); c6_Iter++ )
        cout << *c6_Iter << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7( move(c6) );
    deque <int>::iterator c7_Iter;

    cout << "c7 =" ;
    for ( c7_Iter = c7.begin( ) ; c7_Iter != c7.end( ) ; c7_Iter++ )
        cout << " " << *c7_Iter;
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    or (int i : c9)
        cout << i << " ";
    cout << endl;
}

`difference_type`

동일한 deque 안에서 요소를 참조하는 두 반복기 사이의 차이를 제공하는 형식입니다.

typedef typename Allocator::difference_type difference_type;

설명

difference_type은 두 포인터 사이의 요소로도 설명할 수 있습니다.

예시

// deque_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <deque>
#include <algorithm>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <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( );

   deque <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`

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

iterator emplace(
    const_iterator _Where,
    Type&& val);

매개 변수

_Where
deque 첫 번째 요소가 삽입되는 위치입니다.

val
deque에 삽입되는 요소의 값입니다.

Return Value

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

설명

모든 삽입 작업에서는 많은 계산을 수행해야 할 수 있습니다. deque 성능에 대한 설명은 deque를 참조하세요.

예시

// deque_emplace.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <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 deque of deques by moving v1
   deque < deque <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`

생성된 요소를 deque의 끝에 추가합니다.

void emplace_back(Type&& val);

매개 변수

val
deque 끝에 추가되는 요소입니다.

예시

// deque_emplace_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_back( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}

Last element: 1
New last element: 2
Moved last element: 2

`emplace_front`

생성된 요소를 deque의 끝에 추가합니다.

void emplace_front(Type&& val);

매개 변수

val
의 시작 부분에 추가된 요소입니다 deque.

예시

// deque_emplace_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_front( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}

Last element: 1
New last element: 2
Moved last element: 2

`empty`

deque가 비어 있는지 여부를 테스트합니다.

bool empty() const;

Return Value

true비어 있으면 이고deque, false 비어 있지 않으면 deque

예시

// deque_empty.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   if ( c1.empty( ) )
      cout << "The deque is empty." << endl;
   else
      cout << "The deque is not empty." << endl;
}

The deque is not empty.

`end`

deque에서 마지막 요소 다음에 나오는 위치를 주소 지정하는 반복기를 반환합니다.

const_iterator end() const;

iterator end();

Return Value

의 마지막 요소 다음에 나오는 위치를 해결하는 임의 액세스 반복기입니다 deque. deque이 비어 있으면 deque::end == deque::begin입니다.

설명

end는 반복기가 deque의 끝에 도달했는지 여부를 테스트하는 데 사용됩니다.

예시

// deque_end.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;

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

   c1_Iter = c1.end( );
   c1_Iter--;
   cout << "The last integer of c1 is " << *c1_Iter << endl;

   c1_Iter--;
   *c1_Iter = 400;
   cout << "The new next-to-last integer of c1 is " << *c1_Iter << endl;

   // If a const iterator had been declared instead with the line:
   // deque <int>::const_iterator c1_Iter;
   // an error would have resulted when inserting the 400

   cout << "The deque is now:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
}

The last integer of c1 is 30
The new next-to-last integer of c1 is 400
The deque is now: 10 400 30

`erase`

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

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

매개 변수

_Where
에서 제거할 요소의 deque위치입니다.

first
에서 제거된 첫 번째 요소의 위치입니다 deque.

last
에서 제거된 마지막 요소 바로 다음 위치 deque입니다.

Return Value

제거된 요소 이상으로 남아 있는 첫 번째 요소를 지정하는 임의 액세스 반복기 또는 이러한 요소가 없는 경우 끝부 deque 분에 대한 포인터입니다.

설명

erase은 예외를 throw할 수 없습니다.

예시

// deque_erase.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 40 );
   c1.push_back( 50 );
   cout << "The initial deque is: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   c1.erase( c1.begin( ) );
   cout << "After erasing the first element, the deque becomes:  ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   Iter = c1.begin( );
   Iter++;
   c1.erase( Iter, c1.end( ) );
   cout << "After erasing all elements but the first, deque becomes: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
}

The initial deque is: 10 20 30 40 50
After erasing the first element, the deque becomes:  20 30 40 50
After erasing all elements but the first, deque becomes: 20

`front`

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

reference front();

const_reference front() const;

Return Value

deque 비어 있으면 반환이 정의되지 않습니다.

설명

반환 값 front 이 할당 const_reference된 경우 개체를 deque 수정할 수 없습니다. 반환 값 front 이 할당 reference된 경우 개체를 deque 수정할 수 있습니다.

예시

// deque_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

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

   cout << "The first integer of c1 is " << i << endl;
   i++;
   cout << "The second integer of c1 is " << ii << endl;
}

The first integer of c1 is 10
The second integer of c1 is 11

`get_allocator`

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

Allocator get_allocator() const;

Return Value

에서 사용하는 할당자입니다 deque.

설명

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

예시

// deque_get_allocator.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

   // c3 will use the same allocator class as c1
   deque <int> c3( c1.get_allocator( ) );

   deque <int>::allocator_type xlst = c1.get_allocator( );
   // You can now call functions on the allocator class used by c1
}

`insert`

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

iterator insert(
    const_iterator Where,
    const Type& Val);

iterator insert(
    const_iterator Where,
    Type&& Val);

void insert(
    iterator Where,
    size_type Count,
    const Type& Val);

template <class InputIterator>
void insert(
    iterator Where,
    InputIterator First,
    InputIterator Last);

iterator insert(
    iterator Where,initializer_list<Type>
IList);

매개 변수

Where
첫 번째 요소가 삽입되는 대상 deque 의 위치입니다.

Val
deque에 삽입되는 요소의 값입니다.

Count
에 삽입되는 요소의 수입니다 deque.

First
복사할 인수 deque 의 요소 범위에서 첫 번째 요소의 위치입니다.

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

IList
initializer_list 삽입할 요소의 요소입니다.

Return Value

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

설명

모든 삽입 작업에서는 많은 계산을 수행해야 할 수 있습니다.

`iterator`

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

typedef implementation-defined iterator;

설명

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

예시

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

`max_size`

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

size_type max_size() const;

Return Value

가능한 최대 길이입니다 deque.

예시

// deque_max_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

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

`operator[]`

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

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

매개 변수

pos
참조할 요소의 deque 위치입니다.

Return Value

인수에 해당 위치가 지정된 요소에 대한 참조입니다. 지정된 위치가 크기 deque보다 크면 결과가 정의되지 않습니다.

설명

반환 값 operator[] 이 할당 const_reference된 경우 개체를 deque 수정할 수 없습니다. 반환 값 operator[] 이 할당 reference된 경우 개체를 deque 수정할 수 있습니다.

1 또는 2로 정의된 값을 사용하여 _ITERATOR_DEBUG_LEVEL 컴파일하는 경우 범위 외부의 deque요소에 액세스하려고 하면 런타임 오류가 발생합니다. 자세한 내용은 Checked Iterators 를 참조하세요.

예시

// deque_op_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   cout << "The first integer of c1 is " << c1[0] << endl;
   int& i = c1[1];
   cout << "The second integer of c1 is " << i << endl;
}

The first integer of c1 is 10
The second integer of c1 is 20

`operator=`

다른 deque요소의 요소를 사용하여 이 deque 요소를 바꿉니다.

deque& operator=(const deque& right);

deque& operator=(deque&& right);

매개 변수

right
deque 새 콘텐츠를 제공하는 것입니다.

설명

첫 번째 재정의는 할당의 원본인 이 요소에 right요소를 deque 복사합니다. 두 번째 재정의는 요소를 .에서 right이것 deque 으로 이동합니다.

연산자가 실행되기 전에 이 deque 항목에 포함된 요소가 제거됩니다.

예시

// deque_operator_as.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
using namespace std;

typedef deque<int> MyDeque;

template<typename MyDeque> struct S;

template<typename MyDeque> struct S<MyDeque&> {
  static void show( MyDeque& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
    cout << endl;
  }
};

template<typename MyDeque> struct S<MyDeque&&> {
  static void show( MyDeque&& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
cout << " via unnamed rvalue reference " << endl;
  }
};

int main( )
{
   MyDeque d1, d2;

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

   cout << "d1 = " ;
   S<MyDeque&>::show( d1 );

   d2 = d1;
   cout << "d2 = ";
   S<MyDeque&>::show( d2 );

   cout << "     ";
   S<MyDeque&&>::show ( move< MyDeque& > (d1) );
}

`pointer`

의 요소에 대한 포인터를 deque제공합니다.

typedef typename Allocator::pointer pointer;

설명

형식 pointer 을 사용하여 요소의 값을 수정할 수 있습니다. 요소는 iterator 더 일반적으로 요소에 액세스 deque 하는 데 사용됩니다.

`pop_back`

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

void pop_back();

설명

마지막 요소는 비워 둘 수 없습니다. pop_back은 예외를 throw할 수 없습니다.

예시

// deque_pop_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The last element is: " << c1.back( ) << endl;

   c1.pop_back( );
   cout << "After deleting the element at the end of the deque, the "
      "last element is: " << c1.back( ) << endl;
}

The first element is: 1
The last element is: 2
After deleting the element at the end of the deque, the last element is: 1

`pop_front`

의 시작 부분에 있는 요소를 삭제합니다 deque.

void pop_front();

설명

첫 번째 요소는 비워 둘 수 없습니다. pop_front은 예외를 throw할 수 없습니다.

예시

// deque_pop_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The second element is: " << c1.back( ) << endl;

   c1.pop_front( );
   cout << "After deleting the element at the beginning of the "
      "deque, the first element is: " << c1.front( ) << endl;
}

The first element is: 1
The second element is: 2
After deleting the element at the beginning of the `deque`, the first element is: 2

`push_back`

deque의 끝에 요소를 추가합니다.

void push_back(const Type& val);

void push_back(Type&& val);

매개 변수

val
deque 끝에 추가되는 요소입니다.

설명

예외가 throw되면 deque는 변경되지 않은 상태로 유지되며 예외가 다시 throw됩니다.

`push_front`

의 시작 부분에 요소를 추가합니다 deque.

void push_front(const Type& val);
void push_front(Type&& val);

매개 변수

val
의 시작 부분에 추가된 요소입니다 deque.

설명

예외가 throw되면 deque는 변경되지 않은 상태로 유지되며 예외가 다시 throw됩니다.

예시

// deque_push_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_front( 1 );
   if ( c1.size( ) != 0 )
      cout << "First element: " << c1.front( ) << endl;

   c1.push_front( 2 );
   if ( c1.size( ) != 0 )
      cout << "New first element: " << c1.front( ) << endl;

// move initialize a deque of strings
   deque <string> c2;
   string str("a");

   c2.push_front( move( str ) );
   cout << "Moved first element: " << c2.front( ) << endl;
}

First element: 1
New first element: 2
Moved first element: a

`rbegin`

역방향 deque요소의 첫 번째 요소에 반복기를 반환합니다.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Return Value

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

설명

rbegin는 .와 함께 사용되는 것처럼 begin 역방향 deque 으로 deque사용됩니다.

반환 값 rbegin 이 할당 const_reverse_iterator된 경우 개체를 deque 수정할 수 없습니다. 반환 값 rbegin 이 할당 reverse_iterator된 경우 개체를 deque 수정할 수 있습니다.

rbegin은 deque을 역방향으로 반복할 때 사용할 수 있습니다.

예시

// deque_rbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;

   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

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

   c1_rIter = c1.rbegin( );
   cout << "Last element in the deque is " << *c1_rIter << "." << endl;

   cout << "The deque contains the elements: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << "in that order.";
   cout << endl;

   // rbegin can be used to iterate through a deque in reverse order
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rbegin( );
   *c1_rIter = 40;  // This would have caused an error if a
                    // const_reverse iterator had been declared as
                    // noted above
   cout << "Last element in deque is now " << *c1_rIter << "." << endl;
}

Last element in the deque is 30.
The deque contains the elements: 10 20 30 in that order.
The reversed deque is: 30 20 10
Last element in deque is now 40.

`reference`

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

typedef typename Allocator::reference reference;

예시

// deque_reference.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

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

   const int &i = c1.front( );
   int &j = c1.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`rend`

역순 deque에서 마지막 요소 다음에 나오는 위치를 주소 지정하는 반복기를 반환합니다.

const_reverse_iterator rend() const;

reverse_iterator rend();

Return Value

역 deque 방향의 마지막 요소(역방향 요소의 첫 번째 요소 앞에 있었던 위치)의 뒤를 잇는 위치를 해결하는 역방향 임의 deque액세스 반복기입니다.

설명

rend는 .와 함께 사용되는 것처럼 end 역방향 deque 으로 deque사용됩니다.

반환 값 rend 이 할당 const_reverse_iterator된 경우 개체를 deque 수정할 수 없습니다. 반환 값 rend 이 할당 reverse_iterator된 경우 개체를 deque 수정할 수 있습니다.

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

반환된 rend 값은 역참조하면 안 됩니다.

예시

// deque_rend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;
   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

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

   c1_rIter = c1.rend( );
   c1_rIter --; // Decrementing a reverse iterator moves it forward
                // in the deque (to point to the first element here)
   cout << "The first element in the deque is: " << *c1_rIter << endl;

   cout << "The deque is: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << endl;

   // rend can be used to test if an iteration is through all of
   // the elements of a reversed deque
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rend( );
   c1_rIter--; // Decrementing the reverse iterator moves it backward
               // in the reversed deque (to the last element here)
   *c1_rIter = 40; // This modification of the last element would
                   // have caused an error if a const_reverse
                   // iterator had been declared (as noted above)
   cout << "The modified reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;
}

The first element in the deque is: 10
The deque is: 10 20 30
The reversed deque is: 30 20 10
The modified reversed deque is: 30 20 40

`resize`

deque의 새 크기를 지정합니다.

void resize(size_type _Newsize);

void resize(size_type _Newsize, Type val);

매개 변수

_Newsize
의 새 크기입니다 deque.

val
새 크기가 원래 크기보다 큰 경우 추가할 deque 새 요소의 값입니다. 값을 생략하면 새 요소에 클래스의 기본값이 할당됩니다.

설명

'가 dequesize 보다 _Newsize작으면 요소가 크기에 _Newsize도달할 때까지 추가 deque 됩니다.

deque'가 size 크기보다 _Newsize크면 끝에 deque 가장 가까운 요소가 크기에 _Newsize도달할 때까지 deque 삭제됩니다.

현재 크기 deque 가 동일한 _Newsize경우 아무 작업도 수행되지 않습니다.

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

예시

// deque_resize.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

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

   c1.resize( 4,40 );
   cout << "The size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is " << c1.back( ) << endl;

   c1.resize( 5 );
   cout << "The size of c1 is now: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;

   c1.resize( 2 );
   cout << "The reduced size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;
}

The size of c1 is: 4
The value of the last element is 40
The size of c1 is now: 5
The value of the last element is now 0
The reduced size of c1 is: 2
The value of the last element is now 20

`reverse_iterator`

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

typedef std::reverse_iterator<iterator> reverse_iterator;

설명

형식 reverse_iterator 은 .를 반복하는 deque데 사용됩니다.

예시

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

`shrink_to_fit`

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

void shrink_to_fit();

설명

에서 사용하는 스토리지를 줄일 수 있는지 확인할 shrink_to_fit 수 있는 deque이식 가능한 방법은 없습니다.

예시

// deque_shrink_to_fit.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

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

   v1.push_back( 1 );
   v1.push_back( 2 );
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
   v1.shrink_to_fit();
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
}

Current size of v1 = 1
Current size of v1 = 1

`size`

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

size_type size() const;

Return Value

의 현재 길이입니다 deque.

예시

// deque_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

   c1.push_back( 1 );
   i = c1.size( );
   cout << "The deque length is " << i << "." << endl;

   c1.push_back( 2 );
   i = c1.size( );
   cout << "The deque length is now " << i << "." << endl;
}

The deque length is 1.
The deque length is now 2.

`size_type`

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

typedef typename Allocator::size_type size_type;

예시

size에 대한 예를 참조하세요.

`swap`

두 deque의 요소를 교환합니다.

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

friend void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right) template <class Type, class Allocator>
void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right);

매개 변수

right
deque 교환할 요소를 제공하거나 deque 해당 요소를 해당 요소와 deque left교환할 요소입니다.

left
deque 해당 요소를 해당 요소와 교환해야 하는 deque rightA입니다.

예시

// deque_swap.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1, c2, c3;
   deque <int>::iterator c1_Iter;

   c1.push_back( 1 );
   c1.push_back( 2 );
   c1.push_back( 3 );
   c2.push_back( 10 );
   c2.push_back( 20 );
   c3.push_back( 100 );

   cout << "The original deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   c1.swap( c2 );

   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap( c1,c3 );

   cout << "After swapping with c3, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap<>(c1, c2);
   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;
}

The original deque c1 is: 1 2 3
After swapping with c2, deque c1 is: 10 20
After swapping with c3, deque c1 is: 100
After swapping with c2, deque c1 is: 1 2 3

`value_type`

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

typedef typename Allocator::value_type value_type;

설명

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

예시

// deque_value_type.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
int main( )
{
   using namespace std;
   deque<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

참고 항목

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

다음을 통해 공유

deque 수업

구문

매개 변수

설명

멤버

생성자

Typedef

함수

연산자

allocator_type

설명

예시

assign

매개 변수

설명

예시

at

매개 변수

Return Value

설명

예시

back

Return Value

설명

예시

begin

Return Value

설명

예시

cbegin

Return Value

설명

cend

Return Value

설명

clear

예시

const_iterator

설명

예시

const_pointer

설명

const_reference

설명

예시

const_reverse_iterator

설명

예시

crbegin

Return Value

설명

예시

crend

Return Value

설명

예시

deque

매개 변수

설명

예시

difference_type

설명

예시

emplace

매개 변수

Return Value

설명

예시

emplace_back

매개 변수

예시

emplace_front

매개 변수

예시

empty

Return Value

예시

end

Return Value

`deque` 수업

`allocator_type`

`assign`

`at`

`back`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`deque`

`difference_type`

`emplace`

`emplace_back`

`emplace_front`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`pop_front`

`push_back`

`push_front`

`rbegin`

`reference`

`rend`

`resize`

`reverse_iterator`

`shrink_to_fit`