[C++] 반복자( Iterator )에 대한 설명과 종류

 

반복자( Iterator )란 무엇인가?

Iterator는 컨테이너에서 원소의 위치를 표현하는, 포인터와 같은 객체입니다.

 

여기서, 컨테이너란 다른 객체들을 담는 집합 객체라고 할 수 있습니다. 

컨테이너의 예로 STL vector, list, map, set 등이 있습니다.

 

Iterator 객체는 이러한 컨테이너 내의 원소에 접근하고, 원소 간의 이동을 하기 위해서 사용됩니다.

그리고, STL 컨테이너들은 자신의 원소에 접근을 할 수 있도록 Iterator를 제공하는 함수들을 갖고 있습니다.

 

예를 들어, vector의 처음 원소에 접근하고자 한다면, vector가 제공하는 begin() 함수를 사용하면 됩니다.

이 begin() 함수는 첫 번째 원소의 위치를 가리키는 Iterator를 반환합니다.

 

반복자 선언과 초기화

컨테이너의 Iterator를 선언하기 위해선 [ 컨테이너 <데이터타입>::Iterator 객체 명 ]의 형식을 가집니다.

vector<int>::iterator vecIter;		// int형 vector iterator 객체

vector<int> vecTest = {1,2,3};
vecIter = vecTest.begin();

vector<double>::iterator vecIter2;	// double형 vector iterator 객체
vecIter2 = vecTest.begin();		// error !!

 

주의해야 할 점은, 컨테이너의 데이터 타입과 맞지 않는 Iterator를 사용할 수 없다는 점입니다.

데이터 간의 이동하는 기능을 구현하는데 가장 중요한 것이 데이터 타입입니다.

따라서, 데이터 타입이 맞지 않으면, Iterator의 기능은 제대로 동작하지 못합니다.

 

그리고, Iterator를 선언할 때도 auto 키워드를 사용할 수 있습니다.

auto는 컴파일러가 선언된 변수 또는 변수의 초기화 식을 사용하여 해당 형식을 추론하도록 지시하는 키워드입니다.

 list<string> listTest = {"one", "two", "three"};
    
 list<string>::iterator listIter = listTest.begin(); // ok

 auto listIter2 = listTest.begin();  // ok 위 문장과 똑같은 기능을 합니다.

 

반복자의 기본적인 연산자

Iterator 객체는 컨테이너 원소 간의 이동 및 접근을 위한 많은 연산자들을 갖고 있습니다.

아래 표에 가장 기본적인 연산자들을 정리했습니다.

포인터( pointer )의 연산자를 생각해 보면, 의도적으로 같은 방식의 연산자를 구현하고 있음을 알 수 있습니다.

 

연   산   자	설                                  명
*iter	iterator가 가리키는 객체를 리턴
iter->m	iterator가 가리키는 객체의 멤버를 리턴
iter++	iterator를 다음 위치로 이동
iter--	iterator를 이전 위치로 이동
iter + i	iterator를 i 만큼 이동
iter1 == iter2	iter1과 iter2가 가리키는 위치가 같으면 true를 리턴
iter1 != iter2	iter1과 iter2가 가리키는 위치가 다르면 true를 리턴
iter = iterOther	다른 iterator가 가리키는 위치를 대입

 

이제, Iterator를 사용하는 기본적인 예를 들어보겠습니다.

#include <iostream>
#include <vector>
using namespace std;

int main(){

    vector<string> vecNation = {"korea", "japan", "america"};
    
    vector<string>::iterator vecIter;

    for( vecIter = vecNation.begin(); vecIter != vecNation.end(); vecIter++){
        cout << *vecIter << " ";
    }

    return 0;
}

▼출력

korea japan american

위 예제는 vector의 시작 원소부터 마지막 원소까지 출력하는 예제입니다.

 

여기서, vector의 end() 함수는 vector의 마지막 원소를 가리키는 것이 아니라, 마지막 원소 다음을 가리킨다는 점을 기억해야 합니다.

만약, end() 함수가 마지막 원소를 가리킨다면, 위의 예제는 마지원 원소를 출력할 수 없습니다.

 

vector 원소의 위치

 

반복자( Iterator )의 종류

Iterator는 지원하는 기능에 따라 5가지 종류의 Iterator가 있습니다.

 

• 입력 반복자( input iterator )
• 출력 반복자( output iterator )
• 순방향 반복자( forward iterator )
• 양방향 반복자( bidirectional iterator )
• 임의 접근 반복자( random access iterator )

 

이렇게 종류가 나눠지는 이유는 Iterator를 사용하는 컨테이너와 알고리즘이 요구하는 기능이 제각각이기 때문입니다.

 

다음은 컨테이너가 지원하는 Iterator의 종류입니다.

컨테이너	지원하는 Iterator
vector	임의 접근 반복자
list	양방향 반복자
deque	임의 접근 반복자
map	양방향 반복자
set	양방향 반복자
stack	지원하지 않음
queue	지원하지 않음

 

입력 반복자(input iterator)

입력 반복자는 읽기 전용이고, 진행만 가능한 Iterator입니다.

이 입력 Iterator가 지원하는 연산자는 다음과 같습니다.

++, *, ->, ==, !=

 

입력 반복자의 예로 input stream으로부터 값을 읽을 수 있는 istream_iterator를 들 수 있습니다.

#include <iostream>
#include <iterator>
using namespace std;

int main(){

    istream_iterator<int> input_iter(cin);	// 입력 iterator
    istream_iterator<int> end_iter;		// 스트림의 끝 iterator

    for(; input_iter != end_iter; input_iter++){
        int pow2 = *input_iter;
        pow2 = pow2 * pow2;
        
        cout << pow2 << " ";
    }

    return 0;
}

▼입력

1 2 3 4

▼출력

1 4 9 16

 

출력 반복자(output iterator)

출력 반복자는 쓰기 전용이고, 진행만 가능한 Iterator입니다.

이 출력 Iterator가 지원하는 연산자는 다음과 같습니다.

++, *, =

 

출력 반복자의 예로 output stream에 값을 쓸 수 있는 ostream_iterator를 들 수 있습니다.

#include <iostream>
#include <string>
#include <vector>
#include <iterator>
using namespace std;

int main(){

    vector<string> nations = { "korea", "japan", "america" };
    
    ostream_iterator<string> output_iter(cout);

    for( const string& nation : nations ){
        
        *output_iter++ = nation;
        *output_iter++ = " ";
    }

    return 0;
}

▼출력

korea japan america

 

순방향 반복자(forward iterator)

순방향 반복자는 읽기 / 쓰기 모두 가능하고, 진행만 가능한 Iterator입니다.

이 순방향 Iterator가 지원하는 연산자는 다음과 같습니다.

++, *, ->, ==, !=

 

forward_list의 iterator가 순방향 반복자입니다.

int main(){

    forward_list<int> lsNum = { 1, 2, 3, 4};
    
    forward_list<int>::iterator iter;   // 순방향 iterator

    for( iter = lsNum.begin(); iter != lsNum.end(); iter++){

        int val = *iter;    // 읽기

        *iter = val * val;  // 쓰기
    }

    // 변경된 값들 출력
    for( int val : lsNum ){ 
        cout << val << " ";
    }

    return 0;
}

▼출력

1 4 9 16

 

양방향 반복자(bidirectional iterator)

양방향 반복자는 읽기 / 쓰기 모두 가능하고, 앞과 뒤로 진행이 가능한 Iterator입니다.

이 양방향 Iterator가 지원하는 연산자는 다음과 같습니다.

++, --, 	// 양방향으로 이동하기 위한 연산자
*, ->, ==, !=

 

list, set, multiset, map, multimap의 iterator가 양방향 반복자입니다.

#include <iostream>
#include <list>
using namespace std;

int main(){

    list<int> lsNum = { 1, 2, 3, 4, 5 };
    
    list<int>::iterator iter;   // 양방향 iterator

    cout << "forward direction: ";

    for( iter = lsNum.begin(); iter != lsNum.end(); iter++){

        cout << *iter << " ";
    }

    cout << endl;

    cout << "backward direction: ";

    // 현재 iter는 lsNum의 마지막 원소를 가리키고 있습니다.

    while( iter != lsNum.begin() ){

        iter--;	// 뒤로 이동

        cout << *iter << " ";
    }

    return 0;
}

▼출력

forward direction: 1 2 3 4 5  
backward direction: 5 4 3 2 1

 

위의 예처럼, iter-- 연산자를 통해서 뒤로 갈 수도 있지만, reverse_iterator를 사용하는 방법도 있습니다.

#include <iostream>
#include <list>
using namespace std;

int main(){

    list<int> lsNum = { 1, 2, 3, 4, 5 };

    cout << "backward direction: ";

    list<int>::reverse_iterator iter;	// 반대 방향 iterator
    
    // begin(), end() 대신 rbegin(), rend()를 사용합니다.
    for( iter = lsNum.rbegin(); iter != lsNum.rend(); iter++){
        cout << *iter << " ";
    }

    return 0;
}

▼출력

backward direction: 5 4 3 2 1

 

임의 접근 반복자(random access iterator)

임의 접근 반복자는 읽기 / 쓰기 모두 가능하고, 앞과 뒤로 진행이 가능한 Iterator입니다.

그리고, 임의 접근이 가능합니다.

모든 iterator 중 가장 많은 기능을 가지고 있는 iterator입니다.

 

이 임의 접근 Iterator가 지원하는 연산자는 다음과 같습니다.

++, --, *, ->, [], 
!=, ==
+, -, 			// 이동하는 거리를 직접 입력할 수 있는 연산자
<, <=, >, >=	    	// 위치를 비교할 수 있는 연산자

 

vector, deque, array, string의 iterator가 임의 접근 반복자입니다.

int main(){

    array<int, 5> int_arr = {1,2,3,4,5};
    
    array<int, 5>::iterator iter = int_arr.begin();

    int sum = 0;
    for( int i = 0; i < int_arr.size(); i++){   	
        sum += iter[i];		// 인덱스를 통한 접근
    }

    cout << "sum: " << sum  << endl;

    string str = "This is a string";

    string::iterator str_iter;
    for( str_iter = str.begin(); str_iter != str.end(); str_iter++){
        cout << *str_iter << " ";
    }
    
    return 0;
}

▼출력

sum: 15
T h i s   i s   a   s t r i n g

 

Iterator를 사용하는 이유

STL ( Standard Type Library )에서 제공하는 알고리즘을 사용하기 위해서 

STL은 광범위한 알고리즘을 지원합니다. 

예를 들면, find, sort, accumlate 함수 등이 있습니다.

그런데, 이 알고리즘들은 대부분 iterator를 사용하여 구현되어 있습니다.

 

STL에서 iterator는 컨테이너와 알고리즘의 연결고리라고 할 수 있습니다.

알고리즘은 iterator를 통해, 컨테이너의 데이터에 접근하여 값을 읽거나 쓸 수 있도록 구성되어 있습니다.

 

 

일관성

iterator는 다양한 데이터 타입을 일관된 방식으로 처리할 수 있도록 도와줍니다.

vector, list, set 등 어떤 컨테이너를 사용하더라도 같은 문법을 사용할 수 있습니다.

 

코드 단순화 

iterator는 컨테이너 내에서 데이터 간의 이동 과정을 숨김으로써, 코드를 단순하게 만들 수 있습니다.

결과적으로, 코드를 읽기 쉽게 만듭니다.