vector 복사하기

// copy 알고리즘을 이용한 복사
vDst.resize( (int)(vSrc.size()) );
std::copy( vSrc.begin(), vSrc.end(), vDst.begin() );
std::copy( vSrc.begin() + 2, vSrc.begin() + 5, vDst.begin() );

// assign 을 이용한 복사
vDst.clear();
vDst.assign( vSrc.begin(), vSrc.end() ); // 전체 복사
vDst.assign( vSrc.begin() + 1, vSrc.begin() + 4 );

Original Post : http://neodreamer-dev.tistory.com/331

vector 원소 복사하기

vector< int > vA;
vector< int > vB;

vA.push_back( 1 );
vA.push_back( 3 );
vA.push_back( 5 );
vA.push_back( 7 );
vA.push_back( 9 );

// 모든 원소 복사
vB.resize( vA.size() ); // 복사될 크기 만큼 공간 확보
copy( vA.begin(), vA.end(), vB.begin() );

// 결과
// vA    [5](1,3,5,7,9)    std::vector<int,std::allocator<int> >
// vB    [5](1,3,5,7,9)    std::vector<int,std::allocator<int> >


// 처음부터 3개만 복사할 경우
vB.resize( 3 ); // 복사될 크기 만큼 공간 확보
copy( vA.begin(), vA.begin() + 3, vB.begin() );

// 결과
// vA    [5](1,3,5,7,9)    std::vector<int,std::allocator<int> >
// vB    [3](1,3,5)    std::vector<int,std::allocator<int> >


// 두번 째 원소부터 3개를 복사할 경우
vB.resize( 3 ); // 복사될 크기 만큼 공간 확보
copy( vA.begin() + 1, vA.begin() + 4, vB.begin() );

// 결과
// vA    [5](1,3,5,7,9)    std::vector<int,std::allocator<int> >
// vB    [3](3,5,7)    std::vector<int,std::allocator<int> >

Original Post : http://neodreamer-dev.tistory.com/323

[STL] vector 에서 [] 과 at() 의 차이점

vector 의 원소에 접근하는 방법은 배열의 접근 방법과 갈은 [] 를 이용하는 방법과 멤버 함수인 at() 을 이용하는 방법이 있다.
이 두가지 방법의 차이점은 첨자의 범위를 체크하는지 여부와 범위를 벗어난 접근일 경우 예외 발생 여부이다.


배열 접근 기호인 [] 에의한 접근은 첨자의 범위를 체크하지 않기 때문에 범위를 벗어난 접근을 시도할 경우 예외를 발생하지 않고 에러를 발생한다.

멤버함수 at() 를 이용한 접근은 첨자의 범위를 체크하여 벗어난 접근을 시도할 경우 std::out_of_range 예외를 발생 한다.

범위내의 접근을 보장할 경우 별도의 범위 체크가 필요 없으므로 []의해 원소에 접근하며

for ( int n = 0; n < (int)vInt.size(); ++n )

{

  int a = vInt[ n ];

  :

}

그렇지 않을 경우 at() 의한 접근으로 예외를 처리해 준다.

void foo( int n )

{

    try

    {

        int a = vInt.at( n );

    }

    catch (std::out_of_range& e)

    {

        AfxMessageBox( _T("Catch the std::out_of_range") );

    }

}


Original Post : http://neodreamer-dev.tistory.com/256

[STL] remove algorithm 은 실제로 지우지 않는다.

vector 를 사용하다 특정 원소를 삭제하기 위해 algorithm 의 remove 를 이용하였다. vector 자체에는 remove 를 지원하지 않기 때문에... 하지만 결과는 예상을 빗나가 버렸다.

remove를 하면 원소는 사라지는 것 처럼 보이는데 vector의 크기는 그대로였다.
그래서 remove에 대한 정보를 찾아보았다.

remove 의 기능은 지정된 시작위치부터 끝위치까지 탐색하여 지워야하는 원소가 있을 경우 그 위치에 다음의 지우지 않을 원소를 덮어 써서 뒤쪽의 일부 영역을 무효화 한다.
그렇게 삭제(?)를 마치면 뒤쪽의 무효화 영역이 시작되는 iterator 를 반환한다.

실제로 지우기 위해서는 이 iterator 부터 마지막까지 erase 로 지워야한다. erase 할 경우 마지막까지 지우지 않고 iterator 만 지울 경우 다수의 원소를 삭제하고자 할 경우 정확하게 지워지지 않는다.

vector< int > vInt;
vector< int >::iterator it;

vInt.push_back( 2 );
vInt.push_back( 3 );
vInt.push_back( 4 );
vInt.push_back( 12 );
vInt.push_back( 15 );
vInt.push_back( 35 );
vInt.push_back( 2 );
vInt.push_back( 62 );
vInt.push_back( 24 );
vInt.push_back( 15 );
vInt.push_back( 91 );

TRACE0("\nsource : ");
for ( int i = 0; i < (int)vInt.size(); ++i )
    TRACE1( " %d", vInt[i] );

it = remove( vInt.begin(), vInt.end(), 15 );
TRACE0("\nremove 15 : ");
for ( int i = 0; i < (int)vInt.size(); ++i )
    TRACE1( " %d", vInt[i] );

//vInt.erase( it );
vInt.erase( it, vInt.end() );
TRACE0("\nerase : ");
for ( int i = 0; i < (int)vInt.size(); ++i )
    TRACE1( " %d", vInt[i] );

it = remove( vInt.begin(), vInt.end(), 2 );
TRACE0("\nremove 2 : ");
for ( int i = 0; i < (int)vInt.size(); ++i )
    TRACE1( " %d", vInt[i] );

//vInt.erase( it );
vInt.erase( it, vInt.end() );
TRACE0("\nerase : ");
for ( int i = 0; i < (int)vInt.size(); ++i )
    TRACE1( " %d", vInt[i] );

결과
////////////////////////////////////////////////////////////////////////////////
// remove로 받은 iterator 만을 지울 경우 : vInt.erase( it )
source :  2 3 4 12 15 35 2 62 24 15 91

remove 15 :  2 3 4 12 35 2 62 24 91 15 91
// 15 삭제시 15 두 개가 삭제되고 뒤쪽의 원소들로 앞쪽으로 덮어 씌운다.
// 마지막 두 원소는 유령처럼 살아있다. 
// 반환된 iterator 는 끝에서 두 번째 원소를 가리킨다.
erase :  2 3 4 12 35 2 62 24 91 91
// 반환받은 iterator 위치의 원소를 삭제할 경우 마지막에서 두 번째 원소만
// 삭제한다. 마지막 91은 여전히 살아있다.

remove 2 :  3 4 12 35 62 24 91 91 91 91
erase :  3 4 12 35 62 24 91 91 91

////////////////////////////////////////////////////////////////////////////////
// remove로 받을 iterator 에서 마지막까지 지울 경우 : vInt.erase( it, vInt.end() )
source :  2 3 4 12 15 35 2 62 24 15 91

remove 15 :  2 3 4 12 35 2 62 24 91 15 91
// 15 삭제시 15 두 개가 삭제되고 뒤쪽의 원소들로 앞쪽으로 덮어 씌운다.
// 마지막 두 원소는 유령처럼 살아있다. 
// 반환된 iterator 는 끝에서 두 번째 원소를 가리킨다.
erase :  2 3 4 12 35 2 62 24 91
// 반환받은 iterator 위치부터 마지막까지 삭제할 경우 원하는 결과를 얻을 수 있다.

remove 2 :  3 4 12 35 62 24 91 24 91
erase :  3 4 12 35 62 24 91

Original Post : http://neodreamer-dev.tistory.com/255

vector를 이용한 2차원 동적 배열

STL의 컨테이너인 vector를 이용하여 2차원 동적 배열을 구현해 보았다.


vector를 이용하기 위한 포함 파일을 포함하는 방법은 개발툴 마다 조금씩 다르다.

Visual Studio 의 경우

#include <vector>

using namespace std;

C++ Builder 경우

#include <vector.h>

vector를 활용한 2차원 동적 배열은 vector 를 담는 vector 이다.
선언은 아래와 같다.

vector < vector < int > > vcArray;

선언시 주의해야할 사항은 마지막 angle bracket 2개를 붙여쓰면 쉬프트 연산자로 인식해 에러를 발생한다.

배열을 초기화 하기 위해서 원하는 ROW 만큼 반복을 하며 원하는 COL 크기의 vector를 만들어 동적 배열 vector에 넣어주면 된다. 설명보다는 코드를 보는 것이 이해가 빠를 것이다.

for ( int i = 0 ; i < ROW; ++i ) // 주어진 ROW 만큼 반복

{

    vector<int> elem; // vector 를 생성하고

    elem.resize(COL); // 원하는 COL 크기로 할당

    vcArray.push_back(elem); // 배열에 추가

}

vector 를 활용한 배열이기 때문에 위와는 다르게 각 ROW 마다 원소수(COL 의 크기)를 다르게 설정할 수도 있다. 그때 배열에 접근 할때는 인자가 범위를 벗어나지 않도록 주위를 해야한다.


이렇게 할당한 배열을 삭제할 때는 각각의 ROW 에 포함된 COL 데이터를 삭제하고 마지막으로 ROW 데이터를 삭제하면 된다.

for (int row = 0; row < (int)vcArray.size(); ++row)

    vcArray[row].clear();

vcArray.clear(); 

접근 방법은 일반 배열을 접근하듯이 하면 된다.

int temp = vcArray[1][2]; 

vcArray[1][2] = 3;


Original Post : http://neodreamer-dev.tistory.com/19