C++ 20 기능 소개

C++20은 C++11 이후 가장 큰 변화를 담은 표준으로, 템플릿의 조건을 선언에 적는 콘셉트, 알고리즘을 컨테이너에 바로 적용하고 이어 붙이는 범위 라이브러리, #include를 대신하는 모듈, 중단과 재개가 가능한 함수인 코루틴이 들어왔습니다. 이 네 가지는 하나의 기능이 아니라, 아래 그림처럼 각자 다른 문제를 다룹니다.

이 글은 네 기능과 세 방향 비교, 컴파일 시간에 결정하는 도구들, 그 밖의 C++20 기능을 차례로 개관하고, C++23에서 이어진 기능도 짧게 소개합니다. 예제는 C++20을 지원하는 GCC에서 -std=c++20으로, C++23 기능은 -std=c++23으로 빌드한다고 가정합니다.

export module MathModule;
import MathModule;

co_yield i;
co_return 100;

std::ranges::sort(numbers);
// filter → transform → 순회

template<Addable T>
void print_sum_and_type(T,T);

콘셉트

함수 템플릿에서 본 것처럼, 템플릿은 넘긴 타입이 본문의 연산을 지원하지 않으면 본문을 인스턴스화하는 단계에서 길고 읽기 어려운 오류를 냅니다. 콘셉트(concept)는 템플릿 인수가 갖춰야 할 조건에 이름을 붙여 선언에 적게 해, 조건에 맞지 않는 타입을 호출 지점에서 바로 거부합니다.

#include <concepts>
#include <iostream>

template <typename T>
concept Addable = requires(T a, T b) {
    { a + b } -> std::integral;
};

template <Addable T>
void printSum(T a, T b) {
    std::cout << "sum " << a + b << '\n';
}

struct Item {
    int value;
    friend Item operator+(Item a, Item b) { return {a.value + b.value}; }
};

template <typename T>
concept SumHasValue = requires(T a, T b) {
    { (a + b).value } -> std::convertible_to<int>;
};

template <SumHasValue T>
int sumValue(T a, T b) {
    return (a + b).value;
}

int main() {
    printSum(10, 20);
    static_assert(SumHasValue<Item>);
    static_assert(!SumHasValue<int>);
    std::cout << sumValue(Item{4}, Item{5}) << '\n';
    // printSum(1.5, 2.5); // 컴파일 오류: double의 합은 정수 타입이 아님
}

sum 30
9

requires 식은 괄호 안의 매개변수로 적은 연산이 컴파일되는지와, -> 뒤의 콘셉트로 결과 타입을 검사합니다. Addable은 두 값의 합이 정수 타입이어야 하므로 int는 만족하고 double은 만족하지 않으며, printSum(1.5, 2.5)는 본문에 들어가기 전에 조건을 만족하지 않는다는 오류가 납니다. SumHasValue는 합의 value 멤버까지 검사하므로, int는 덧셈은 되지만 value가 없어 이 조건을 만족하지 않습니다.

콘셉트는 본문이 실제로 쓰는 연산과 맞춰 적어야 의미가 있습니다. 조건에는 덧셈만 적고 본문에서 .value를 쓰면, 조건은 통과했는데 본문에서 다시 오류가 날 수 있습니다. <concepts>에는 std::integral, std::floating_point, std::totally_ordered 같은 표준 콘셉트가 있고, void show(std::integral auto x)처럼 매개변수에 바로 콘셉트를 적는 축약 문법도 있습니다.

범위 라이브러리

알고리즘의 끝에서 본 std::ranges::sort처럼, 범위 라이브러리(ranges library)의 알고리즘은 반복자 쌍 대신 컨테이너를 바로 받습니다. 또 뷰(view)를 |로 이어 붙여, 원소를 거르고 바꾸는 과정을 파이프라인처럼 적을 수 있습니다.

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

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

    std::ranges::sort(numbers);
    for (int n : numbers) { std::cout << n << ' '; }
    std::cout << '\n';

    auto evensPlusTen = numbers
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::transform([](int x) { return x + 10; });
    for (int n : evensPlusTen) { std::cout << n << ' '; }
    std::cout << '\n';

    for (int n : numbers) { std::cout << n << ' '; }
    std::cout << '\n';
}

1 2 3 4 5 6 7 8 9
12 14 16 18
1 2 3 4 5 6 7 8 9

std::ranges::sort는 원본을 정렬하지만, std::views::filter와 std::views::transform은 원본을 바꾸지 않고 새 컨테이너도 만들지 않습니다. 뷰는 순회할 때마다 원본에서 원소를 꺼내 그 자리에서 거르고 바꾸는 지연 평가(lazy evaluation)를 합니다. 그래서 결과를 오래 보관해야 한다면 별도의 컨테이너에 담아야 하고, 뷰를 쓰는 동안 원본이 살아 있어야 하며 원본을 바꾸면 뷰가 보는 값도 바뀝니다.

세 방향 비교

C++20의 세 방향 비교 연산자 <=>는 두 값을 한 번 비교해 작음, 같음, 큼을 알려 줍니다. 연산자 오버로딩 기초에서 본 것처럼 auto operator<=>(const T&) const = default;로 선언하면 컴파일러가 멤버를 선언 순서대로 비교하는 <=>를 만들고, 이를 바탕으로 <, <=, >, >=를 쓸 수 있습니다.

<=>를 = default로 선언하면 ==도 함께 만들어지지만, <=>를 직접 구현했다면 ==는 따로 정의해야 합니다. 같은지 확인하는 일은 크기를 비교하는 것보다 빠르게 할 수 있는 경우가 많아, 둘을 분리해 두었기 때문입니다.

모듈

#include는 헤더의 내용을 그대로 복사해 넣으므로, 같은 헤더가 많은 소스에 포함되면 매번 다시 컴파일되고 헤더의 매크로가 다른 코드에 새어 들어갑니다. 모듈(module)은 공개할 이름을 export로 밝히고, 쓰는 쪽은 import로 가져오게 합니다.

export module MathModule;

export namespace math {
    double add(double a, double b) { return a + b; }
}

import MathModule;

int main() {
    double sum = math::add(10.0, 5.0);
    (void)sum;
}

모듈은 한 번 컴파일한 인터페이스를 다른 소스가 재사용하므로 빌드 시간을 줄이고, export하지 않은 이름과 매크로는 밖으로 나가지 않습니다. 대신 모듈 인터페이스를 먼저 컴파일해야 그것을 import하는 소스를 컴파일할 수 있어, 빌드 순서를 지켜야 합니다. 모듈을 켜는 옵션과 인터페이스 파일의 확장자, 빌드 도구의 지원은 컴파일러마다 다르므로, 실제 프로젝트에 도입할 때는 쓰는 컴파일러와 빌드 도구의 문서를 확인합니다.

코루틴

코루틴(coroutine)은 실행을 중간에 멈추었다가 나중에 그 자리에서 다시 시작할 수 있는 함수입니다. 본문에 co_yield, co_return, co_await 가운데 하나가 있으면 코루틴이 되며, 멈추는 동안에도 지역 변수가 담긴 코루틴 프레임(coroutine frame)이 살아 있습니다. 언어는 중단과 재개의 틀만 주고, 스케줄러나 스레드는 제공하지 않습니다.

#include <coroutine>
#include <exception>
#include <iostream>
#include <stdexcept>

struct IntGenerator {
    struct promise_type {
        int value = 0;
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        IntGenerator get_return_object() {
            return IntGenerator{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        void unhandled_exception() { std::terminate(); }
        void return_value(int v) { value = v; }
        std::suspend_always yield_value(int v) {
            value = v;
            return {};
        }
    };

    std::coroutine_handle<promise_type> handle;

    explicit IntGenerator(std::coroutine_handle<promise_type> h) : handle(h) {}
    IntGenerator(const IntGenerator&) = delete;
    IntGenerator& operator=(const IntGenerator&) = delete;
    ~IntGenerator() {
        if (handle) {
            handle.destroy();
        }
    }

    int next() {
        if (!handle || handle.done()) {
            throw std::logic_error("generator finished");
        }
        handle.resume();
        return handle.promise().value;
    }

    bool done() const { return handle.done(); }
};

IntGenerator generateNumbers() {
    for (int i = 0; i < 5; ++i) {
        co_yield i;
    }
    co_return 100;
}

int main() {
    auto gen = generateNumbers();
    while (!gen.done()) {
        std::cout << "generated " << gen.next() << '\n';
    }
    std::cout << "done\n";
}

generated 0
generated 1
generated 2
generated 3
generated 4
generated 100
done

promise_type은 코루틴이 처음과 끝에서 멈출지, co_yield와 co_return의 값을 어디에 둘지를 정하며, 이 예제는 처음과 끝에서 모두 멈추도록 std::suspend_always를 돌려줍니다. 아래 그림처럼 generateNumbers()를 부르면 본문을 실행하지 않고 처음에 멈춘 채 gen을 돌려주고, next()가 resume()으로 재개할 때마다 다음 co_yield까지 실행해 0부터 4를 내놓습니다. 여섯 번째 next()는 반복문을 끝내고 co_return 100으로 마지막에 멈추므로 done()이 참이 되고, 프레임은 gen의 소멸자가 destroy()할 때 해제됩니다.

이 예제는 co_return의 값도 next()의 결과로 읽도록 만들었지만, 모든 생성기가 그렇게 동작하는 것은 아닙니다. 마지막에 멈춘 코루틴을 다시 resume()하는 것은 정의되지 않은 동작이어서, next()가 먼저 done()을 확인해 예외를 던집니다. 실제로 비동기 입출력에 코루틴을 쓸 때는 취소, 시간 제한, 오류 전달을 함께 설계해야 하며, C++23에는 이런 생성기를 대신하는 std::generator가 들어왔습니다.

컴파일 시간에 결정하는 도구

컴파일할 때 결정하는 일을 돕는 키워드도 늘었습니다. 이름이 비슷하지만 하는 일이 서로 다릅니다.

template<Addable T>
void print_sum_and_type(T,T);

if constexpr (
  std::is_arithmetic_v<T>) {
  // number 처리
}

consteval int square(int x) {
  return x * x;
}

constinit int g_retry_limit = 3;

#include <iostream>
#include <string>
#include <type_traits>

template <typename T>
void printValue(const T& value) {
    if constexpr (std::is_arithmetic_v<T>) {
        std::cout << "[number] " << value << '\n';
    } else {
        std::cout << "[text] " << value << '\n';
    }
}

consteval int square(int x) {
    return x * x;
}

constinit int retryLimit = 3;

int main() {
    printValue(42);
    printValue(std::string("hi"));

    constexpr int area = square(5);
    retryLimit = 4;
    std::cout << area << ' ' << retryLimit << '\n';
}

[number] 42
[text] hi
25 4

C++17의 if constexpr는 템플릿 안에서 조건이 거짓인 갈래를 그 타입으로는 인스턴스화하지 않으므로, 타입에 따라 쓸 수 없는 코드를 한 함수에 함께 둘 수 있습니다. C++20의 consteval 함수는 반드시 컴파일할 때 계산되어야 하는 즉시 함수(immediate function)여서, square(5)처럼 상수 인자로만 부를 수 있습니다. constinit은 전역이나 정적 변수가 프로그램 시작 전에 상수로 초기화되도록 요구할 뿐, 변수를 const로 만들지는 않으므로 retryLimit에 4를 대입할 수 있습니다.

그 밖의 C++20 기능

C++23에서 이어진 기능

C++23은 C++20을 다듬고 쓰기 편한 기능을 더했습니다. std::expected<T, E>는 값 또는 오류를 돌려주어, 예외 처리의 기본 개념에서 본 반환값 방식의 한계를 타입으로 해결합니다. std::print와 std::println은 std::format과 같은 형식 문자열로 바로 출력하고, std::ranges::to는 뷰의 결과를 컨테이너로 모읍니다.

그 밖에 멤버 함수의 대상 객체를 이름 있는 매개변수로 받는 명시적 객체 매개변수, 정렬한 vector 위에 만든 std::flat_map, 앞에서 언급한 std::generator도 C++23에 들어왔습니다. 새 기능은 쓰는 컴파일러와 표준 라이브러리가 지원하는지 먼저 확인하고, 작은 범위에서 하나씩 도입하는 편이 안전합니다.

더 깊이: 기능을 지원하는지 코드에서 확인하기

새 기능을 쓸 수 있는지는 컴파일러의 버전 번호보다 기능 검사 매크로(feature-test macro)로 확인하는 편이 정확합니다. 언어 기능의 매크로는 모든 번역 단위에 미리 정의되어 있어 #if defined(__cpp_concepts)처럼 바로 검사할 수 있고, 라이브러리 기능의 매크로는 C++20의 <version> 헤더와 그 기능을 담은 헤더가 정의하므로 <version>을 포함한 뒤 #ifdef __cpp_lib_format처럼 검사합니다. 매크로의 값은 201907L처럼 연도와 월을 이어 붙인 정수여서, 기능이 나중에 확장된 경우에는 값을 비교해 어느 단계까지 지원하는지도 알 수 있습니다. 반면 C++17의 __has_include(<format>)는 그 이름의 헤더 파일이 있는지만 알려 줄 뿐, 안의 기능이 완성되어 있는지는 알려 주지 않습니다.

표준 버전을 나타내는 __cplusplus는 C++20에서 202002L이지만, MSVC는 기본으로 이 값을 언제나 199711L로 둡니다. Microsoft 문서에 따르면 이 값에 기대는 기존 코드가 많기 때문이며, Visual Studio 2017 버전 15.7부터 있는 /Zc:__cplusplus 옵션을 켜야 /std 옵션에 맞는 값이 나옵니다. 그래서 여러 컴파일러에서 빌드할 코드는 __cplusplus보다 기능 검사 매크로를 기준으로 갈래를 나눕니다.

기능이 있다고 나와도 빌드 설정이 더 필요할 수 있습니다. 예를 들어 GCC 14의 변경 사항은 Windows에서 C++23의 std::print와 std::println을 쓰려면 -lstdc++exp를 함께 링크해야 한다고 적고 있으므로, 새 기능은 쓰는 환경에서 작은 예제로 먼저 빌드해 봅니다.

정리

• C++20의 콘셉트는 템플릿 인수의 조건을 선언에 적어, 맞지 않는 타입을 호출 지점에서 거부하며, 조건은 본문이 쓰는 연산과 맞춰 적습니다.
• 범위 라이브러리의 알고리즘은 컨테이너를 바로 받고, 뷰는 원본을 복사하지 않고 순회할 때 계산하므로 원본이 살아 있어야 합니다.
• <=>를 = default로 선언하면 순서 비교와 ==를 함께 얻습니다.
• 모듈은 export와 import로 공개 범위를 밝히고 빌드를 빠르게 하지만, 빌드 순서와 도구의 지원을 확인해야 합니다.
• 코루틴은 멈추었다가 재개되는 함수이며, 프레임은 소유자가 destroy()할 때까지 살아 있고 끝난 코루틴은 재개하지 않습니다.
• if constexpr는 갈래의 인스턴스화를, consteval은 컴파일 시간 계산을, constinit은 정적 초기화를 정하며 서로 다른 도구입니다.

연습 문제

1. 컴파일 시간이라고 모두 상수는 아니다

compile_time_tools.cpp의 선언을 그대로 두고 square(5), int n = 7; square(n);, retryLimit = 4;, constexpr int limit = retryLimit; 가운데 컴파일되는 것은 무엇인가요?

2. 생성기의 반복 횟수 바꾸기

int_generator.cpp의 generateNumbers에서 반복 조건만 i < 3으로, 마지막을 co_return 9;로 바꾸면 무엇이 출력되나요? 프레임은 언제 해제되나요?

3. 지연 평가되는 뷰

ranges.cpp에서 evensPlusTen을 만든 뒤, 순회하기 전에 numbers[1] = 100;을 실행하면 둘째 출력 줄은 무엇이 되나요? 정렬된 numbers의 인덱스 1은 원래 2였습니다.

이것으로 14장의 현대 C++ 기능을 마칩니다. 다음 장의 스레드 생성과 관리에서는 여러 작업을 동시에 실행하는 스레드를 만들고, 스레드의 수명을 관리하는 방법을 다룹니다.