[C++] 18. Standard Library 정복하기(STL)

 

 

 

STL이란?

C++ STL(Standard Template Library)은 C++ 표준 라이브러리의 중요한 구성 요소 중 하나로, 여러 유용한 데이터 구조와 알고리즘을 제공하는 컬렉션입니다. STL은 C++ 표준이므로 C++ 언어에 내장되어 있으며, 많은 C++ 컴파일러와 환경에서 사용할 수 있습니다.

STL의 핵심 아이디어는 '템플릿(Template)'을 사용하여 제네릭(generic)한 방식으로 구현된 데이터 구조와 알고리즘을 제공하는 것입니다. 이렇게 구현된 STL 컨테이너와 알고리즘은 특정 자료형에 종속되지 않고, 다양한 자료형에 대해 재사용될 수 있습니다. 이를 통해 코드의 재사용성과 일반성을 높일 수 있습니다.

STL은 주로 다음과 같은 세 가지 요소로 구성됩니다.

1. 컨테이너 (Containers): 데이터를 저장하고 관리하는 클래스들로, 배열, 리스트, 해시 테이블 등 다양한 형태의 데이터 구조를 제공합니다. 주요 컨테이너로는 vector, list, set, map, unordered_set, unordered_map 등이 있습니다.

2. 반복자 (Iterators): 컨테이너의 원소에 접근하고 순회하는 방법을 추상화하는 클래스 또는 객체입니다. 반복자를 사용하여 컨테이너의 원소에 접근하고 수정할 수 있습니다.

3. 알고리즘 (Algorithms): 컨테이너에서 작업을 수행하는 함수들의 집합입니다. 정렬, 검색, 복사, 변환 등 다양한 작업을 수행하는 함수들이 있으며, 이러한 알고리즘들은 컨테이너와 독립적으로 작동합니다.

STL을 사용하면 데이터 구조와 알고리즘을 구현할 필요 없이 이미 구현되어 있는 컨테이너와 알고리즘을 활용하여 프로그래밍할 수 있습니다. 이는 개발자들이 효율적이고 안정적인 코드를 쉽게 작성할 수 있도록 도와줍니다.

 

 

 

STL 컨테이너

C++ STL(Standard Template Library)은 C++ 표준 라이브러리의 중요한 부분으로, 다양한 유용한 데이터 구조와 알고리즘을 제공하여 개발자들이 효율적으로 프로그램을 작성할 수 있도록 도와줍니다. STL은 크게 다음과 같은 세 가지 주요 컨테이너 종류로 구성됩니다.

1. Sequence Containers(순차 컨테이너):
   - vector: 동적 배열(Dynamic Array)로 크기를 변경할 수 있으며 빠른 임의 접근을 지원합니다.
   - list: 이중 연결 리스트(Doubly Linked List)로 원소의 삽입과 삭제가 빈번한 경우에 유용합니다.
   - deque: 덱(Deque)은 양쪽 끝에서 원소를 삽입/삭제하는 데 효율적인 더블엔디드 큐(Double-ended Queue)입니다.(그냥 queue도 당연히 있습니다.)
   - array: 고정 크기 배열로, 크기가 변경되지 않습니다. C 스타일 배열보다 안전하고 편리합니다.

2. Associative Containers(연관 컨테이너):
   - set: 중복을 허용하지 않는 원소의 정렬된 집합입니다.
   - multiset: 중복을 허용하는 원소의 정렬된 집합입니다.
   - map: 키와 값을 연결하여 키를 기준으로 정렬된 집합입니다.
   - multimap: 키와 값을 연결하는데 중복이 허용되는 정렬된 집합입니다.

3. Unordered Containers(비정렬 연관 컨테이너):
   - unordered_set: 중복을 허용하지 않는 해시(Hash) 기반 집합입니다.
   - unordered_multiset: 중복을 허용하는 해시 기반 집합입니다.
   - unordered_map: 키와 값을 연결하는데 해시 기반으로 동작하는 맵입니다.
   - unordered_multimap: 키와 값을 연결하는데 중복이 허용되는 해시 기반 맵입니다.

STL 컨테이너들은 각각의 특징을 가지고 있습니다. 그러므로 적절한 컨테이너를 선택하는 것이 중요합니다. 몇 가지 중요한 특징은 다음과 같습니다:

1. 메모리 관리: vector는 동적 배열을 사용하므로 메모리 사용이 효율적입니다. list와 deque는 각각 이중 연결 리스트와 덱을 사용하여 삽입/삭제에 용이합니다.

2. 정렬과 검색: 정렬된 데이터를 다룰 때에는 set, map, unordered_set, unordered_map보다 multiset, multimap, unordered_multiset, unordered_multimap이 유용합니다.

3. 성능: 컨테이너들은 서로 다른 성능 특징을 가지고 있습니다. 예를 들어, vector는 임의 접근이 빠르지만 중간 삽입/삭제가 느립니다. list는 중간 삽입/삭제가 빠르지만 임의 접근이 느립니다.

4. 중복 허용 여부: set과 map은 중복을 허용하지 않지만 multiset과 multimap은 중복을 허용합니다. unordered_set과 unordered_map도 동일한 원리로 중복 여부가 결정됩니다.

STL 컨테이너들은 이외에도 다양한 멤버 함수와 반복자(Iterators)를 제공하여 데이터의 조작과 접근을 용이하게 합니다. 각 컨테이너의 특징을 잘 이해하고 필요에 맞게 선택하여 사용하는 것이 중요합니다.

 

 

 

반복자(Iterator)

STL(Standard Template Library)에서 반복자(Iterator)는 컨테이너의 원소에 접근하고 순회하는 추상화된 인터페이스를 제공하는 개체입니다. 반복자를 사용하면 컨테이너의 내용을 순회하거나 수정하는 등의 작업을 일반적인 방법으로 수행할 수 있으며, 알고리즘과 컨테이너를 분리하여 사용할 수 있도록 합니다.

반복자는 포인터와 유사한 인터페이스를 가지고 있으며, 일반적으로 다음과 같은 주요 기능을 제공합니다:

1. 원소에 접근: 반복자는 컨테이너의 원소에 접근하는 역할을 수행합니다. 포인터처럼 역참조 연산자(`*`)를 사용하여 현재 원소의 값을 가져올 수 있습니다.

2. 원소 이동: `++` 연산자를 사용하여 다음 원소로 이동할 수 있습니다. 이렇게 반복자를 이동시키는 것을 "순회(iteration)"라고 합니다.

3. 비교: 반복자들끼리의 상대적인 위치를 비교할 수 있습니다. `==`, `!=`, `<`, `>`, `<=`, `>=` 연산자들을 사용하여 비교합니다.

STL에서는 다양한 종류의 반복자들이 제공되며, 컨테이너의 종류와 작업의 특성에 따라 적절한 반복자를 선택할 수 있습니다. 주요 반복자 종류로는 다음과 같습니다:

1. Input Iterator: 읽기 전용으로 컨테이너의 원소를 순회합니다. 순회하며 원소를 수정할 수 없습니다.

2. Output Iterator: 쓰기 전용으로 컨테이너에 원소를 추가하거나 수정합니다.

3. Forward Iterator: 순방향으로만 이동할 수 있으며 읽기 및 쓰기가 가능합니다.

4. Bidirectional Iterator: 양방향으로 이동할 수 있으며, 순방향과 역방향으로의 이동이 모두 가능합니다.

5. Random Access Iterator: 임의 접근이 가능하며, 인덱스를 이용해 원소에 O(1) 시간에 접근할 수 있습니다. 포인터가 이에 해당합니다.

STL 알고리즘은 반복자를 통해 컨테이너의 원소들을 순회하고 처리하기 때문에, 반복자의 사용은 STL의 강력한 기능 중 하나입니다. 반복자를 이해하고 적절히 활용하면 보다 효율적이고 일반적인 알고리즘을 작성할 수 있습니다.

 

 

 

STL 메서드

1. vector 사용 메서드

#include <vector>
#include <iostream>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 원소 추가
    numbers.push_back(6);

    // 원소 개수 출력
    std::cout << "Size: " << numbers.size() << std::endl;

    // 원소 접근
    std::cout << "First Element: " << numbers[0] << std::endl;

    // 반복자를 사용한 원소 순회
    for (auto it = numbers.begin(); it != numbers.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

 

2. map 사용 메서드

#include <map>
#include <iostream>

int main() {
    std::map<std::string, int> scores;

    // 원소 추가
    scores["Alice"] = 100;
    scores["Bob"] = 85;
    scores["Charlie"] = 90;

    // 원소 개수 출력
    std::cout << "Size: " << scores.size() << std::endl;

    // 원소 접근
    std::cout << "Bob's score: " << scores["Bob"] << std::endl;

    // 반복자를 사용한 원소 순회
    for (auto it = scores.begin(); it != scores.end(); ++it) {
        std::cout << it->first << ": " << it->second << std::endl;
    }

    return 0;
}

 

3. algorithm 라이브러리의 메서드

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 3};

    // 정렬
    std::sort(numbers.begin(), numbers.end());

    // 특정 값 찾기
    int target = 8;
    auto it = std::find(numbers.begin(), numbers.end(), target);
    if (it != numbers.end()) {
        std::cout << target << " found at index: " << std::distance(numbers.begin(), it) << std::endl;
    } else {
        std::cout << target << " not found." << std::endl;
    }

    // 합계 계산
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0);
    std::cout << "Sum: " << sum << std::endl;

    return 0;
}

 

4. 원하는 원소 찾기(find, find_if, count, count_if)

// find
#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    int target = 3;

    auto it = std::find(numbers.begin(), numbers.end(), target);

    if (it != numbers.end()) {
        std::cout << target << " found at index: " << std::distance(numbers.begin(), it) << std::endl;
    } else {
        std::cout << target << " not found." << std::endl;
    }

    return 0;
}

// find_if
#include <algorithm>
#include <vector>
#include <iostream>

bool isEven(int num) {
    return num % 2 == 0;
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    auto it = std::find_if(numbers.begin(), numbers.end(), isEven);

    if (it != numbers.end()) {
        std::cout << "First even number: " << *it << std::endl;
    } else {
        std::cout << "No even number found." << std::endl;
    }

    return 0;
}

// count
#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> numbers = {1, 2, 3, 2, 4, 5, 2};
    int target = 2;

    size_t count = std::count(numbers.begin(), numbers.end(), target);
    std::cout << target << " appears " << count << " times." << std::endl;

    return 0;
}

// count_if
#include <algorithm>
#include <vector>
#include <iostream>

bool isEven(int num) {
    return num % 2 == 0;
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    size_t count = std::count_if(numbers.begin(), numbers.end(), isEven);
    std::cout << "Number of even numbers: " << count << std::endl;

    return 0;
}

 

 

 

std::find_if와 Predicate, 그리고 람다함수

Predicate

Predicate는 조건을 판별하는 함수 객체 또는 함수 포인터를 일반적으로 가리키는 용어입니다. Predicate 함수는 보통 참 또는 거짓을 반환합니다. STL 알고리즘에서는 find_if와 같은 함수들이 Predicate를 사용하여 원소를 검색하거나 정렬하는 등의 작업을 수행합니다.

Predicate 함수는 주어진 조건에 따라 원소를 선택하거나 걸러내는데 사용되며, 람다 함수나 함수 객체로 작성하여 활용할 수 있습니다. 이러한 개념들을 함께 응용하면 STL 알고리즘을 매우 유연하게 사용할 수 있습니다. 

 

람다 함수 (Lambda Function)

람다 함수는 간단한 익명 함수로서, 함수를 선언하지 않고 바로 사용할 수 있는 기능입니다. 주로 함수 객체를 간편하게 생성할 때 사용됩니다. 

[캡처 리스트](매개변수 리스트) -> 반환형 {
    // 함수 내용
}

캡처 리스트: 함수 외부의 변수를 함수 내부에서 사용하기 위해 캡처하는 목록입니다.
매개변수 리스트: 함수의 매개변수를 선언하는 부분입니다.
반환형: 함수의 반환형을 선언하는 부분입니다. 생략 가능하며, 컴파일러가 반환형을 추론합니다.
{} 안에는 람다 함수의 동작을 구현하는 코드가 들어갑니다.

람다 함수는 주로 find_if와 함께 사용하여 짧고 간단한 조건 함수를 생성하는 데 유용합니다.

#include <algorithm>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};


	// 람다 함수를 사용하여 짝수를 찾는 Predicate를 생성
    auto it = std::find_if(numbers.begin(), numbers.end(), [](int num) 
    	{ return num % 2 == 0; });
    

    if (it != numbers.end()) {
        std::cout << "First even number: " << *it << std::endl;
    } else {
        std::cout << "No even number found." << std::endl;
    }

    return 0;
}

위 예시에서 익명 람다 함수를 사용하여 Predicate를 생성하고, find_if에 이 Predicate를 전달하여 컨테이너에서 첫 번째 짝수를 찾았습니다. 이렇게 Predicate와 람다 함수를 조합하면 필요에 따라 다양한 조건으로 컨테이너의 원소를 처리할 수 있습니다.