MENU
  1. ホーム
  2. C++
  3. C++ STL 알고리즘으로 코드 품질과 유지보수성 향상하는 법

C++ STL 알고리즘으로 코드 품질과 유지보수성 향상하는 법

C++

C++ STL(Standard Template Library) 알고리즘을 적극적으로 활용하면 코드의 가독성과 유지보수성을 향상시킬 수 있습니다. 반복문을 직접 작성하는 대신 STL 알고리즘을 사용하면 코드가 간결해지고, 성능 최적화가 용이해지며, 버그 발생 가능성을 줄일 수 있습니다.

본 기사에서는 STL 알고리즘의 기본 개념부터 주요 함수 소개, 성능 최적화 기법, 람다 함수 및 병렬 STL 알고리즘까지 다양한 활용 방법을 다룹니다. 또한, 실제 프로젝트에서 STL 알고리즘을 활용하는 예제도 포함하여 실용적인 적용 방안을 제공합니다.

STL 알고리즘을 제대로 활용하면 C++ 코드의 효율성이 크게 향상됩니다. 지금부터 그 원리와 효과적인 사용법을 알아보겠습니다.

목차
  1. STL 알고리즘이란?
    1. STL 알고리즘의 주요 특징
    2. STL 알고리즘의 기본 분류
  2. 반복문보다 STL 알고리즘을 사용하는 이유
    1. 1. 코드 가독성과 유지보수성 향상
    2. 2. 성능 최적화 및 오류 방지
    3. 3. 병렬 연산 지원
    4. 결론
  3. 주요 STL 알고리즘 정리
    1. 1. 요소를 순회하는 알고리즘: `std::for_each`
    2. 2. 변환 알고리즘: `std::transform`
    3. 3. 정렬 알고리즘: `std::sort`
    4. 4. 축적 알고리즘: `std::accumulate`
    5. 5. 검색 알고리즘: `std::find`
    6. 6. 요소 제거 알고리즘: `std::remove`
    7. 7. 중복 제거 알고리즘: `std::unique`
    8. 결론
  4. 성능 최적화를 위한 STL 알고리즘 활용법
    1. 1. `std::sort` 대신 `std::stable_sort` 활용
    2. 2. `std::unordered_map`을 이용한 빠른 검색
    3. 3. `std::remove_if`를 이용한 조건부 제거
    4. 4. `std::accumulate` 대신 `std::reduce` 활용
    5. 5. `std::partition`을 이용한 효율적인 필터링
    6. 결론
  5. 람다 함수와 STL 알고리즘의 조합
    1. 1. `std::for_each`와 람다 함수
    2. 2. `std::transform`과 람다 함수
    3. 3. `std::sort`와 람다 함수
    4. 4. `std::remove_if`와 람다 함수
    5. 5. `std::count_if`와 람다 함수
    6. 6. `std::find_if`와 람다 함수
    7. 결론
  6. 사용자 정의 비교 함수와 커스텀 연산
    1. 1. `std::sort`에서 사용자 정의 비교 함수 사용
    2. 2. 람다 함수를 활용한 비교 함수
    3. 3. `std::unique`에서 사용자 정의 비교 함수 사용
    4. 4. `std::set`과 사용자 정의 비교 함수
    5. 5. `std::find_if`에서 사용자 정의 비교 함수 사용
    6. 결론
  7. 병렬 STL 알고리즘 활용
    1. 1. 병렬 STL 알고리즘의 개념
    2. 2. 병렬 정렬: `std::sort` vs `std::sort` with `std::execution::par`
    3. 3. 병렬 누적 연산: `std::reduce` vs `std::accumulate`
    4. 4. 병렬 `std::for_each`로 데이터 처리 속도 향상
    5. 5. `std::transform`과 병렬 실행
    6. 결론
  8. STL 알고리즘을 활용한 예제 프로젝트
    1. 1. 단어 빈도수 계산기 (`std::map` + `std::for_each`)
    2. 2. 로그 파일에서 특정 패턴 검색 (`std::find_if` 활용)
    3. 3. 학생 성적 관리 시스템 (`std::vector` + `std::sort`)
    4. 4. 웹 서버 로그 분석 (`std::unordered_map` + `std::transform`)
    5. 5. 파일 크기 비교 도구 (`std::filesystem` + `std::sort`)
    6. 결론
  9. 요약

STL 알고리즘이란?


STL(Standard Template Library) 알고리즘은 C++ 표준 라이브러리에서 제공하는 다양한 함수들의 집합으로, 컨테이너 내부의 요소를 효율적으로 조작할 수 있도록 설계되었습니다.

STL 알고리즘은 기본적으로 반복문을 직접 작성하는 대신 미리 최적화된 함수를 제공하여 코드의 가독성을 높이고, 성능을 향상시키는 역할을 합니다. 예를 들어, 배열이나 벡터의 정렬, 검색, 변환, 축적 등의 작업을 손쉽게 처리할 수 있습니다.

STL 알고리즘의 주요 특징

  • 반복자(iterator)를 활용: 컨테이너 유형과 관계없이 사용 가능
  • 범용적이며 재사용 가능: 다양한 데이터 구조에 적용 가능
  • 고성능 구현: 표준 라이브러리에서 최적화된 코드 제공
  • 템플릿 기반: 다양한 데이터 타입에 대해 일관된 방식으로 동작

STL 알고리즘의 기본 분류


STL 알고리즘은 크게 다음과 같이 분류됩니다.

분류설명예제
변환(transform)데이터를 변환하는 연산std::transform
정렬(sorting)데이터를 정렬하는 연산std::sort, std::stable_sort
검색(search)특정 요소를 찾는 연산std::find, std::binary_search
축적(accumulate)요소들을 합산하는 연산std::accumulate, std::reduce
제거(removal)특정 조건을 만족하는 요소 제거std::remove, std::unique
비교(comparison)요소 간 비교 연산 수행std::equal, std::lexicographical_compare

이처럼 STL 알고리즘은 수많은 기능을 제공하며, 이를 적절히 활용하면 코드의 품질을 크게 향상시킬 수 있습니다. 다음으로 반복문보다 STL 알고리즘을 사용하는 이유를 알아보겠습니다.

반복문보다 STL 알고리즘을 사용하는 이유

C++에서 데이터를 조작할 때 for 또는 while 반복문을 직접 작성하는 방식은 익숙하지만, 이는 코드의 가독성과 유지보수성을 저하시킬 수 있습니다. 반면, STL 알고리즘을 활용하면 보다 간결하고 효율적인 코드 작성을 할 수 있습니다.

1. 코드 가독성과 유지보수성 향상


반복문을 직접 작성하면 코드의 양이 많아지고 가독성이 떨어질 수 있습니다. 반면 STL 알고리즘을 사용하면 의도를 명확하게 표현할 수 있어 유지보수에 용이합니다.

예제 1: std::for_each를 활용한 코드 개선

아래는 벡터의 모든 요소를 출력하는 코드입니다.

반복문 사용

#include <iostream>
#include <vector>

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

    for (size_t i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " ";
    }

    return 0;
}

STL 알고리즘 사용 (std::for_each)

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

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

    std::for_each(vec.begin(), vec.end(), [](int n) { std::cout << n << " "; });

    return 0;
}

STL 알고리즘을 사용하면 반복문 없이 직관적인 코드 작성이 가능하며, 람다 함수와 결합하여 더욱 깔끔한 표현이 가능합니다.

2. 성능 최적화 및 오류 방지


STL 알고리즘은 내부적으로 최적화되어 있으며, 잘못된 반복문 조건을 설정하는 실수를 방지할 수 있습니다.

예를 들어, std::sort는 내부적으로 고성능 정렬 알고리즘을 사용하며, 직접 for 문을 이용하여 정렬을 구현하는 것보다 빠르고 안전합니다.

예제 2: std::sort를 이용한 정렬

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

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

    std::sort(vec.begin(), vec.end());

    for (int num : vec) {
        std::cout << num << " ";
    }
    return 0;
}

위와 같이 std::sort를 활용하면 정렬을 매우 간결하게 수행할 수 있습니다.

3. 병렬 연산 지원


C++17부터는 병렬 STL 알고리즘이 추가되어 std::execution을 활용하면 멀티스레드 환경에서 성능을 더욱 높일 수 있습니다.

예제 3: 병렬 정렬 (std::sort vs std::sort with 병렬 실행)

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

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

    // 병렬 정렬
    std::sort(std::execution::par, vec.begin(), vec.end());

    for (int num : vec) {
        std::cout << num << " ";
    }
    return 0;
}

위 코드에서 std::execution::par를 사용하면 멀티코어 환경에서 정렬 속도를 최적화할 수 있습니다.

결론


STL 알고리즘을 활용하면 코드의 가독성을 높이고, 성능을 최적화하며, 버그 발생 가능성을 줄일 수 있습니다. 반복문보다 STL 알고리즘을 적극 활용하면 유지보수성이 높은 코드를 작성할 수 있습니다.

다음으로 주요 STL 알고리즘과 그 활용법을 살펴보겠습니다.

주요 STL 알고리즘 정리

C++ STL 알고리즘은 데이터를 효율적으로 처리하기 위한 다양한 함수를 제공합니다. 여기서는 가장 자주 사용되는 핵심 STL 알고리즘을 정리하고, 각각의 예제 코드를 소개합니다.

1. 요소를 순회하는 알고리즘: `std::for_each`


std::for_each는 컨테이너의 모든 요소를 순회하며 특정 작업을 수행하는 함수입니다.

예제: 벡터의 모든 요소 출력

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

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

    std::for_each(vec.begin(), vec.end(), [](int n) { std::cout << n << " "; });

    return 0;
}

출력:

1 2 3 4 5

이처럼 std::for_each는 반복문을 대체하여 코드의 가독성을 높입니다.

2. 변환 알고리즘: `std::transform`


std::transform은 컨테이너의 각 요소를 변환하여 새로운 값을 할당하는 데 사용됩니다.

예제: 벡터의 모든 요소를 제곱하기

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::vector<int> result(vec.size());

    std::transform(vec.begin(), vec.end(), result.begin(), [](int n) { return n * n; });

    for (int n : result) {
        std::cout << n << " ";
    }
    return 0;
}

출력:

1 4 9 16 25

이렇게 std::transform을 사용하면 새로운 컨테이너에 변환된 값을 저장할 수 있습니다.

3. 정렬 알고리즘: `std::sort`


std::sort는 컨테이너의 요소를 오름차순(또는 사용자 정의 조건에 따라) 정렬하는 함수입니다.

예제: 벡터 정렬

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

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

    std::sort(vec.begin(), vec.end());

    for (int num : vec) {
        std::cout << num << " ";
    }
    return 0;
}

출력:

1 2 4 5 8

내림차순으로 정렬하려면 std::greater<int>()을 사용합니다.

std::sort(vec.begin(), vec.end(), std::greater<int>());

4. 축적 알고리즘: `std::accumulate`


std::accumulate는 컨테이너의 요소를 누적하여 합산하는 데 사용됩니다.

예제: 벡터의 합 구하기

#include <iostream>
#include <vector>
#include <numeric>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    int sum = std::accumulate(vec.begin(), vec.end(), 0);

    std::cout << "합: " << sum << std::endl;
    return 0;
}

출력:

합: 15

이처럼 std::accumulate를 활용하면 간단한 코드로 합계를 구할 수 있습니다.

5. 검색 알고리즘: `std::find`


std::find는 컨테이너에서 특정 요소를 찾는 데 사용됩니다.

예제: 특정 값 찾기

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

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};

    auto it = std::find(vec.begin(), vec.end(), 30);
    if (it != vec.end()) {
        std::cout << "값을 찾음: " << *it << std::endl;
    } else {
        std::cout << "값이 없음" << std::endl;
    }

    return 0;
}

출력:

값을 찾음: 30

6. 요소 제거 알고리즘: `std::remove`


std::remove는 특정 값을 제거하는 알고리즘으로, 컨테이너의 요소를 실제로 삭제하는 것이 아니라 “유효한 범위”를 조정합니다.

예제: 특정 값 제거

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

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

    vec.erase(std::remove(vec.begin(), vec.end(), 3), vec.end());

    for (int n : vec) {
        std::cout << n << " ";
    }
    return 0;
}

출력:

1 2 4 5

std::remove는 요소를 제거한 후, erase를 사용해야 완전히 삭제됩니다.

7. 중복 제거 알고리즘: `std::unique`


std::unique는 연속된 중복 요소를 제거하는 알고리즘입니다.

예제: 중복 제거

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

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

    vec.erase(std::unique(vec.begin(), vec.end()), vec.end());

    for (int n : vec) {
        std::cout << n << " ";
    }
    return 0;
}

출력:

1 2 3 4 5

주의할 점은 std::unique를 사용하기 전에 정렬(std::sort)을 해야 정확하게 중복을 제거할 수 있습니다.

결론


이처럼 STL 알고리즘을 사용하면 코드의 가독성과 유지보수성이 향상되며, 수작업으로 반복문을 작성할 필요 없이 효율적인 방식으로 데이터를 조작할 수 있습니다.

다음으로 성능 최적화를 위한 STL 알고리즘 활용법을 살펴보겠습니다.

성능 최적화를 위한 STL 알고리즘 활용법

C++ STL 알고리즘은 성능을 고려하여 설계되었으며, 적절한 사용법을 익히면 실행 속도를 최적화할 수 있습니다. 이 섹션에서는 효율적인 STL 알고리즘 활용법과 성능 개선 기법을 소개합니다.

1. `std::sort` 대신 `std::stable_sort` 활용


정렬 시 std::sort는 빠르지만, 같은 값에 대한 상대적 순서를 보장하지 않습니다. 반면, std::stable_sort는 상대적 순서를 유지하면서 정렬을 수행합니다.

예제: std::sort vs std::stable_sort

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

struct Data {
    int key;
    char value;
};

int main() {
    std::vector<Data> vec = {{2, 'B'}, {1, 'A'}, {2, 'C'}, {1, 'D'}};

    std::sort(vec.begin(), vec.end(), [](const Data& a, const Data& b) { return a.key < b.key; });
    std::cout << "std::sort 결과:\n";
    for (const auto& d : vec) std::cout << d.key << " " << d.value << "\n";

    vec = {{2, 'B'}, {1, 'A'}, {2, 'C'}, {1, 'D'}};
    std::stable_sort(vec.begin(), vec.end(), [](const Data& a, const Data& b) { return a.key < b.key; });
    std::cout << "\nstd::stable_sort 결과:\n";
    for (const auto& d : vec) std::cout << d.key << " " << d.value << "\n";

    return 0;
}

출력 결과:

std::sort 결과:
1 D
1 A
2 C
2 B

std::stable_sort 결과:
1 A
1 D
2 B
2 C

std::stable_sort는 정렬 후에도 동일한 키를 가진 요소들의 원래 순서를 유지합니다.

2. `std::unordered_map`을 이용한 빠른 검색


STL의 std::map은 이진 검색 트리를 기반으로 하여 O(log N)의 탐색 성능을 가지지만, std::unordered_map을 사용하면 해시 테이블을 기반으로 O(1)에 가까운 검색 성능을 얻을 수 있습니다.

예제: std::unordered_map을 이용한 빠른 키 검색

#include <iostream>
#include <unordered_map>

int main() {
    std::unordered_map<int, std::string> data = {{1, "Apple"}, {2, "Banana"}, {3, "Cherry"}};

    int key = 2;
    if (data.find(key) != data.end()) {
        std::cout << "찾은 값: " << data[key] << std::endl;
    } else {
        std::cout << "값을 찾을 수 없음" << std::endl;
    }

    return 0;
}

std::unordered_map을 사용하면 std::map보다 빠른 검색이 가능하여 대량의 데이터를 처리할 때 성능 이점을 얻을 수 있습니다.

3. `std::remove_if`를 이용한 조건부 제거


std::remove_if를 활용하면 특정 조건을 만족하는 요소를 효율적으로 제거할 수 있습니다.

예제: 짝수 요소 제거

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 6, 7, 8};

    vec.erase(std::remove_if(vec.begin(), vec.end(), [](int n) { return n % 2 == 0; }), vec.end());

    for (int n : vec) {
        std::cout << n << " ";
    }
    return 0;
}

출력:

1 3 5 7

이처럼 std::remove_if를 사용하면 반복문 없이도 간결하게 조건부 삭제가 가능합니다.

4. `std::accumulate` 대신 `std::reduce` 활용


std::accumulate는 연산을 순차적으로 수행하는 반면, std::reduce는 C++17부터 병렬 처리를 지원하여 속도를 더욱 높일 수 있습니다.

예제: std::reduce를 이용한 병렬 연산 (C++17 이상)

#include <iostream>
#include <vector>
#include <numeric>
#include <execution>

int main() {
    std::vector<int> vec(1000000, 1);

    int sum = std::reduce(std::execution::par, vec.begin(), vec.end());

    std::cout << "합계: " << sum << std::endl;
    return 0;
}

병렬 실행 정책을 적용하면 멀티코어 환경에서 연산 속도가 크게 향상됩니다.

5. `std::partition`을 이용한 효율적인 필터링


std::partition을 사용하면 특정 조건을 만족하는 요소들을 컨테이너의 앞부분에 모을 수 있어, 성능 최적화에 유리합니다.

예제: 짝수를 앞쪽으로 배치

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 6, 7, 8};

    auto it = std::partition(vec.begin(), vec.end(), [](int n) { return n % 2 == 0; });

    std::cout << "짝수 그룹: ";
    for (auto i = vec.begin(); i != it; ++i) std::cout << *i << " ";
    std::cout << "\n홀수 그룹: ";
    for (auto i = it; i != vec.end(); ++i) std::cout << *i << " ";

    return 0;
}

출력:

짝수 그룹: 2 4 6 8 
홀수 그룹: 1 3 5 7

이처럼 std::partition을 활용하면 데이터 재배치를 효율적으로 수행할 수 있습니다.

결론


STL 알고리즘을 적절히 활용하면 코드의 성능을 최적화할 수 있습니다.

  • std::stable_sort를 사용하면 정렬 후에도 원래 순서를 유지할 수 있습니다.
  • std::unordered_map을 사용하면 해시 기반의 빠른 검색이 가능합니다.
  • std::remove_if와 std::partition을 활용하면 불필요한 요소 제거 및 데이터 필터링을 효율적으로 수행할 수 있습니다.
  • std::reduce를 활용하면 병렬 연산을 통해 성능을 극대화할 수 있습니다.

다음으로 람다 함수와 STL 알고리즘을 조합하여 더욱 직관적인 코드를 작성하는 방법을 알아보겠습니다.

람다 함수와 STL 알고리즘의 조합

람다 함수(lambda function)는 간단한 익명 함수를 생성하는 기능으로, STL 알고리즘과 함께 사용하면 코드의 가독성을 높이고, 불필요한 함수 정의 없이 즉시 동작을 지정할 수 있습니다. 본 섹션에서는 STL 알고리즘과 람다 함수를 조합하는 다양한 예제를 소개합니다.

1. `std::for_each`와 람다 함수


std::for_each를 사용할 때 람다 함수를 활용하면 반복문을 대체하면서도 간결한 코드 작성이 가능합니다.

예제: 벡터 요소 출력

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

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

    std::for_each(vec.begin(), vec.end(), [](int n) { std::cout << n << " "; });

    return 0;
}

출력:

1 2 3 4 5

람다 함수를 사용하면 std::for_each 내에서 즉시 동작을 정의할 수 있어 코드가 더욱 직관적이 됩니다.

2. `std::transform`과 람다 함수


std::transform을 활용하면 기존 컨테이너의 데이터를 변환하여 새로운 값을 저장할 수 있습니다.

예제: 벡터의 모든 요소를 제곱하기

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::vector<int> result(vec.size());

    std::transform(vec.begin(), vec.end(), result.begin(), [](int n) { return n * n; });

    for (int n : result) {
        std::cout << n << " ";
    }
    return 0;
}

출력:

1 4 9 16 25

람다 함수를 사용하면 별도의 함수 정의 없이 직관적인 변환 로직을 작성할 수 있습니다.

3. `std::sort`와 람다 함수


std::sort를 활용할 때 사용자 정의 정렬 기준을 람다 함수로 쉽게 지정할 수 있습니다.

예제: 내림차순 정렬

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

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

    std::sort(vec.begin(), vec.end(), [](int a, int b) { return a > b; });

    for (int num : vec) {
        std::cout << num << " ";
    }
    return 0;
}

출력:

8 5 4 2 1

람다 함수를 사용하면 간단하게 정렬 기준을 지정할 수 있습니다.

4. `std::remove_if`와 람다 함수


std::remove_if는 특정 조건을 만족하는 요소를 제거할 때 사용됩니다.

예제: 짝수 제거

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 6, 7, 8};

    vec.erase(std::remove_if(vec.begin(), vec.end(), [](int n) { return n % 2 == 0; }), vec.end());

    for (int n : vec) {
        std::cout << n << " ";
    }
    return 0;
}

출력:

1 3 5 7

람다 함수를 사용하여 특정 조건(짝수 여부)을 쉽게 정의할 수 있습니다.

5. `std::count_if`와 람다 함수


std::count_if는 특정 조건을 만족하는 요소의 개수를 계산할 때 유용합니다.

예제: 홀수 개수 세기

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

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5, 6, 7, 8};

    int count = std::count_if(vec.begin(), vec.end(), [](int n) { return n % 2 != 0; });

    std::cout << "홀수 개수: " << count << std::endl;

    return 0;
}

출력:

홀수 개수: 4

람다 함수를 사용하여 조건을 직접 지정할 수 있어 코드가 더욱 직관적이 됩니다.

6. `std::find_if`와 람다 함수


std::find_if는 특정 조건을 만족하는 첫 번째 요소를 찾을 때 사용됩니다.

예제: 10보다 큰 첫 번째 요소 찾기

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

int main() {
    std::vector<int> vec = {3, 5, 9, 12, 15, 20};

    auto it = std::find_if(vec.begin(), vec.end(), [](int n) { return n > 10; });

    if (it != vec.end()) {
        std::cout << "10보다 큰 첫 번째 값: " << *it << std::endl;
    } else {
        std::cout << "10보다 큰 값이 없음" << std::endl;
    }

    return 0;
}

출력:

10보다 큰 첫 번째 값: 12

람다 함수를 사용하면 원하는 조건을 간결하게 표현할 수 있습니다.

결론


람다 함수는 STL 알고리즘과 결합할 때 강력한 성능을 발휘합니다.

  • std::for_each, std::transform과 함께 사용하면 코드 가독성이 향상됩니다.
  • std::sort와 조합하면 정렬 기준을 쉽게 지정할 수 있습니다.
  • std::remove_if, std::count_if, std::find_if와 함께 사용하면 불필요한 조건문 없이 직관적인 코드 작성이 가능합니다.

람다 함수를 활용하면 불필요한 보일러플레이트 코드 없이 STL 알고리즘을 보다 효과적으로 사용할 수 있습니다.

다음으로 사용자 정의 비교 함수와 커스텀 연산을 활용하여 STL 알고리즘을 더욱 세밀하게 조정하는 방법을 살펴보겠습니다.

사용자 정의 비교 함수와 커스텀 연산

C++ STL 알고리즘은 기본적으로 표준 연산(예: <, > 등)을 사용하지만, 경우에 따라 사용자가 직접 비교 함수나 커스텀 연산을 정의해야 할 때가 있습니다. 이 섹션에서는 사용자 정의 비교 함수와 커스텀 연산을 활용하는 방법을 설명합니다.

1. `std::sort`에서 사용자 정의 비교 함수 사용


STL의 std::sort는 기본적으로 < 연산자를 사용하여 오름차순으로 정렬합니다. 하지만, 사용자 정의 비교 함수를 사용하면 보다 복잡한 정렬 기준을 적용할 수 있습니다.

예제: 구조체를 특정 기준으로 정렬하기

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

struct Student {
    std::string name;
    int score;
};

// 사용자 정의 비교 함수
bool compareByScore(const Student& a, const Student& b) {
    return a.score > b.score;  // 높은 점수가 먼저 오도록 정렬
}

int main() {
    std::vector<Student> students = {{"Alice", 85}, {"Bob", 92}, {"Charlie", 78}};

    std::sort(students.begin(), students.end(), compareByScore);

    for (const auto& s : students) {
        std::cout << s.name << ": " << s.score << "\n";
    }
    return 0;
}

출력:

Bob: 92
Alice: 85
Charlie: 78

사용자 정의 비교 함수를 활용하면 복잡한 정렬 기준을 쉽게 적용할 수 있습니다.

2. 람다 함수를 활용한 비교 함수


C++11 이상에서는 람다 함수를 사용하여 더 간결하게 비교 함수를 정의할 수 있습니다.

예제: std::sort에서 람다 함수 사용

std::sort(students.begin(), students.end(), [](const Student& a, const Student& b) {
    return a.score > b.score;
});

람다 함수를 사용하면 불필요한 비교 함수 정의를 줄일 수 있습니다.

3. `std::unique`에서 사용자 정의 비교 함수 사용


std::unique는 연속된 중복 요소를 제거하는데, 기본적으로 == 연산자를 사용합니다. 하지만 사용자 정의 비교 함수를 제공하면 보다 복잡한 기준으로 중복을 제거할 수 있습니다.

예제: 문자열 길이가 같은 경우 중복 제거

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

bool sameLength(const std::string& a, const std::string& b) {
    return a.length() == b.length();
}

int main() {
    std::vector<std::string> words = {"apple", "banana", "pear", "grape", "peach"};

    std::sort(words.begin(), words.end());  // 정렬 후 적용
    words.erase(std::unique(words.begin(), words.end(), sameLength), words.end());

    for (const auto& word : words) {
        std::cout << word << " ";
    }
    return 0;
}

출력:

apple banana grape

이처럼 사용자 정의 비교 함수를 사용하면 중복 제거 기준을 커스터마이징할 수 있습니다.

4. `std::set`과 사용자 정의 비교 함수


기본적으로 std::set은 오름차순으로 정렬된 상태를 유지합니다. 하지만 사용자 정의 비교 함수를 제공하면 특정 기준에 따라 정렬된 데이터를 저장할 수 있습니다.

예제: std::set을 내림차순으로 정렬하기

#include <iostream>
#include <set>

struct Descending {
    bool operator()(int a, int b) const {
        return a > b;  // 내림차순 정렬
    }
};

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

    for (int num : numbers) {
        std::cout << num << " ";
    }
    return 0;
}

출력:

8 5 3 2 1

기본 정렬(오름차순)과 다르게, 내림차순 정렬이 적용됩니다.

5. `std::find_if`에서 사용자 정의 비교 함수 사용


std::find_if를 활용하면 특정 조건을 만족하는 첫 번째 요소를 찾을 수 있습니다.

예제: 특정 조건을 만족하는 값 찾기

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

int main() {
    std::vector<int> vec = {3, 10, 7, 12, 15, 20};

    auto it = std::find_if(vec.begin(), vec.end(), [](int n) { return n % 5 == 0; });

    if (it != vec.end()) {
        std::cout << "5의 배수 중 첫 번째 값: " << *it << std::endl;
    } else {
        std::cout << "5의 배수가 없음" << std::endl;
    }

    return 0;
}

출력:

5의 배수 중 첫 번째 값: 10

사용자 정의 비교 함수를 사용하면 원하는 조건을 쉽게 적용할 수 있습니다.

결론


STL 알고리즘에서 사용자 정의 비교 함수와 커스텀 연산을 사용하면 더욱 세밀한 데이터 처리가 가능합니다.

  • std::sort에서 사용자 정의 비교 함수로 정렬 기준을 변경할 수 있습니다.
  • std::unique에서 특정 기준으로 중복을 제거할 수 있습니다.
  • std::set에서 사용자 정의 정렬을 적용할 수 있습니다.
  • std::find_if를 활용하여 특정 조건을 만족하는 요소를 찾을 수 있습니다.

다음으로 C++17에서 추가된 병렬 STL 알고리즘을 활용하여 성능을 극대화하는 방법을 살펴보겠습니다.

병렬 STL 알고리즘 활용

C++17부터 병렬 STL 알고리즘이 도입되면서, std::execution을 활용하여 멀티코어 환경에서 알고리즘을 더욱 효율적으로 실행할 수 있습니다. 이를 통해 대량의 데이터를 처리할 때 성능을 극대화할 수 있습니다.

본 섹션에서는 병렬 STL 알고리즘의 개념과 활용법을 살펴보고, std::sort, std::reduce, std::for_each 등을 병렬로 실행하는 방법을 소개합니다.

1. 병렬 STL 알고리즘의 개념


기존 STL 알고리즘은 단일 스레드에서 순차적으로 실행되었지만, C++17 이후에는 std::execution 네임스페이스를 이용해 실행 정책을 지정할 수 있습니다.

실행 정책설명
std::execution::seq기본값. 단일 스레드에서 순차적으로 실행
std::execution::par여러 개의 스레드를 활용하여 병렬로 실행
std::execution::par_unseq병렬 + 벡터화 실행 (하드웨어가 지원하는 경우)

2. 병렬 정렬: `std::sort` vs `std::sort` with `std::execution::par`


C++17에서는 std::sort에 병렬 실행 정책을 적용하여 성능을 향상시킬 수 있습니다.

예제: 대량 데이터 정렬 (순차 vs 병렬)

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
#include <chrono>

int main() {
    std::vector<int> data(1'000'000);
    std::generate(data.begin(), data.end(), rand);

    auto start = std::chrono::high_resolution_clock::now();
    std::sort(std::execution::seq, data.begin(), data.end());  // 순차 정렬
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "순차 정렬 시간: "
              << std::chrono::duration<double>(end - start).count() << "초\n";

    std::generate(data.begin(), data.end(), rand);

    start = std::chrono::high_resolution_clock::now();
    std::sort(std::execution::par, data.begin(), data.end());  // 병렬 정렬
    end = std::chrono::high_resolution_clock::now();
    std::cout << "병렬 정렬 시간: "
              << std::chrono::duration<double>(end - start).count() << "초\n";

    return 0;
}

출력 예시:

순차 정렬 시간: 0.8초
병렬 정렬 시간: 0.3초

병렬 정렬을 사용하면 데이터가 많을수록 실행 시간이 크게 단축됩니다.

3. 병렬 누적 연산: `std::reduce` vs `std::accumulate`


기존 std::accumulate는 순차적으로 연산을 수행하지만, std::reduce를 사용하면 병렬 처리가 가능합니다.

예제: 병렬 누적 연산 (std::reduce)

#include <iostream>
#include <vector>
#include <numeric>
#include <execution>
#include <chrono>

int main() {
    std::vector<int> data(1'000'000, 1);

    auto start = std::chrono::high_resolution_clock::now();
    int sum = std::accumulate(data.begin(), data.end(), 0);  // 순차적 합산
    auto end = std::chrono::high_resolution_clock::now();
    std::cout << "순차 합산: " << sum << ", 시간: "
              << std::chrono::duration<double>(end - start).count() << "초\n";

    start = std::chrono::high_resolution_clock::now();
    sum = std::reduce(std::execution::par, data.begin(), data.end());  // 병렬 합산
    end = std::chrono::high_resolution_clock::now();
    std::cout << "병렬 합산: " << sum << ", 시간: "
              << std::chrono::duration<double>(end - start).count() << "초\n";

    return 0;
}

출력 예시:

순차 합산: 1000000, 시간: 0.4초
병렬 합산: 1000000, 시간: 0.1초

std::reduce를 사용하면 멀티코어 환경에서 성능이 크게 향상됩니다.

4. 병렬 `std::for_each`로 데이터 처리 속도 향상


std::for_each를 병렬로 실행하면 대량의 데이터를 빠르게 처리할 수 있습니다.

예제: 병렬 데이터 연산

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
#include <chrono>

int main() {
    std::vector<int> data(1'000'000, 1);

    auto start = std::chrono::high_resolution_clock::now();
    std::for_each(std::execution::par, data.begin(), data.end(), [](int &n) { n *= 2; });
    auto end = std::chrono::high_resolution_clock::now();

    std::cout << "병렬 for_each 수행 시간: "
              << std::chrono::duration<double>(end - start).count() << "초\n";

    return 0;
}

출력 예시:

병렬 for_each 수행 시간: 0.1초

병렬 실행을 적용하면 수백만 개의 요소를 빠르게 처리할 수 있습니다.

5. `std::transform`과 병렬 실행


std::transform은 입력 데이터를 변환하여 새로운 컨테이너에 저장하는 데 사용됩니다. 이를 병렬로 실행하면 속도를 더욱 높일 수 있습니다.

예제: 벡터 요소 제곱 연산 (병렬 실행)

#include <iostream>
#include <vector>
#include <algorithm>
#include <execution>
#include <chrono>

int main() {
    std::vector<int> data(1'000'000, 2);
    std::vector<int> result(data.size());

    auto start = std::chrono::high_resolution_clock::now();
    std::transform(std::execution::par, data.begin(), data.end(), result.begin(),
                   [](int n) { return n * n; });
    auto end = std::chrono::high_resolution_clock::now();

    std::cout << "병렬 transform 수행 시간: "
              << std::chrono::duration<double>(end - start).count() << "초\n";

    return 0;
}

출력 예시:

병렬 transform 수행 시간: 0.15초

병렬 std::transform을 활용하면 대량의 데이터를 빠르게 변환할 수 있습니다.

결론


C++17에서 도입된 병렬 STL 알고리즘을 활용하면 멀티코어 환경에서 연산 속도를 극대화할 수 있습니다.

  • std::sort(std::execution::par, ...)을 사용하면 대량 데이터를 빠르게 정렬할 수 있습니다.
  • std::reduce(std::execution::par, ...)를 사용하면 순차 연산보다 빠르게 누적 연산을 수행할 수 있습니다.
  • std::for_each와 std::transform을 병렬 실행하면 벡터화된 대량 데이터를 빠르게 처리할 수 있습니다.

병렬 STL 알고리즘을 적극 활용하면 코드의 실행 속도를 극대화하면서도 간결한 코드를 유지할 수 있습니다.

다음으로 STL 알고리즘을 활용한 실제 프로젝트 예제를 살펴보겠습니다.

STL 알고리즘을 활용한 예제 프로젝트

STL 알고리즘은 코드의 가독성을 높이고 성능을 최적화하는 데 유용합니다. 본 섹션에서는 실제 프로젝트에서 STL 알고리즘을 활용하여 효율적인 코드 작성을 구현하는 방법을 소개합니다.

1. 단어 빈도수 계산기 (`std::map` + `std::for_each`)


텍스트 파일에서 단어의 빈도수를 계산하는 프로그램을 STL 알고리즘을 활용하여 간결하게 구현할 수 있습니다.

예제: 단어 빈도수 계산

#include <iostream>
#include <fstream>
#include <sstream>
#include <map>
#include <algorithm>
#include <vector>

int main() {
    std::ifstream file("sample.txt");
    std::map<std::string, int> wordCount;
    std::string word;

    while (file >> word) {
        ++wordCount[word];
    }

    std::vector<std::pair<std::string, int>> sortedWords(wordCount.begin(), wordCount.end());

    std::sort(sortedWords.begin(), sortedWords.end(), 
              [](const auto& a, const auto& b) { return a.second > b.second; });

    std::for_each(sortedWords.begin(), sortedWords.end(), 
                  [](const auto& pair) { std::cout << pair.first << ": " << pair.second << "\n"; });

    return 0;
}

출력 예시 (텍스트 파일 sample.txt에서 분석된 결과):

the: 15
is: 10
a: 8
  • std::map을 사용하여 단어 빈도를 저장
  • std::sort를 사용하여 단어 빈도순으로 정렬
  • std::for_each를 사용하여 결과 출력

2. 로그 파일에서 특정 패턴 검색 (`std::find_if` 활용)


로그 파일에서 특정 키워드가 포함된 줄을 찾는 프로그램을 STL 알고리즘으로 구현할 수 있습니다.

예제: 특정 키워드 포함된 로그 검색

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

int main() {
    std::ifstream file("log.txt");
    std::vector<std::string> logs;
    std::string line;

    while (std::getline(file, line)) {
        logs.push_back(line);
    }

    std::string keyword = "ERROR";
    auto it = std::find_if(logs.begin(), logs.end(), 
                           [&keyword](const std::string& log) { return log.find(keyword) != std::string::npos; });

    if (it != logs.end()) {
        std::cout << "첫 번째 오류 로그: " << *it << std::endl;
    } else {
        std::cout << "오류 로그 없음" << std::endl;
    }

    return 0;
}

출력 예시:

첫 번째 오류 로그: [2025-01-30 12:45:12] ERROR: 파일 접근 실패
  • std::find_if를 사용하여 ERROR가 포함된 첫 번째 로그 찾기

3. 학생 성적 관리 시스템 (`std::vector` + `std::sort`)


학생들의 성적을 저장하고, 점수 순으로 정렬하여 출력하는 프로그램을 구현할 수 있습니다.

예제: 학생 성적 정렬

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

struct Student {
    std::string name;
    int score;
};

int main() {
    std::vector<Student> students = {{"Alice", 85}, {"Bob", 92}, {"Charlie", 78}};

    std::sort(students.begin(), students.end(), 
              [](const Student& a, const Student& b) { return a.score > b.score; });

    std::for_each(students.begin(), students.end(), 
                  [](const Student& s) { std::cout << s.name << ": " << s.score << "\n"; });

    return 0;
}

출력 예시:

Bob: 92
Alice: 85
Charlie: 78
  • std::sort를 사용하여 점수 기준으로 정렬
  • std::for_each를 사용하여 정렬된 데이터 출력

4. 웹 서버 로그 분석 (`std::unordered_map` + `std::transform`)


웹 서버의 접속 로그에서 IP별 접속 횟수를 집계하는 프로그램을 STL 알고리즘을 활용하여 구현할 수 있습니다.

예제: IP별 접속 횟수 집계

#include <iostream>
#include <fstream>
#include <unordered_map>
#include <vector>
#include <algorithm>

int main() {
    std::ifstream file("access.log");
    std::unordered_map<std::string, int> ipCount;
    std::string ip;

    while (file >> ip) {
        ++ipCount[ip];
    }

    std::vector<std::pair<std::string, int>> sortedIPs(ipCount.begin(), ipCount.end());

    std::sort(sortedIPs.begin(), sortedIPs.end(),
              [](const auto& a, const auto& b) { return a.second > b.second; });

    std::for_each(sortedIPs.begin(), sortedIPs.end(),
                  [](const auto& pair) { std::cout << pair.first << ": " << pair.second << "\n"; });

    return 0;
}

출력 예시:

192.168.1.1: 250
10.0.0.2: 180
172.16.0.3: 120
  • std::unordered_map을 사용하여 IP별 요청 횟수 집계
  • std::sort를 사용하여 접속 횟수 기준으로 정렬
  • std::for_each를 사용하여 결과 출력

5. 파일 크기 비교 도구 (`std::filesystem` + `std::sort`)


C++17의 std::filesystem을 활용하여 특정 디렉터리 내 파일들을 크기 순으로 정렬하는 프로그램을 만들 수 있습니다.

예제: 디렉터리 내 파일 크기 정렬

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

namespace fs = std::filesystem;

int main() {
    std::vector<std::pair<std::string, uintmax_t>> files;

    for (const auto& entry : fs::directory_iterator(".")) {
        if (entry.is_regular_file()) {
            files.emplace_back(entry.path().filename().string(), entry.file_size());
        }
    }

    std::sort(files.begin(), files.end(),
              [](const auto& a, const auto& b) { return a.second > b.second; });

    std::for_each(files.begin(), files.end(),
                  [](const auto& file) { std::cout << file.first << ": " << file.second << " bytes\n"; });

    return 0;
}

출력 예시:

large_file.txt: 1,024,000 bytes
image.jpg: 500,000 bytes
document.pdf: 250,000 bytes
  • std::filesystem을 사용하여 파일 정보 조회
  • std::sort를 사용하여 파일 크기 기준 정렬
  • std::for_each를 사용하여 정렬된 데이터 출력

결론


STL 알고리즘을 활용하면 복잡한 작업을 간결하게 구현할 수 있습니다.

  • std::map과 std::for_each를 이용한 단어 빈도수 계산
  • std::find_if를 활용한 특정 패턴 검색
  • std::sort와 std::for_each를 활용한 성적 정렬
  • std::unordered_map과 std::sort를 활용한 IP 분석
  • std::filesystem과 std::sort를 활용한 파일 크기 비교

다음으로 전체 내용을 정리하는 요약을 제공합니다.

요약

C++ STL 알고리즘을 적극적으로 활용하면 코드의 가독성과 유지보수성을 향상시키면서 성능도 최적화할 수 있습니다.

  • STL 알고리즘의 기본 개념을 이해하고, 반복문보다 STL 알고리즘을 사용하여 코드의 간결성과 안정성을 확보할 수 있습니다.
  • 핵심 STL 알고리즘 (std::for_each, std::transform, std::sort, std::accumulate, std::find_if 등) 을 활용하여 데이터 조작을 효과적으로 수행할 수 있습니다.
  • 성능 최적화를 위해 STL 알고리즘을 적절히 사용하면 연산 속도를 개선할 수 있으며, std::remove_if, std::partition 등의 알고리즘을 활용하면 불필요한 반복문을 줄일 수 있습니다.
  • 람다 함수와 조합하여 STL 알고리즘을 더욱 직관적으로 사용할 수 있으며, std::sort 등의 알고리즘에서 비교 함수를 간단하게 정의할 수 있습니다.
  • 사용자 정의 비교 함수 및 커스텀 연산을 활용하여 정렬 기준을 변경하거나, 특정 조건을 만족하는 요소를 찾는 등의 복잡한 연산을 수행할 수 있습니다.
  • 병렬 STL 알고리즘 (std::execution::par 적용) 을 활용하면 멀티코어 환경에서 대량의 데이터를 더욱 빠르게 처리할 수 있습니다.
  • 실제 프로젝트에서 STL 알고리즘을 활용하는 예제를 통해, 텍스트 분석, 로그 검색, 성적 관리, 웹 서버 로그 분석, 파일 크기 비교 등의 문제를 효과적으로 해결할 수 있음을 확인했습니다.

STL 알고리즘을 적극 활용하면 코드의 품질을 높이고, 유지보수성을 향상시키면서도 실행 성능을 극대화할 수 있습니다. 이를 실무에서 잘 활용하면 보다 효율적인 C++ 프로그램을 개발할 수 있습니다.

C++
C++ STL 알고리즘 코드 최적화
목차
  1. STL 알고리즘이란?
    1. STL 알고리즘의 주요 특징
    2. STL 알고리즘의 기본 분류
  2. 반복문보다 STL 알고리즘을 사용하는 이유
    1. 1. 코드 가독성과 유지보수성 향상
    2. 2. 성능 최적화 및 오류 방지
    3. 3. 병렬 연산 지원
    4. 결론
  3. 주요 STL 알고리즘 정리
    1. 1. 요소를 순회하는 알고리즘: `std::for_each`
    2. 2. 변환 알고리즘: `std::transform`
    3. 3. 정렬 알고리즘: `std::sort`
    4. 4. 축적 알고리즘: `std::accumulate`
    5. 5. 검색 알고리즘: `std::find`
    6. 6. 요소 제거 알고리즘: `std::remove`
    7. 7. 중복 제거 알고리즘: `std::unique`
    8. 결론
  4. 성능 최적화를 위한 STL 알고리즘 활용법
    1. 1. `std::sort` 대신 `std::stable_sort` 활용
    2. 2. `std::unordered_map`을 이용한 빠른 검색
    3. 3. `std::remove_if`를 이용한 조건부 제거
    4. 4. `std::accumulate` 대신 `std::reduce` 활용
    5. 5. `std::partition`을 이용한 효율적인 필터링
    6. 결론
  5. 람다 함수와 STL 알고리즘의 조합
    1. 1. `std::for_each`와 람다 함수
    2. 2. `std::transform`과 람다 함수
    3. 3. `std::sort`와 람다 함수
    4. 4. `std::remove_if`와 람다 함수
    5. 5. `std::count_if`와 람다 함수
    6. 6. `std::find_if`와 람다 함수
    7. 결론
  6. 사용자 정의 비교 함수와 커스텀 연산
    1. 1. `std::sort`에서 사용자 정의 비교 함수 사용
    2. 2. 람다 함수를 활용한 비교 함수
    3. 3. `std::unique`에서 사용자 정의 비교 함수 사용
    4. 4. `std::set`과 사용자 정의 비교 함수
    5. 5. `std::find_if`에서 사용자 정의 비교 함수 사용
    6. 결론
  7. 병렬 STL 알고리즘 활용
    1. 1. 병렬 STL 알고리즘의 개념
    2. 2. 병렬 정렬: `std::sort` vs `std::sort` with `std::execution::par`
    3. 3. 병렬 누적 연산: `std::reduce` vs `std::accumulate`
    4. 4. 병렬 `std::for_each`로 데이터 처리 속도 향상
    5. 5. `std::transform`과 병렬 실행
    6. 결론
  8. STL 알고리즘을 활용한 예제 프로젝트
    1. 1. 단어 빈도수 계산기 (`std::map` + `std::for_each`)
    2. 2. 로그 파일에서 특정 패턴 검색 (`std::find_if` 활용)
    3. 3. 학생 성적 관리 시스템 (`std::vector` + `std::sort`)
    4. 4. 웹 서버 로그 분석 (`std::unordered_map` + `std::transform`)
    5. 5. 파일 크기 비교 도구 (`std::filesystem` + `std::sort`)
    6. 결론
  9. 요약