[ 시퀀스 컨테이너 ]

 

시퀀스 컨테이너느 저장 원소가 삽입 순서에 따라 상대적인 위치(순서)를 갖는 컨테이너 vector, list, deque 입니다. 





vector는 시퀀스 컨테이너이므로 원소의 저장 위치(순서)가  정해지며 배열 기반 컨테이너이므로 원소가 하나의

메모리 블록에 할당됩니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <iostream>
#include <vector>
using namespace std;
 
int main( )
{ 
    vector<int> v; 
 
    v.push_back(10); 
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    v.push_back(50);
 
    /** 
    /* size_type은 원소의 개수나 [] 연산자 등의 index로 사용하는 형식
    /* 이왕이면 컴파일러의 경고 타입을 없애고 보기좋은 코드 작성
    */
    for(vector<int>::size_type i = 0 ; i < v.size() ; ++i)
        cout << v[i] << endl;   
 
    cout << typeid(vector<int>::size_type).name() << endl;    
    
    system("pause");
    return 0;
}

 

 

위의 예제에서 사용되었던 typeid(T)는 T에 대한 typeinfo 객체를 리턴 해줍니다.

 

vector는 크기를 반환하는 세 멤버함수 size(), capacity(), max_size()를 가집니다.

 

size() : 저장 원소의 개수

capacity() : 실제 할당된 메모리 공간의 크기 ( vector만 가지는 멤버함수 )

max_size() : 컨테이너가 담을 수 있는 최대 원소의 개수

 

※ 중요 ※

vector는 원소가 하나의 메모리 블록에 연속(배열 기반 컨테이너)으로 저장 됩니다.

원소가 추가될 때마다 메모리를 재할당하고 이전원소를 모두 복사해야 한다면 너무나 비효율적입니다.

 

이떄 조금이나마 재할당에 드는 성능 문제를 보완 하고자 만들어진 개념이 capacity 입니다.

원소가 추가될 때마다 메모리를 재할당하지 않고 미리 넉넉한 메모리를 확보하면 재할당과 이전 원소를 복사하는 데 드는 비용을 줄일 수 있습니다. 이것은 컨테이너 중 vector만이 가지고 있는 중요한 특징 입니다.

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include <iostream>
#include <vector>
using namespace std;
 
int main( )
{ 
    vector<int> v; 
    vector<int> v_reserve;
 
    cout <<"size: "<< v.size() <<"  capacity: " << v.capacity() <<endl; // 0, 0
    v.push_back(10); // 메모리 재할당과 원소 복사 ( capacity + 이전 capacity / 2 )
    cout <<"size: "<< v.size() <<"  capacity: " << v.capacity() <<endl; // 1, 1
    v.push_back(20); // 메모리 재할당과 원소 복사 ( capacity + 이전 capacity / 2 )
    cout <<"size: "<< v.size() <<"  capacity: " << v.capacity() <<endl; // 2, 2
    v.push_back(30); // 메모리 재할당과 원소 복사 ( capacity + 이전 capacity / 2 )
    cout <<"size: "<< v.size() <<"  capacity: " << v.capacity() <<endl; // 3, 3
    v.push_back(40); // 메모리 재할당과 원소 복사 ( capacity + 이전 capacity / 2 )
    cout <<"size: "<< v.size() <<"  capacity: " << v.capacity() <<endl; // 4, 4                                             
    v.push_back(50); // 메모리 재할당과 원소 복사 ( capacity + 이전 capacity / 2 )
    cout <<"size: "<< v.size() <<"  capacity: " << v.capacity() <<endl; // 5, 6
    v.push_back(60);
    cout <<"size: "<< v.size() <<"  capacity: " << v.capacity() <<endl; // 6, 6 
    v.push_back(70); // 메모리 재할당과 원소 복사 ( capacity + 이전 capacity / 2 )
    cout <<"size: "<< v.size() <<"  capacity: " << v.capacity() <<endl; // 7, 9
    v.push_back(80);
    cout <<"size: "<< v.size() <<"  capacity: " << v.capacity() <<endl; // 8, 9
    v.push_back(90);
    cout <<"size: "<< v.size() <<"  capacity: " << v.capacity() <<endl; // 9, 9
 
    for(vector<int>::size_type i = 0 ; i < v.size() ; ++i)
        cout << v[i] << " ";   
    cout << endl;
    cout << endl;
 
    // reserve 함수 사용
    v_reserve.reserve(8);
    cout <<"size: "<< v_reserve.size() <<"  capacity: " << v_reserve.capacity() <<endl; // 0, 8
    v_reserve.push_back(10); 
    cout <<"size: "<< v_reserve.size() <<"  capacity: " << v_reserve.capacity() <<endl; // 1, 8
    v_reserve.push_back(20); 
    cout <<"size: "<< v_reserve.size() <<"  capacity: " << v_reserve.capacity() <<endl; // 2, 8
    v_reserve.push_back(30); 
    cout <<"size: "<< v_reserve.size() <<"  capacity: " << v_reserve.capacity() <<endl; // 3, 8
    v_reserve.push_back(40); 
    cout <<"size: "<< v_reserve.size() <<"  capacity: " << v_reserve.capacity() <<endl; // 4, 8                                             
    v_reserve.push_back(50); 
    cout <<"size: "<< v_reserve.size() <<"  capacity: " << v_reserve.capacity() <<endl; // 5, 8
    v_reserve.push_back(60);
    cout <<"size: "<< v_reserve.size() <<"  capacity: " << v_reserve.capacity() <<endl; // 6, 8 
    v_reserve.push_back(70); 
    cout <<"size: "<< v_reserve.size() <<"  capacity: " << v_reserve.capacity() <<endl; // 7, 8
    v_reserve.push_back(80);
    cout <<"size: "<< v_reserve.size() <<"  capacity: " << v_reserve.capacity() <<endl; // 8, 8
    v_reserve.push_back(90);// 메모리 재할당과 원소 복사 ( capacity + 이전 capacity / 2 )
    cout <<"size: "<< v_reserve.size() <<"  capacity: " << v_reserve.capacity() <<endl; // 9, 12
 
    for(vector<int>::size_type i = 0 ; i < v_reserve.size() ; ++i)
        cout << v_reserve[i] << " ";   
    cout << endl;
 
    system("pause");    
    return 0;
}

 

위의 예제에서 보면 vector는

 

1. 미리저장할 메모리의 크기(capacity)를 크게 하면 원소가 추가돼도 메모리의 크기가 변하지 않게 됩니다.

2. 원소를 추가하려 할때 메모리의 크기(capacity)가 원소의 개수(size)보다 크지 않다면 메모리 재할당을 수행하게 됩니다.( 같다면 )

 

결국 vector는 이러한 메모리 재할당과 이전 원소 복사 문제가 발생할 수 있습니다. 그래서 vector는 미리 메모리를 할당할 수 있는 메모리 예약 함수 reserve()를 제공합니다. reserve()를 사용하면 미리 메모리를 할당해 capacity를 결정하고 vector에 원소가 추가되더라도 메모리를 재할당 하지 않습니다.

 

 

[ vector 생성자 사이즈 변경및 초기화 ]

1
2
3
4
5
// 기본값 0으로 초기화된 size가 5인 컨테이너
    vector<int> v1(5);        // 0,0,0,0,0    
    // 기본값 10으로 초기화된 size가 5인 컨테이너
    vector<int> v2(5,10);    // 10,10,10,10,10
 

 

[ vector resize함수 사용, 사이즈변경및 초기화 ]

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    vector<int> v3(5); // 이 선언으로 0,0,0,0,0 원소가 있다.
    // 원소가 있으므로, push_back하지 않고 변경해준다.
    v3[0] = 10; 
    v3[1] = 20;
    v3[2] = 30;
    v3[3] = 40;
    v3[4] = 50;    
 
    // resize함수로 초기값이 0인 size가 10인 컨테이너 생성
    v3.resize(10);// 10,20,30,40,50,0,0,0,0,0
 
    // 사이즈는 줄었지만, capacity는 변경없음( size : 5,  capacity : 10 )
    v3.resize(5); // 10,20,30,40,50    
    // resize(10, 100 ) : size를 10으로 확장하고 추가되는 원소를 100으로 초기화

 

[ vector의 clear()함수와 empty() 함수 ]

 

1
2
3
4
5
6
7
8
9
10
11
    v3.clear(); // size : 0 capacity : 5
    // ※clear한다고 해서 메모리(capacity)가 제거되지 않음
    if( v3.empty() ){
        cout<<"비었다"<<endl;
    }
 
    /**
    * 메모리(capacity)를 완전히 제거하는방법
    */    
    //임시객체 기본생성자로 만든vector컨테어나와 v3 swap한다
    vector<int>().swap(v3); // size : 0, capacity : 0

 

[ swap함수를 이용하여 원소교환 ]

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
vector<int> v4;
    v4.push_back(10);
    v4.push_back(20);
    v4.push_back(30);
    vector<int> v5;
    v5.push_back(100);
    v5.push_back(200);
    v5.push_back(300);
    v4.swap(v5);
 
    //v4의 원소들과 v5원소들이 교환됨
    for(vector<int>::size_type i = 0; i < v4.size(); ++i){
        cout<< v4[i] << "," << v5[i] <<endl;
    }
    cout<<endl;



[ front(), back() 함수 ]

 

1
2
3
4
5
6
7
8
9
10
cout<< v4[0] << "," << v4.front() <<endl; // v4[0]은 v4.at(0)과 같음
    cout<< v4[2] << "," << v4.back() <<endl;
 
    // 원소 수정    
    v4.front() = 10;    
    v4.at(1)   = 20;
    v4.back()  = 30;    
    cout<< v4[0] << "," << v4.front() <<endl;
    cout<< v4[1] << "," << v4.at(1) <<endl;
    cout<< v4[2] << "," << v4.back() <<endl;

 

 

vector와 deque은 일반 배열처럼 임의 취치의 원소를 참조하는 두 인터페이스르 제공합니다.

 

[] 연산자 :  범위 점검을 하지 않아 속도가 빠르며

at(index) 멤버함수 : 범위 점검을 해서 안전함, 범위가 넘어가면 out_of_range 예외 발생

 

 

[ assign() 멤버 함수 ]

 

1
2
    vector<int> v6(5, 1); // 초기값1인 5개의 원소를 갖는 컨테이너 생성
    v6.assign(5, 10); // 5개의 원소값을 2로 할당(n개의 원소에 x의값을 할당합니다.)

 

 

[ begin(), end() 멤버 함수, 상수 반복자 ]

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    vector<int>::iterator Iter;
    vector<int>::const_iterator const_Iter;
 
    for( Iter = v6.begin(); Iter != v6.end(); ++Iter ){
        cout<< *Iter << endl;
    }
    cout<<endl;
 
    const_Iter = Iter = v6.begin();
    cout<< *(++Iter) <<endl;
    cout<< *(++const_Iter) <<endl;
 
    *Iter = 40;
//    *const_Iter = 50; 상수반복자는 원소변경 못함( const int* )

 

 

[ const키워드와 반복자 ]

 

1
2
3
4
vector<int>::iterator Iter; //다음원소 이동가능, 원소변경 가능
vector<int>::const_iterator const_Iter;//다음원소 이동가능, 원소변경 불가능
const vector<int>::iterator Iter_const;//다음원소 이동불가능, 원소변경 가능
const vector<int>::const_iterator const_Iter_const; //둘다 불가능
 

반대로 동작하는 역방향 반복자( reverse_Iterator )

reverse_iterator는 vector에 반복자 어댑터로 typedef되어 있습니다.

 

 

[ insert() 멤버함수 ]

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    vector<int>::iterator Iter_v6 = v6.begin()+2; //10,20,30,40,50에서 30을 가르킴    
 
    // Iter_v6가 가르키는 위치에 100을 삽입하고 삽입한 100의 위치를 가르키는 반복자
    // 를 리턴하여 Iter_insertPos에 대입한다.
    vector<int>::iterator Iter_InsertPos = v6.insert(Iter_v6, 100);
    
 
    // Iter_InsertPos가 가리키는 위치에 정수 200을 3개 삽입
    v6.insert(Iter_InsertPos, 3, 200 );
 
 
    // Iter_InsertPos가 가리키는 위치에 v4의 구간 [b,e)의 원소 삽입
    vector<int> v7;
    v7.push_back(100);
    v7.push_back(200);
    v7.push_back(300);
    Iter_v6 = v6.begin(); //10을 가르킴
    v6.insert(Iter_v6, v7.begin(), v7.end() );
    
    for( Iter_v6 = v6.begin(); Iter_v6 != v6.end(); ++Iter_v6 ) {
        cout<< *Iter_v6 <<endl;
    }

 

[ erase() 멤버함수 ]

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <iostream>
#include <vector>
 
using namespace std;
 
int main(){
    
    /**
    * erase() 멤버함수
    */
 
    vector<int> v;
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    v.push_back(50);
 
    vector<int>::const_iterator Iter = v.begin()+1;
    //Iter가 가르키는 위치의 원소 20 을 제거합니다. 제거된 원소의 다음원소를 리턴
    //리턴된 반복자를 erase_Iter에 대입합니다. 30
    vector<int>::const_iterator erase_Iter = v.erase( Iter );
 
    for( Iter = v.begin(); Iter != v.end(); ++Iter ){
        cout<< *Iter << endl;
    }
    cout<<endl;
    cout<<"제거후 리턴된 반복자가 가르키는 값 : "<< *erase_Iter <<endl;
    cout<<endl;
 
    // 구간 [b,e) 사이의 모든 원소를 지운다. 10만 남겨놓고 30,40,50 지움
    // erase()멤버함수에서 리턴되는 반복자는 NULL을 가르키게된다.v.end()
    v.erase(v.begin()+1, v.end());
    for( Iter = v.begin(); Iter != v.end(); ++Iter ){
        cout<< *Iter << endl;
    }    
 
    system("pause");
    return 0;
}

 

[ 반복자로 동작하는 생성자와 assign() 멤버함수 ]

 

1
2
3
vector<int> v2(v.begin(), v.end()); // 순차열[b,e) 생성자로 초기화
vector<int> v3;
v3.assign(v2.begin(), v2.end()); //순차열 [b,e) v3에 할당

 

vector의 생성자는 반복자를 통해서 초기화될 수 있으며 assign() 멤버 함수도 반복자를 통해 할당될 수 있습니다.

 

 

[ vector와 vector의 비교 컨테이너 연산자 ]

 

컨테이너 연산자 : ==, !=, <, <=, >, >=

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <iostream>
#include <vector>
using namespace std;
 
int main(){
 
    vector<int> v1;
    v1.push_back(10);
    v1.push_back(20);
    v1.push_back(30);
    v1.push_back(40);
    v1.push_back(50);
    vector<int> v2;
    v2.push_back(10);
    v2.push_back(20);
    v2.push_back(50);
 
    if( v1 == v2 ){ //모든원소가 같다면
        cout<<"v1 == v2"<<endl;
    }
    if( v1 != v2 ){ //모든원소가 같지 않다면
        cout<<"v1 != v2"<<endl;
    }
 
    // 순차열의 원소를 하나씩 순서대로 비교하여
    // v2의 원소가 크다면 참 아니면 거짓
    // 10 == 10, 20 == 20, 30 < 50 여기서 v2가 큼
    if( v1 < v2 ){ 
        cout<<"v1 < v2"<<endl;
    }
 
    system("pause");
    return 0;
}


저작자표시

'0x0001 > STL' 카테고리의 다른 글

[C++ STL] 연관 컨테이너 - 셋(set)  (0) 2019.02.16
[C++ STL] 시퀀스 컨테이너 - 리스트(list)  (0) 2019.02.16
[C++ STL] 시퀀스 컨테이너 - 덱(deque)  (0) 2019.02.16
[C++ STL] STL 구성요소( 컨테이너, 반복자, 알고리즘, 함수객체, 어댑터, 할당기 )  (0) 2019.02.16
[C++ STL] STL ( Standard Template Library ) 이란?  (0) 2019.02.16

 

1. 컨테이너

 

컨테이너는 같은 타입을 저장, 관리할 목적으로 만들어진 클래스 입니다.

 

▣ 표준 시퀀스 컨테이너 ( Standard Sequence Container )

 - 컨테이너 원소가 자신만의 삽입 위치(순서)를 가지는 컨테이너 ( vector, list, deque : 선형 구조 )

 - 삽입되는 순서에 따라 원소의 위치가 결정되고 바뀌지 않습니다.

 - 컨테이너 끝에 데이터를 추가하고 제거하기 위한 push_back()과 pop_back() 멤버함수를 가집니다.

 

▣ 표준 연관 컨테이너 ( Standard Associative Container )

 - 저장 원소가 삽입 순서와 다르게 특정 정렬 기준에 의해 자동 정렬되는 컨테이너 ( set, multiset, map, multimap : 비선형 구조 )

 - 삽입 순서와 상관없이 정렬 기준 ( default : less )에 따라 원소의 위치가 결정 됩니다.

 

 

컨테이너는 데이터를 하나의 연속된 메모리 단위로 저장하느냐에 따라 두가지로 나눕니다.

 

▣ 배열 기반 컨테이너( Array-based Container ) : 데이터 여러개가 하나의 메모리 단위에 저장됩니다.

 - vector, deque

 - operator[] 연산자를 이용해 일반 배열처럼 컨테이너 원소에 접근할 수 있습니다.

 

▣ 노드 기반 컨테이너( Node-based Container ) : 데이터 하나를 하나의 메모리 단위에 저장합니다.

 - list, set, multiset, map, multimap

 

모든 컨테이어는 원소의 개수를 반환하는 size() 멤버 함수를 가집니다.

 

 

--------------------------------------------------------------------------------------------------------------------------

2. 반복자

 

반복자는 컨테이너에 저장된 원소를 순회하고 접근하는 일반화된 방법을 제공합니다.

반복자는 컨테이너와 알고리즘이 하나로 동작하게 묶어주는 인터페이스 역할을 합니다.

특정 컨테이너에 종속적이지 않고 독립적이면서도 언제든지 컨테이너와 결합하여 동작할 수 있습니다.

 

반복자의 특징

 - 컨테이너 내부의 원(객체)를 가리키고 접근할 수 있어야 합니다. ( * 연산자 제공 )

 - 다음원소로 이동하고 컨테이너의 모든 원소를 순회할 수 있어야 합니다. ( ++,!=,== 연산자 제공 )

 

 

STL에서 컨테어너 원소(객체)의 집합을 순처열( Sequence )이라 하고, 순차열은 하나의 시작과 하나의 끝을 갖습니다. 여기서 반복자는 순차열의 한 원소를 가리킵니다.

 

STL의 모든 컨테이너는 자신만의 반복자를 갖습니다. 멤버함수 begin()과 end()가 순차열의 시작과 끝을 가리키는 반복자를 반환합니다.

 

 

반복자                                                   반복자

begin()                                                  end()

 

A            B           C          D           E        n

                           

                         Iterator

 

 

※ 순차열 [begin, end) 구간의 원소는 A,B,C,D,E, [begin, iter) 구간의 원소는 A,B [iter, end) 구간의 원소는 C,D,E 입니다.

    만일 순차열[p, q)에서 p,q가 가리키는 원소가 같다면 이 순차열은 원소가 없습니다.

 

◎ 입력 반복자( Input Iterator ) : 현 위치의 원소를 한 번만 읽을 수 있는 반복자

◎ 출력 반복자( Output Iterator ) : 현 위치의 원소를 한 번만 쓸 수 있는 반복자

◎ 순반향 반복자( Forward Iterator ) : 입력, 출력 반복자 기능에 순방향으로 이동(++)이 가능한 재할당될 수 있는 반복자

◎ 양방향 반복자( Bidirectional Iterator ) : 순방향 반복자 기능에 역방향으로 이동(--)이 가능한 반복자

 - list, set, multiset, map, multimap

◎ 임의 접근 반복자( Random Access Iterator ) : 양방향 반복자 기능에 +,-,+=,-=,[] 연산이 가능한 반복자

 - vector, deque

 

모든 컨테이너는 양방향 반복자 이상을 제공 합니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
#include <vector>
using namespace std;
 
int main( )
{
    vector<int> v; 
 
    v.push_back(10); 
    v.push_back(20);
    v.push_back(30);
    v.push_back(40);
    v.push_back(50);
 
    vector<int>::iterator iter=v.begin(); //시작 원소를 가리키는 반복자
    cout << iter[0] << endl; // [] 연산자
    cout << iter[1] << endl;
    cout << iter[2] << endl;
    cout << iter[3] << endl;
    cout << iter[4] << endl;
    cout << endl;
 
    iter += 2; // += 연산
    cout << *iter << endl;        // 30
    cout << endl;
 
    vector<int>::iterator iter2 = iter+2; // + 연산
    cout << *iter2 << endl;        // 50
 
    system("pause");
    return 0;
}

 

 

--------------------------------------------------------------------------------------------------------------------------

3. 알고리즘

 

STL은 순차열의 원소를 조사, 변경, 관리, 처리할 목적으로 알고리즘이라는 구성요소를 제공합니다.

알고리즘은 한 쌍의 반복자([begin, end))을 필요로 하며 알고리즘 대부분은 순방향 반복자를 요구하지만, 몇몇 알고리즘은 임의 접근 반복자를 요구 합니다.

 

 

[알고리즘 일곱 가지의 범주로 분류]

 

◇ 원소를 수정하지 않는 알고리즘

◇ 원소를 수정하는 알고리즘

◇ 제거 알고리즘

◇ 변경 알고리즘

◇ 정렬 알고리즘

◇ 정렬된 범위 알고리즘

◇ 수치 알고리즘

 

 

find 알고리즘 : 순방향 반복자를 요구, 순방향 반복자만 지원하는 컨테이너(순차열)이라면, 어떤 컨테이너가 와도 알고리즘 수행가능

 

1
2
3
4
5
6
7
8
9
10
#include <algorithm> // find 사용
    
vector<int>::iterator iter;
iter = find(v.begin(), v.end(), 20); //[begin, end)에서 20 찾기
cout << *iter << endl;
 
iter = find(v.begin(), v.end(), 100); //[begin, end)에서 100 찾기
if( iter == v.end() ) // 100이 없으면 iter==v.end() 임
    cout << "100이 없음!" << endl;
        

 

 

sort 알고리즘 : 순차열을 정렬, 임의 접근 반복자를 요구, vector와 deque는 sort알고리즘을 수행할 수 있지만, 다른컨테이너는 불가능합니다. 연관컨테이너는 컨테이너만의 정렬 기준을 가지고 있습니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <vector>
#include <list>
#include <algorithm>
using namespace std;
 
vector<int> v; 
v.push_back(50); 
v.push_back(40);
v.push_back(30);
v.push_back(20);
v.push_back(10);
 
list<int> lt;
lt.push_back(10); 
lt.push_back(20);
lt.push_back(30);
lt.push_back(40);
lt.push_back(50);
 
sort(v.begin(), v.end()); // 정렬 가능(vector는 임의 접근 반복자)
                          // 디폴트 less, 오름차순 정렬
//sort(lt.begin(), lt.end()); // 에러!(list는 양방향 반복자)
 
for( vector<int>::iterator Iter = v.begin(); Iter != v.end(); ++Iter ){
       cout<< *Iter <<endl;
}
 

 

 

--------------------------------------------------------------------------------------------------------------------------

4. 함수객체

 

STL 에서 함수 객체는 클라이언트가 정의한 동작을 다른 구성 요소에 반영하려 할 때 사용 됩니다.

STL 알고리즘이 함수 객체, 함수, 함수 포인터 등의 함수류를 인자로 받아 알고리즘을 유연하게 동작 시킵니다.

 

 

1
2
3
 
sort(v.begin(), v.end(), less<int>() );    // 오름차순 정렬
sort(v.begin(), v.end(), greater<int>() ); // 내림차순 정렬

 

 

--------------------------------------------------------------------------------------------------------------------------

5. 어댑터

 

구성 요소의 인터페이스를 변경합니다.

 

[ 어댑터 종류 ]

 

◇ 컨테이너 어댑터 ( Container Adaptor ) : stack, queue, priority_queue

 - stack 컨테이너 어댑터는 일반 컨테이너를 LIFO 방식의 스택 컨테이너로 변환합니다.

empty, size, push_back, pop_back, back 인터페이스(멤버함수)를 지원하는 컨테이너는 모두 LIFO방식의 스택으로 변환할 수 있습니다.

시퀀스 컨테이너는 모두 멤버함수를 가지므로 stack 컨테이너 어댑터의 컨테이너로 이용할 수 있습니다.

stack 컨테이너 어댑터의 디폴트 컨테이너는 deque 컨테이너 입니다.

 

[stack 컨테이너]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <iostream>
#include <stack>
using namespace std;
 
int main(){
 
    stack<int> s;
    s.push(10);
    s.push(20);
    s.push(30);
 
 
    cout<< s.top() << endl;    //30
    s.pop();
    cout<< s.top() << endl; //20
    s.pop();
    cout<< s.top() << endl; //10
    cout<< s.top() << endl; //10
    s.pop();
 
    if( s.empty() ){
        cout<<"empty"<<endl;
    }
 
    system("pause");
    return 0;
}

 

 

[vector 컨테이너를 적용한 stack 컨테이너]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
 
void main( )
{
    stack<int, vector<int> > st; // vector 컨테이너를 이용한 stack 컨테이너 생성
 
    st.push( 10 ); // 데이터 추가(입력)
    st.push( 20 );
    st.push( 30 );
 
    cout << st.top() << endl; // top 데이터 출력
    st.pop(); // top 데이터 삭제
    cout << st.top() << endl;
    st.pop();
    cout << st.top() << endl;
    st.pop();
 
    if( st.empty() ) // 스택이 비었는지 확인
        cout << "stack이 데이터 없음" << endl;
}

 

 

◇ 반복자 어댑터 ( Iterator Adaptor ) : reverse_iterator, back_insert_iterator, front_insert_iterator, insert_iterator

 - reverse_iterator는 일반 반복자의 동작 방식을 반대로 동작시키는 역방향 반복자(reverse_iterator)로 변환합니다.

 - 역방향 반복자는 반복자가 가리키는 원소와 실제 가리키(참조)는 값이 다르다는 점입니다. 반복자가 가리키는 원소 다음 원소의 값을 참조 합니다. 이렇게 설계한 이유는 알고리즘 수행 시 정방향 반복자와 호환되도록 하기 위해서 입니다.

 

1
2
3
4
5
6
//일반 반복자 iterator를 역방향 반복자 reverse_iterator로 변환
reverse_iterator< vector<int>::iterator > riter(v.end());
reverse_iterator< vector<int>::iterator > end_riter(v.begin());
 
for(   ; riter != end_riter ; ++riter )
    cout << *riter << " ";

 

        begin()                                                       end()

          10           20         30          40          50          n

        end_riter( 10을 가르키고, 10앞의 값을 참조)      riter( n을 가르키고 50의 값을 참조 )

 

위의 설계의 장점은

--연산자를 사용하지 않고 ++ 연산자만으로 정방향, 역방향의 순회가 모두 가능 하다는 점입니다. 이는 대부분의 알고리즘이 ++연산자만 으로 구현 되어 있으며 이렇게 이미 구현된 알고리즘에 정방향과 역방향 순회가 모두 가능하게 합니다.

 

정방향 순회시 순차열 구간의 원소는 반복자 이전까지를 나타내는 것을 생각해보면 역방향시 반복자가 가르키는 원소의 앞의 값을 참조하는것이 역방향으로 순회시 ++연산자로 순회를 가능하게 해주는 것 입니다.

 

1
2
3
4
5
// STL 모든 컨테이너는 반복자 어댑터 reverse_iterator를 typedef 타입으로 정의하며
// rbegin(), rend()로 컨테이너의 역방향 반복자를 반환함.
vector<int>::reverse_iterator riter(v.rbegin()); 
for(   ; riter != v.rend() ; ++riter )
    cout << *riter << " ";

 

 

 

◇ 함수 어댑터 ( Function Adaptor ) : 바인더( binder ), 부정자( negator ), 함수 포인터 어댑터( adaptor for pointers to functions )

 - not2는 조건자 함수 객체(이항)를 NOT(반대)로 변환합니다. ( 조건자는 bool타입을 반환하는 함수류 입니다 )

 - not1은 단항 조건자에 사용되며, not2는 이항 조건자에 사용 됩니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <iostream>
#include <functional> //not2 사용
using namespace std;
 
int main( )
{
    //임시 less 객체로 비교
    cout << less<int>()(10, 20) << endl; // 1
    cout << less<int>()(20, 20) << endl; // 0
    cout << less<int>()(20, 10) << endl; // 0
    cout << "==============" <<endl;
    // 임시 객체 less에 not2 어댑터 적용
    cout << not2( less<int>() )(10, 20) << endl; // 0
    cout << not2( less<int>() )(20, 20) << endl; // 1    
    cout << not2( less<int>() )(20, 10) << endl; // 1
    cout << endl;
 
    /**
    * not2( less<int>() ) 이 구문은
    * less함수객체가 < 연산이므로 반대 의미가 있는 >=연산 기능의 함수객체를 반환하게 됩니다.
    */
 
    less<int> l;
    cout << l(10, 20) << endl; // less 객체 l로 비교    
    cout << l(20, 20) << endl;    
    cout << l(20, 10) << endl;
    cout << "==============" <<endl;
    cout << not2( l )(10, 20) << endl; // less 객체 l에 not2 어댑터 적용
    cout << not2( l )(20, 20) << endl;
    cout << not2( l )(20, 10) << endl;
 
    system("pause");
    return 0;
}

 

 

--------------------------------------------------------------------------------------------------------------------------

6. 할당기

 

컨테이너의 메모리 할당 정보와 정책(메모리 할당 모델)을 캡슐화한 STL 구성 요소입니다.

할당기는 템플릿 클래스이며, 모든 컨테이너는 기본 할당기를 사용합니다.

 

사용자 정의 할당기는 사용자가 직접 메모리 할당 방식을 제어할 수 있게 합니다.

 

모든컨테이너는 템플릿 매개변수에 할당기를 인자로 받습니다. 기본할당기는 allocator<T>이며, 컨테이너는 템플릿 매개변수에 디폴트 매개변수 값으로 기본 할당기를 지정합니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
#include <vector>
#include <set>
#include <map>
using namespace std;
 
void main( )
{
    //vector<typename T, typename Alloc = allocator<T> >
    // vector<int> 와 같음
    vector< int, allocator<int> > v;
    v.push_back( 10 );
    cout << *v.begin() << endl;
 
    //set<typename T, typename Pred = less< T >, typename Alloc = allocator<T> >
    // set<int> 와 같음
    set< int, less<int>, allocator<int> > s;
    s.insert( 10 );
    cout << *s.begin() << endl;
}

 

 

저작자표시

'0x0001 > STL' 카테고리의 다른 글

[C++ STL] 연관 컨테이너 - 셋(set)  (0) 2019.02.16
[C++ STL] 시퀀스 컨테이너 - 리스트(list)  (0) 2019.02.16
[C++ STL] 시퀀스 컨테이너 - 덱(deque)  (0) 2019.02.16
[C++ STL] 시퀀스 컨테이너 - 벡터(vector)  (0) 2019.02.16
[C++ STL] STL ( Standard Template Library ) 이란?  (0) 2019.02.16


STL은 표준 C++ 라이브러리의 일부분으로 Standard Template Library의 약자입니다.

STL은 프로그램에 필요한 자료구조와 알고리즘을 템플릿으로 제공하는 라이브러리입니다.

자료구조와 알고리즘은 서로 반복자라는 구성요소를 통해 연결합니다.

 

[STL의 구성요소]

 

컨테이너( Container ) : 객체를 저장하는 객체로 컬렉션 혹은 자료구조라고도 합니다.

 

반복자( Iterator ) : 포인터와 비슷한 개념으로 컨테이너의 원소를 가리키고, 가리키는원소에 접근하여 다음원소를 가리키게하는 기능을 합니다.

 

알고리즘( Algorithm ) : 정렬, 삭제, 검색, 연산 등을 해결하는 일반화된 방법을 제공하는 함수 템플릿입니다.

 

함수객체( Function Object ) : 함수처럼 동작하는 객체로 operator() 연산자를 오버로딩한 객체입니다. 컨테이너와 알고리즘 등에 클라이언트 정책을 반영하게 합니다.


어댑터( Adaptor ) : 구성 요소의 인터페이스를 변경해 새로운 인터페이스를 갖는 구성요소로 변경합니다(새로운 구성 요소처럼 보입니다)

 

할당기( Allocator ) : 컨테이너의 메모리 할당 정책을 캡슐화한 클래스 객체로 모든 컨테이너는 자신만의 기본 할당기를 가지고 있습니다.

 

 

[STL의 3가지 특징]

효율성, 일반화 프로그램( 재사용성), 확장성

 

STL알고리즘은 너무나도 일반적입니다. 특정한 자료구조와 형식에 종속저이지 않고, 효율성도 다른 라이브러리에 뒤지지않을 뿐만아니라 사용자가 작성한 구성 요소와도 잘 동작하며, 확장성도 뛰어납니다.

 

 

 

저작자표시

'0x0001 > STL' 카테고리의 다른 글

[C++ STL] 연관 컨테이너 - 셋(set)  (0) 2019.02.16
[C++ STL] 시퀀스 컨테이너 - 리스트(list)  (0) 2019.02.16
[C++ STL] 시퀀스 컨테이너 - 덱(deque)  (0) 2019.02.16
[C++ STL] 시퀀스 컨테이너 - 벡터(vector)  (0) 2019.02.16
[C++ STL] STL 구성요소( 컨테이너, 반복자, 알고리즘, 함수객체, 어댑터, 할당기 )  (0) 2019.02.16



NEW:
- Implemented new cube behaviours allowing you to create unique puzzle mechanics;
- Included an example scene of a Sokoban style game mechanic;
- Included a reference scene showing different cube behaviour possibilities.

Create a roll-a-cube puzzle style game with the “Jelly Cube – Game Starter Kit”

Features:
- Mobile friendly;
- Roll-a-Box’ Puzzle mechanics with several levels of challenges and great visuals;
- Create different mechanics changing the way the cubes act on each other;
- All source code included;
- Documentation explaining how to create new levels;
- Easy to play. Easier to Implement new levels;
- Includes an example of a Sokoban style game mechanic;
- Beautiful Rubber/Jelly Effect Script to use in another projects.

This pack includes a complete working game prototype, with nice and challenging gameplay, and ready to create new levels or use as basis to create a new game.

Asset version: 1.2.2


More Info: https://assetstore.unity.com/packages/templates/systems/jelly-cube-game-starter-kit-42756


저작자표시

'0x0010 > Unity Asset' 카테고리의 다른 글

Drawing & Coloring (Extra Edition) v1.1.1  (0) 2019.02.16
MaterialUI v1.1.8  (0) 2019.02.16
Mobile Fast Shadow v1.0.6  (0) 2019.02.16
Bubble Shooter Match 3 Complete Project  (0) 2019.02.16
Smooth Sync v3.15  (0) 2019.02.16



Extra Drawing And Coloring Package.
Pick up the tools in the bottom to draw on Screen and paint the Characters. Use the Hand Tool to Zoom/Pinch Zoom & Drag the picture.

Ready for publish

ey Features

- Tools List :
1. Pencil
2. Crayon
3. Brush
4. Paint
5. Paint Roller
6. Paint Can
7. Sparkle
8. Stamp
9. Eraser
10. Hand

- 17 Built-in Characters~New
- Advertisements Manager ~New
- Admob Integration ~New
- ChartBoost Integration ~New
- Unity Ads Integration ~New
- Bezier Path option for Smooth Lines
- Zoom IN/OUT & Pinch Zoom
- Web Screenshot Print & Export
- Ability to Undo/Redo
- Shapes Manager
- Singleton Manager
- 14 Colors and you can add more
- Trash with Confirm Dialog
- Mouse and Touch Cursor
- LineRenderer based
- 2D Sprites Used
- 14 Sprites per Tool
- Scrollable Lists
- Scrollable shapes selector
- Temp Draw saving between Shapes
- Commented source code in C#
- Landscape Orientation
- Mobile support IOS & Android
- Package Manual

Note :
The Filling Tool is implemented without using any algorithm ,you must slice your character into separate white parts to fill each one .

Works with Unity 5.5.0 or Higher built-in features. As well as supports Unity 2017 and Unity 2018 or Higher.

Asset version: 1.1.1


More Info: https://assetstore.unity.com/packages/templates/packs/drawing-coloring-extra-edition-43865


저작자표시

'0x0010 > Unity Asset' 카테고리의 다른 글

Jelly Cube Game Starter Kit v1.2.2  (0) 2019.02.16
MaterialUI v1.1.8  (0) 2019.02.16
Mobile Fast Shadow v1.0.6  (0) 2019.02.16
Bubble Shooter Match 3 Complete Project  (0) 2019.02.16
Smooth Sync v3.15  (0) 2019.02.16



It's now easier than ever to create beautiful Material Design layouts in your apps and games with MaterialUI!

Almost all of the components featured in Google's Material Design specification can be created with the click of a button, then tweaked and modified with powerful editor tools.

MaterialUI components act just like those in Unity's UI system, and are designed to be as compatible as possible with other uGUI-based assets.

These aren't just image elements; this is a real, full implementation of Material Design in Unity - pixel-perfect controls with gorgeous animations that are intended to take the place of the default uGUI components (eg. Input Field, Dropdown, toggles etc)

Features include...
- Menus to easily create all types of components
- Integrated (code and in-editor) Tween engine
- Complex dialogs that can be called with a single line of code (eg. Alert, Checkbox, List, Loading, Time picker, Date picker etc...),
- Screen component to create awesome animations between screens
- Example scenes for every type of control
- Vector icon support (via fonts)
- Full editor integration
- Material Design color palettes
- Full C# source code
- Great support
- And much more!

Asset version: 1.1.8


More Info: https://assetstore.unity.com/packages/tools/gui/materialui-51870


저작자표시

'0x0010 > Unity Asset' 카테고리의 다른 글

Jelly Cube Game Starter Kit v1.2.2  (0) 2019.02.16
Drawing & Coloring (Extra Edition) v1.1.1  (0) 2019.02.16
Mobile Fast Shadow v1.0.6  (0) 2019.02.16
Bubble Shooter Match 3 Complete Project  (0) 2019.02.16
Smooth Sync v3.15  (0) 2019.02.16



Feature:

• Simple and easy to use.

• For mobile phones (Window、IOS and Android).

• Shadow direction can be adjusted.

• Shadow quality can be adjusted.

• Shadow supports custom colors.

• Shadow shade can be adjusted.

• DEMO demonstration scene and comparison of the performance.

Asset version: 1.0.6


More Info: https://assetstore.unity.com/packages/tools/utilities/mobile-fast-shadow-56865


저작자표시

'0x0010 > Unity Asset' 카테고리의 다른 글

Drawing & Coloring (Extra Edition) v1.1.1  (0) 2019.02.16
MaterialUI v1.1.8  (0) 2019.02.16
Bubble Shooter Match 3 Complete Project  (0) 2019.02.16
Smooth Sync v3.15  (0) 2019.02.16
GUI Animator for Unity UI v1.2.0  (0) 2019.02.13


Best template for your great bubble shooter match 3 game. Full monetization. 


Features
✔ EDITOR
✔ Ads monitization
✔ 55 levels
✔ IAPs crossplatform (Android, iOS)
✔ Animated GUIs
✔ 2 types of gameplay
✔ Aiming shoots
✔ Requires Unity3D 5.3 or higher
✔ Animated Powerful Boosts
✔ Amazing map
✔ Settings menu
✔ Cute main character


More Info: https://assetstore.unity.com/packages/templates/packs/bubble-shooter-match-3-complete-project-34517


저작자표시

'0x0010 > Unity Asset' 카테고리의 다른 글

MaterialUI v1.1.8  (0) 2019.02.16
Mobile Fast Shadow v1.0.6  (0) 2019.02.16
Smooth Sync v3.15  (0) 2019.02.16
GUI Animator for Unity UI v1.2.0  (0) 2019.02.13
LipSync Pro v1.44  (0) 2019.02.13

+ Recent posts

티스토리툴바