C++프로 그래 밍 의 vector 류 용기 사용법 을 자세히 설명 합 니 다.

벡터 소개
vector 는 STL 에서 가장 흔히 볼 수 있 는 용기 로 무 작위 접근 을 지원 하 는 순서 용기 입 니 다.vector 는 연속 적 으로 분 배 된 메모리 입 니 다.데이터 배정 의 측면 에서 볼 때 배열 과 매우 비슷 합 니 다.다른 점 은 배열 은 정적 분배 공간 입 니 다.공간의 크기 를 분배 하면 더 이상 바 꿀 수 없습니다.한편,vector 는 동적 분배 공간 으로 요소 가 계속 삽입 되면 서 자신의 체제 에 따라 자신의 용량 을 계속 확대 할 것 이다.
vector 의 확장 메커니즘:용기 의 현재 용량 의 배로 증가 합 니 다.vector 용 기 는 연속 적 인 메모리 공간 을 분배 합 니 다.용기 가 늘 어 날 때마다 기 존의 연속 적 인 메모리 공간 에서 간단 한 중첩 을 하 는 것 이 아니 라 더 큰 새 메모 리 를 다시 신청 하고 기 존 용기 의 요 소 를 하나씩 복사 한 다음 에 오래된 메모 리 를 소각 합 니 다.이 때 기 존 메모리 공간 을 가리 키 는 교체 기 는 이미 효력 을 잃 었 기 때문에 용 기 를 조작 할 때 교체 기 는 제때에 업데이트 해 야 한다.
vector 의 데이터 구조
vector 데이터 구 조 는 연속 적 인 선형 공간 을 사용 하여 선형 저장 에 속 합 니 다.그 는 3 개의 교체 기 를 채택 했다.First、_Last、_End 는 분 배 된 선형 공간의 서로 다른 범 위 를 가리 키 며,다음은 3 개의 교체 기 변 수 를 설명 하 는 소스 코드 입 니 다.

template<class _Ty, class _A= allocator< _Ty> > 
class vector{ 
... 
protected: 
iterator _First, _Last, _End; 
};

_First 는 공간의 머리 를 가리 키 며,마지막 으로 사용 공간 크기(size)의 끝 을 가리 키 며,End 는 공간 용량(capacity)을 사용 하 는 끝 을 가리킨다.예 를 들 면:

int data[6]={3,5,7,9,2,4}; 
vector<int> vdata(data, data+6); 
vdata.push_back(6); 
...

vector 초기 화 시 신청 한 공간 크기 는 6 이 며,data 에 있 는 6 개의 요 소 를 저장 합 니 다.vdata 에 일곱 번 째 요소 인'6'을 삽입 할 때 vector 는 자신의 확장 체 제 를 이용 하여 공간 을 재 신청 하고 데이터 저장 구 조 는 그림 과 같다.

간단하게 설명해 주세요.7 번 째 요소 인'6'을 삽입 할 때 vector 는 자신의 공간 이 부족 하 다 는 것 을 알 고 12 번 째 크기 의 메모리 공간(자체 2 배 증가)을 신청 하고 앞 에 있 는 데 이 터 를 새로운 공간의 앞부분 으로 복사 한 다음 7 번 째 요 소 를 삽입 합 니 다.이때마지막 교체 기 는 마지막 유효 요 소 를 가리 키 며,End 교체 기 는 vector 의 마지막 유효 공간 위 치 를 가리킨다.저 희 는 vector 의 구성원 함수 size 를 이용 하여 현재 vector 의 크기 를 얻 을 수 있 습 니 다.이 때 는 7 입 니 다.capacity 구성원 함 수 를 이용 하여 현재 vector 의 용량 을 가 져 옵 니 다.이 때 는 12 입 니 다.
vector 용기 종류
vector 용 기 는 템 플 릿 클래스 로 모든 종류의 대상 을 저장 할 수 있 습 니 다(단,같은 대상 이 어야 합 니 다).vector 대상 은 실행 할 때 효율 적 으로 요 소 를 추가 할 수 있 으 며,vector 에서 요 소 는 연속 으로 저 장 됩 니 다.
vector 의 구조
함수 원형:

template<typename T>
explicit vector();                 //       ，vector    
explicit vector(size_type n, const T& v = T());  //    n    vector  
vector(const vector& x);
vector(const_iterator first, const_iterator last);

주:vector 용기 에 저 장 된 모든 대상 은 초기 화 되 었 습 니 다.저장 대상 의 초기 값 이 지정 되 지 않 으 면 내 장 된 형식 은 0 으로 초기 화 됩 니 다.클래스 유형 에 대해 서 는 기본 구조 함 수 를 호출 하여 초기 화 합 니 다.(기본 구조 함수 가 없 는 다른 구조 함수 가 있다 면 요소 의 초기 값 을 제공 해 야 용기 에 넣 을 수 있 습 니 다)
예:

vector<string> v1;     //      ，      string 
vector<string> v2(10);   //    10      （   ） string      
vector<string> v3(5, "hello"); //    5   “hello” string      
vector<string> v4(v3.begin(), v3.end()); // v4  v3     （    ）

vector 의 조작(아래 함 수 는 모두 구성원 함수)

bool empty() const;          //        ，  true；    false
size_type max_size() const;      //               
size_type size() const;        //           
size_type capacity() const;      //            ， ：capacity() >= size() 
void reserve(size_type n);       //   capacity() >= n
void resize(size_type n, T x = T());  //      ， ：size() == n；    size()<n，     x    。

reference front();           //              （      ）
const_reference front() const;          
reference back();           //               （      ）
const_reference back() const;

reference operator[](size_type pos);  //      pos      （   0  ；       ，        。
const_reference operator[](size_type pos) const; 
reference at(size_type pos);      //      pos      ；       ，     out_of_range
const_reference at(size_type pos) const;

void push_back(const T& x);      //                 
void pop_back();            //            （      ）

//  ：                  （           ），            
iterator insert(iterator it, const T& x = T());    //             （           ）
void insert(iterator it, size_type n, const T& x);   //            （        ）
void insert(iterator it, const_iterator first, const_iterator last);

iterator erase(iterator it);      //       ，               （     ，  end()）
iterator erase(iterator first, iterator last); //   ：     ，                  。

void clear() const;          //     ，     erase( begin(), end())

void assign(size_type n, const T& x = T());  //   ，                
void assign(const_iterator first, const_iterator last);

const_iterator begin() const;     //     
iterator begin();
const_iterator end() const;
iterator end();

const_reverse_iterator rbegin() const;
reverse_iterator rbegin();
const_reverse_iterator rend() const; 
reverse_iterator rend();

vector 대상 비교(비 구성원 함수)
vector 대상 에 대한 비교 연산 자 는 여섯 개 입 니 다:operator=,operator!=,operator<、operator<=、operator>、operator>=。
그 중에서 operator==와 operator!=,만약 에 vector 대상 이 같은 요소 개 수 를 가지 고 해당 하 는 위치 에 있 는 요소 가 모두 같다 면 두 vector 대상 은 같다.안 그러면 안 기 다 려.
operator<,operator<=,operator>,operator>=에 대해 사전 정렬 전략 으로 비교 합 니 다.
주:사실 operator==와 operator!=됐 습 니 다.다른 것 은 이 두 가지 에 따라 이 루어 질 수 있 습 니 다.왜냐하면,operator!=(lhs,rhs)바로!lhs==rhs),operator<=(lhs,rhs)바로!(rhs(lhs,rhs)바로(rhs=(lhs,rhs)바로!(lhs, rhs)。
vector 클래스 의 교체 기
vector 류 의 교체 기 는 통용 되 는 접두사 자체 증가 연산 자 를 지원 하 는 것 외 에 산술 연산 도 지원 합 니 다:it+n,it-n,it2-it1.주의 it2-it1 반환 값 은 differencetype(signed 형식).
용기 크기 를 바 꾸 는 모든 작업 은 이전의 교체 기 를 무효 로 만 들 수 있 음 을 주의 하 세 요.
실례
1.vector 의 데이터 저장 과 출력:

#include<stdio.h>
#include<vector>
#include <iostream>
using namespace std;
void main()
{
 int i = 0;
  vector<int> v;
  for( i = 0; i < 10; i++ )
 {
      v.push_back( i );//          vector 
 }
        
 for( i = 0; i < v.size(); i++ )//v.size()   vector       
 {
     cout << v[ i ] << " "; //         
 }
 cont << endl;
}

주:v.begin()과 v.end()로 vector 가 시작 하고 끝 난 요소 주소 의 포인터 위 치 를 얻 을 수 있 습 니 다.너 도 이렇게 할 수 있다.

vector<int>::iterator iter;
for( iter = v.begin(); iter != v.end(); iter++ )
{
  cout << *iter << endl;
}

2.2 차원 vector 에 대한 정의.
(1)10 개의 vector 요 소 를 정의 하고 각 vector 문자 값 1-10 을 정의 합 니 다.

#include<stdio.h>
#include<vector>
#include <iostream>
using namespace std;
void main()
{
int i = 0, j = 0;
//           ， 10 ，         vector        。
              。     vector<int>(0)  vector   ，     vector    。
vector< vector<int> > Array( 10, vector<int>(0) );
for( j = 0; j < 10; j++ )
{
 for ( i = 0; i < 9; i++ )
 {
  Array[ j ].push_back( i );
 }
}
for( j = 0; j < 10; j++ )
{
 for( i = 0; i < Array[ j ].size(); i++ )
 {
  cout << Array[ j ][ i ] << " ";
 }
 cout<< endl;
}
}

(2)한 행렬 이 모두 변 화 된 배열 이 라 고 정의 한다.

#include<stdio.h>
#include<vector>
#include <iostream>
using namespace std;
void main()
{
int i = 0, j = 0;
vector< vector<int> > Array;
vector< int > line;
for( j = 0; j < 10; j++ )
{
 Array.push_back( line );//     vector   ，        。
 for ( i = 0; i < 9; i++ )
 {
  Array[ j ].push_back( i );
 }
}
for( j = 0; j < 10; j++ )
{
 for( i = 0; i < Array[ j ].size(); i++ )
 {
  cout << Array[ j ][ i ] << " ";
 }
 cout<< endl;
}
}

(3)vettor erase 를 사용 하여 지정 한 요 소 를 삭제 합 니 다.

#include "iostream"
#include "vector"
using namespace std;
int main()
{
  vector<int> arr;
  arr.push_back(6);
  arr.push_back(8);
  arr.push_back(3);
  arr.push_back(8);
  for(vector<int>::iterator it=arr.begin(); it!=arr.end(); )
  {
    if(* it == 8)
    {
      it = arr.erase(it);
    }
    else
    {
      ++it;
    }
  }
  cout << "After remove 8:
";
  for(vector<int>::iterator it = arr.begin(); it < arr.end(); ++it)
  {
    cout << * it << " ";
  }
  cout << endl;
}