C++

C++의 역사는 C (프로그래밍 언어)의 실행 효율과 시스템 프로그래밍 능력을 유지하면서, 대규모 프로그램을 더 체계적으로 구성할 수 있는 추상화 기능을 추가해 온 과정이다. 최초의 언어는 C with Classes라는 이름으로 개발되었으며, 이후 독립된 컴파일러와 가상 함수, 함수 및 연산자 오버로딩이 추가되면서 C++로 발전했다. 1998년 국제 표준이 처음 제정된 뒤에는 표준 라이브러리와 제네릭 프로그래밍이 언어의 중심으로 자리 잡았고, C++11 이후에는 이동 의미론, 람다 표현식, 컴파일 시간 계산과 동시성 기능을 포함하는 현대 C++ 체계가 형성되었다.

역사적 코드 예제는 각 시대의 대표적인 문법과 프로그래밍 방식을 보여주기 위해 작성되었다. C with Classes 예제는 당시 문헌에 나타난 문법을 바탕으로 재구성한 것이며, 오늘날의 C++ 컴파일러에서 그대로 컴파일되는 코드는 아니다.

C with Classes의 개발

비야네 스트롭스트룹은 1979년 Bell Labs에서 분산 시스템과 네트워크 관련 프로그램을 개발하면서, C의 효율성과 Simula의 클래스 기반 프로그램 구성 방식을 결합하려 했다. 그는 같은 해 10월 Simula와 유사한 클래스 기능을 C에 추가하는 전처리기 Cpre를 만들었고, 1980년 3월에는 실제 프로젝트와 여러 실험에서 사용할 수 있는 수준으로 발전시켰다.^[4]

이 초기 언어는 별도의 독립 언어라기보다 C에 클래스를 추가한 확장으로 인식되었으며, C with Classes라고 불렸다. 구현 방식도 완전한 컴파일러가 아니라 C with Classes 코드를 일반 C 코드로 변환한 뒤 기존 C 컴파일러에 전달하는 전처리기 방식이었다.

C with Classes의 초기 컴파일 과정

1. C with Classes 소스 코드
   ↓
2. Cpre 전처리기
   ↓
3. 일반 C 소스 코드
   ↓
4. C 컴파일러
   ↓
5. 기계어 또는 실행 파일

초기 C with Classes에는 클래스, 파생 클래스, public과 private 접근 제어, 생성자와 소멸자, 친구 클래스, 함수 인자의 타입 검사 등이 포함되었다. 1981년에는 인라인 함수, 기본 인자와 대입 연산자 오버로딩도 추가되었다. 반면 가상 함수, 함수 오버로딩, 참조, 템플릿과 예외 처리는 아직 존재하지 않았다.^[5]

당시 클래스는 오늘날과 마찬가지로 데이터와 그 데이터를 다루는 함수를 하나의 사용자 정의 타입으로 묶는 역할을 했다. 그러나 생성자 문법과 객체 선언 방식에는 현대 C++와 다른 부분이 있었다.

다음 코드는 1980년 C with Classes의 stack 예제를 바탕으로 당시 문법을 재구성한 것이다.

#define SIZE 100

class stack {
    char data[SIZE];
    char* bottom;
    char* top;
    char* limit;

    // 당시에는 클래스 이름과 같은 함수가 아니라
    // new()라는 특별한 초기화 함수를 생성자로 사용했다.
    void new();

public:
    void push(char value);
    char pop();
};

당시의 new()는 동적 메모리 할당 연산자가 아니라 객체 초기화 함수, 즉 오늘날의 생성자에 해당했다. C with Classes 문헌에서는 이를 new-function이라고 불렀다. 이후 C++에서는 생성자의 이름을 클래스 이름과 같게 작성하는 현재 방식으로 변경되었다.

멤버 함수는 클래스 선언 바깥에서 정의할 수 있었지만, 현재 사용하는 stack::pop() 형태가 아니라 점 표기법과 유사한 문법이 사용되었다.

char stack.pop()
{
    if (top <= bottom) {
        error("stack underflow");
    }

    return *(--top);
}

객체를 선언할 때도 타입 이름 앞에 class를 명시하는 형태가 일반적으로 사용되었다.

class stack first;
class stack second;

class stack* pointer = &second;

// 당시의 new는 객체 생성 및 동적 할당에도 사용되었지만,
// 문법과 내부 의미는 현대 C++와 완전히 같지 않았다.
class stack* dynamic_stack = new stack;

first.push('A');
pointer->push('B');

이 코드에서 확인할 수 있는 초기 설계 원칙은 이후 C++에도 대부분 유지되었다.

• 클래스는 단순한 코드 묶음이 아니라 객체를 생성할 수 있는 타입이다.
• 객체의 데이터 배치는 클래스 선언에서 결정된다.
• 비공개 데이터에는 클래스의 멤버 함수만 접근할 수 있다.
• 멤버 함수의 선언과 정의를 분리할 수 있다.
• 객체는 포인터뿐 아니라 지역 변수와 전역 변수로도 선언할 수 있다.
• C의 포인터와 배열, 수동 메모리 접근 기능을 그대로 사용할 수 있다.

C with Classes의 목적은 C의 계산 모델을 대체하는 것이 아니었다. 계산과 하드웨어 제어는 이미 C가 해결한 문제로 보고, 클래스와 접근 제어를 통해 프로그램의 구조를 개선하는 데 초점을 맞췄다. 스트롭스트룹은 실행 시간, 코드 크기와 객체 크기에서 C보다 불필요한 비용이 발생하지 않아야 한다는 기준을 적용했다.^[6]

C++라는 이름과 최초 공개

1982년 무렵 스트롭스트룹은 C with Classes의 전처리기 기반 구조와 제한된 기능만으로는 더 넓은 사용자를 지원하기 어렵다고 판단했다. 그는 기존 경험을 바탕으로 언어를 정리하고 확장하면서, 전처리기가 아닌 전통적인 컴파일러 구조를 사용하는 새 구현체를 개발하기 시작했다.

새 언어는 잠시 C84라고 불렸으나, 1983년부터 C++라는 이름이 사용되었다. 이름은 C의 증가 연산자 ++에서 가져온 것으로, C를 기반으로 한 다음 단계의 언어라는 의미를 나타낸다. C with Classes라는 이름이 일상적으로 C로 줄여 불리면서 기존 C가 “old C” 또는 “plain C”로 불리는 혼란이 생긴 것도 이름 변경의 배경이었다.^[7]

초기 C++에는 C with Classes에 없던 다음과 같은 기능이 추가되었다.

• 가상 함수
• 함수 이름과 연산자 오버로딩
• 참조
• const
• // 한 줄 주석
• 자유 저장 영역 연산자 new와 delete
• 클래스 이름을 사용하는 생성자와 ~로 시작하는 소멸자
• 범위 지정 연산자 ::

C with Classes의 스택을 초기 C++ 문법으로 옮기면 다음과 같은 형태가 된다.

const int stack_size = 100;

class Stack {
    char data[stack_size];
    char* bottom;
    char* top;
    char* limit;

public:
    // 클래스 이름과 같은 함수가 생성자가 되었다.
    Stack();

    // 물결표가 붙은 함수는 소멸자가 되었다.
    ~Stack();

    void push(char value);
    char pop();
};

Stack::Stack()
{
    bottom = data;
    top = data;
    limit = data + stack_size;
}

Stack::~Stack()
{
    // 이 클래스는 외부 자원을 소유하지 않으므로
    // 별도로 해제할 작업이 없다.
}

char Stack::pop()
{
    if (top <= bottom) {
        error("stack underflow");
    }

    return *(--top);
}

이 시기부터 Stack::Stack()처럼 ::를 사용해 클래스 외부에서 멤버 함수를 정의하는 문법이 정착했다. 생성자는 클래스 이름과 같고 반환형을 갖지 않으며, 소멸자는 클래스 이름 앞에 ~를 붙이는 현재의 기본 구조가 만들어졌다.

가상 함수의 추가는 C++가 단순한 추상 자료형 언어에서 객체 지향 프로그래밍 언어로 확장되는 중요한 계기가 되었다.

class Shape {
public:
    virtual void draw();
};

class Circle : public Shape {
public:
    void draw();
};

void render(Shape& shape)
{
    // 실제 객체가 Circle이면 Circle::draw()가 호출된다.
    shape.draw();
}

C with Classes에도 파생 클래스는 있었지만 가상 함수가 없었기 때문에, 기반 클래스의 인터페이스를 통해 실제 파생 객체의 동작을 선택하는 런타임 다형성을 직접 표현하기 어려웠다. 1983년 가상 함수가 추가되면서 클래스 계층과 동적 디스패치를 결합한 객체 지향 프로그래밍이 가능해졌다.

1985년에는 최초의 상용 C++ 구현체인 Cfront 1.0과 스트롭스트룹의 《The C++ Programming Language》 초판이 공개되었다. Cfront는 C++ 코드를 C 코드로 변환했지만, 단순한 문자 기반 전처리기가 아니라 C++ 문법과 타입 체계를 분석하는 컴파일러 프런트엔드였다.^[8]

Cfront의 컴파일 과정

1. C++ 소스 코드
   ↓
2. Cfront 구문 및 타입 분석
   ↓
3. 변환된 C 소스 코드
   ↓
4. 플랫폼의 C 컴파일러
   ↓
5. 실행 파일

C++ 2.0과 언어 기능의 확장

1989년에 공개된 C++ 2.0은 다중 상속, 추상 클래스, static 멤버 함수, const 멤버 함수와 보호된 접근 수준인 protected 등을 도입했다. 이 시기의 C++는 대규모 객체 지향 프로그램을 작성하기 위한 기능을 본격적으로 갖추기 시작했다.

class Drawable {
public:
    virtual void draw() = 0;
};

class Serializable {
public:
    virtual void save() = 0;
};

class Document : public Drawable, public Serializable {
public:
    void draw();
    void save();
};

= 0으로 선언된 순수 가상 함수와 추상 클래스는 공통 인터페이스를 표현할 수 있게 했다. 다중 상속은 하나의 클래스가 여러 기반 클래스의 인터페이스와 구현을 함께 계승할 수 있게 했지만, 기반 클래스의 중복과 복잡한 객체 배치 문제도 함께 가져왔다.

이 시기에는 템플릿과 예외 처리도 실험되고 있었다. 1990년에 출판된 The Annotated C++ Reference Manual, 줄여서 ARM은 당시 AT&T C++ 2.0을 바탕으로 언어를 정리했으며, 이후 표준화 작업의 주요 기반 문서가 되었다. ARM과 초기 표준화 과정에서 템플릿과 예외 처리가 언어의 정식 기능으로 자리 잡았다.^[9]

초기 템플릿은 서로 다른 타입에 대해 같은 자료구조나 알고리즘을 반복 작성하는 문제를 해결했다.

template<class T>
class Stack {
    T* data;
    int size;
    int top;

public:
    Stack(int capacity);
    ~Stack();

    void push(T value);
    T pop();
};

템플릿을 사용하면 Stack<int>, Stack<double>과 Stack<MyType>처럼 타입별 스택을 하나의 정의에서 생성할 수 있었다. 이는 이후 표준 템플릿 라이브러리와 제네릭 프로그래밍의 기반이 되었다.

예외 처리는 오류 처리 코드를 일반 실행 흐름에서 분리하는 수단을 제공했다.

class stack_underflow {
};

char Stack::pop()
{
    if (top <= bottom) {
        throw stack_underflow();
    }

    return *(--top);
}

void process(Stack& stack)
{
    try {
        char value = stack.pop();
        use(value);
    }
    catch (stack_underflow&) {
        recover();
    }
}

국제 표준화

C++ 사용자가 증가하고 여러 회사에서 서로 다른 컴파일러와 라이브러리를 개발하면서, 구현체 간 호환성을 확보하기 위한 공식 표준이 필요해졌다. 미국에서는 1989년 ANSI X3J16 위원회가 구성되었고, 국제적으로는 1990년부터 1991년 사이 ISO/IEC JTC 1/SC 22/WG 21이 조직되었다.^[10]

표준화 작업은 단순히 기존 언어를 문서화하는 데 그치지 않았다. 템플릿과 예외 처리, 이름공간, 런타임 타입 정보, bool 타입과 새로운 형 변환 연산자 등이 정리되었으며, Alexander Stepanov와 Meng Lee가 개발한 표준 템플릿 라이브러리가 표준 라이브러리에 통합되었다.

C++98

1998년 최초의 국제 C++ 표준인 ISO/IEC 14882:1998이 제정되었다. C++98은 언어 문법뿐 아니라 문자열, 입출력 스트림, 컨테이너, 반복자와 알고리즘을 포함하는 표준 라이브러리를 규정했다.

C++98의 대표적인 프로그래밍 방식은 명시적인 타입과 반복자, 수동 자원 관리를 사용하는 형태였다.

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

int main()
{
    std::vector<std::string> names;

    names.push_back("Unix");
    names.push_back("C");
    names.push_back("C++");

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

    for (std::vector<std::string>::const_iterator it = names.begin();
         it != names.end();
         ++it) {
        std::cout << *it << '\n';
    }

    return 0;
}

이 코드에는 std::vector, 반복자와 std::sort가 사용된다. 자료구조와 알고리즘을 분리하고 반복자로 연결하는 구조는 표준 템플릿 라이브러리의 핵심 설계였다.

C++98에서는 템플릿을 활용한 제네릭 프로그래밍이 표준적인 언어 사용 방식으로 자리 잡았다.

template<class Iterator, class T>
Iterator find_value(Iterator first, Iterator last, const T& value)
{
    while (first != last) {
        if (*first == value) {
            return first;
        }

        ++first;
    }

    return last;
}

이 함수는 배열, 연결 리스트, 벡터처럼 반복자를 제공하는 여러 자료구조에 같은 방식으로 적용할 수 있다.

C++03

2003년에 제정된 C++03은 새로운 언어 기능을 대규모로 도입한 판이라기보다 C++98의 결함 보고서와 모호한 규칙을 정리한 개정판이었다. 값 초기화와 일부 템플릿 규칙이 개선되었지만, 프로그래밍 방식 자체는 C++98과 크게 다르지 않았다.

struct Counter {
    int value;
};

// C++03에서 값 초기화 규칙이 정리되면서
// 기본 타입 멤버를 0으로 초기화하는 동작이 명확해졌다.
Counter counter = Counter();

C++03 시기에는 컴파일러와 표준 라이브러리 구현이 안정화되었으며, Boost와 같은 외부 라이브러리 생태계가 성장했다. 이후 C++11에 도입된 스마트 포인터, 정규 표현식, 스레드와 여러 메타프로그래밍 도구는 Boost에서 먼저 널리 실험된 기능의 영향을 받았다.

C++11과 현대 C++의 형성

C++11은 C++98 이후 가장 큰 변화로 평가되는 표준이다. 개발 중에는 2000년대 안에 완성될 것이라는 의미에서 C++0x라고 불렸으나, 최종 표준은 2011년에 제정되었다.^[11]

C++11에는 다음과 같은 핵심 기능이 추가되었다.

• 이동 의미론과 오른값 참조
• auto 타입 추론
• 람다 표현식
• 범위 기반 for
• nullptr
• constexpr
• 가변 인자 템플릿
• 열거형 클래스
• 위임 생성자
• 사용자 정의 리터럴
• 표준 스레드와 원자적 연산
• std::unique_ptr와 std::shared_ptr
• std::tuple, std::array와 해시 기반 컨테이너

C++98 코드를 C++11 방식으로 다시 작성하면 타입과 반복자 관련 상용구가 크게 줄어든다.

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

int main()
{
    std::vector<std::string> names {
        "Unix",
        "C",
        "C++"
    };

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

    for (const auto& name : names) {
        std::cout << name << '\n';
    }
}

이동 의미론은 임시 객체나 더 이상 사용하지 않는 객체의 자원을 복사하지 않고 이전할 수 있게 했다.

class Buffer {
    unsigned char* data_;
    std::size_t size_;

public:
    explicit Buffer(std::size_t size)
        : data_(new unsigned char[size]),
          size_(size)
    {
    }

    ~Buffer()
    {
        delete[] data_;
    }

    // 복사 생성자는 새로운 저장 공간을 만든다.
    Buffer(const Buffer& other)
        : data_(new unsigned char[other.size_]),
          size_(other.size_)
    {
        std::copy(other.data_, other.data_ + size_, data_);
    }

    // 이동 생성자는 기존 저장 공간의 소유권만 넘긴다.
    Buffer(Buffer&& other) noexcept
        : data_(other.data_),
          size_(other.size_)
    {
        other.data_ = nullptr;
        other.size_ = 0;
    }
};

스마트 포인터는 동적 객체의 수명을 객체 자체의 수명과 연결하는 RAII 방식을 표준화했다.

#include <memory>

class Device {
public:
    void start();
};

void run()
{
    std::unique_ptr<Device> device(new Device());

    device->start();

    // 함수가 끝나면 Device가 자동으로 파괴된다.
}

C++14 이후에는 std::make_unique를 사용해 같은 코드를 더 직접적으로 작성할 수 있다.

C++14

C++14는 C++11의 기능을 보완하고 더 쉽게 사용할 수 있도록 개선한 표준이다. 일반 람다, 함수 반환형 추론, 변수 템플릿, 완화된 constexpr 규칙과 std::make_unique 등이 추가되었다.

#include <iostream>
#include <memory>

auto add = [](const auto& left, const auto& right) {
    return left + right;
};

int main()
{
    auto value = std::make_unique<int>(42);

    std::cout << add(*value, 8) << '\n';
}

일반 람다는 매개변수에 auto를 사용할 수 있어, 이름이 없는 함수 객체를 템플릿처럼 사용할 수 있게 했다.

auto print_pair = [](const auto& first, const auto& second) {
    std::cout << first << ": " << second << '\n';
};

print_pair("version", 14);
print_pair(10, 20.5);

C++17

C++17은 구조적 바인딩, if constexpr, 인라인 변수, 클래스 템플릿 인자 추론과 폴드 표현식을 도입했다. 표준 라이브러리에는 std::optional, std::variant, std::any, std::string_view와 파일 시스템 라이브러리가 추가되었다.^[12]

#include <iostream>
#include <map>
#include <string>

int main()
{
    std::map<std::string, int> versions {
        {"C++98", 1998},
        {"C++11", 2011},
        {"C++17", 2017}
    };

    // 구조적 바인딩으로 pair의 두 요소를 바로 분해한다.
    for (const auto& [name, year] : versions) {
        std::cout << name << ": " << year << '\n';
    }
}

if constexpr는 템플릿 인스턴스화 시점에 조건에 맞지 않는 분기를 제거할 수 있게 했다.

#include <iostream>
#include <type_traits>

template<class T>
void print_value(const T& value)
{
    if constexpr (std::is_pointer_v<T>) {
        std::cout << *value << '\n';
    }
    else {
        std::cout << value << '\n';
    }
}

C++20

C++20은 C++11 이후 가장 큰 규모의 표준으로, 개념, 범위, 모듈과 코루틴을 주요 기능으로 도입했다.^[13]

개념은 템플릿 인자가 충족해야 하는 조건을 언어 문법으로 표현한다.

#include <concepts>

template<class T>
concept Number = std::integral<T> || std::floating_point<T>;

template<Number T>
T square(T value)
{
    return value * value;
}

범위 라이브러리는 반복자의 시작과 끝을 개별적으로 전달하는 대신, 컨테이너나 뷰 자체를 알고리즘에 전달할 수 있게 했다.

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

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

    auto result = values
        | std::views::filter([](int value) {
              return value % 2 == 0;
          })
        | std::views::transform([](int value) {
              return value * value;
          });

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

모듈은 헤더 파일과 전처리기 중심의 소스 코드 구성 방식을 보완하기 위해 도입되었다.

export module math;

export int add(int left, int right)
{
    return left + right;
}

import math;

int main()
{
    return add(20, 22);
}

코루틴은 함수 실행을 중단하고 나중에 다시 이어서 실행할 수 있는 저수준 언어 기반을 제공했다. C++20 코루틴 자체는 완성된 비동기 프레임워크가 아니라, 라이브러리가 생성기나 작업, 비동기 입출력 타입을 구현할 수 있도록 하는 언어 기능이다.

Generator<int> count_to(int end)
{
    for (int value = 1; value <= end; ++value) {
        co_yield value;
    }
}

여기서 Generator는 표준 C++20에 직접 포함된 타입이 아니라, 코루틴 프로토콜을 이용해 별도로 구현하거나 라이브러리에서 제공해야 하는 타입이다.

C++23

C++23은 C++20의 대형 기능을 보완하면서 라이브러리의 표현력과 오류 처리 기능을 확장한 표준이다. 현재 정식 국제 표준은 ISO/IEC 14882:2024이며, 기술 작업이 2023년에 완료되었기 때문에 일반적으로 C++23이라고 부른다.^[14]

C++23에는 std::expected, std::print, std::generator, std::mdspan, 범위 라이브러리 확장과 여러 constexpr 개선이 포함되었다.

std::expected는 성공 결과와 오류 값을 하나의 타입으로 표현한다.

#include <expected>
#include <string>

std::expected<int, std::string> parse_number(const std::string& text)
{
    try {
        return std::stoi(text);
    }
    catch (...) {
        return std::unexpected("숫자로 변환할 수 없다.");
    }
}

int main()
{
    auto result = parse_number("42");

    if (!result) {
        return 1;
    }

    return *result;
}

std::print는 기존 입출력 스트림보다 간결한 형식 지정 출력을 제공한다.

#include <print>
#include <string>

int main()
{
    std::string language = "C++";
    int standard = 23;

    std::println("{}{}", language, standard);
}

현대 C++에서는 직접적인 new와 delete, 소유권이 불분명한 포인터와 수동 반복자 사용을 줄이고, 값 타입과 RAII, 표준 컨테이너, 스마트 포인터, 범위와 컴파일 시간 검사를 활용하는 방향이 널리 권장된다.

#include <algorithm>
#include <memory>
#include <print>
#include <ranges>
#include <string>
#include <vector>

struct Project {
    std::string name;
    int year;
};

int main()
{
    std::vector<Project> projects {
        {"C with Classes", 1979},
        {"C++", 1983},
        {"C++98", 1998},
        {"C++11", 2011},
        {"C++20", 2020},
        {"C++23", 2023}
    };

    auto modern = projects
        | std::views::filter([](const Project& project) {
              return project.year >= 2011;
          });

    for (const auto& project : modern) {
        std::println("{}: {}", project.name, project.year);
    }
}

이 코드는 C++가 초기의 클래스 확장 언어에서 값 의미론, 제네릭 프로그래밍, 자동 자원 관리와 범위 기반 데이터 처리를 결합하는 언어로 발전했음을 보여준다.

C++26과 이후의 표준화

C++23 이후에는 C++26 표준화가 진행되고 있다. WG21은 정적 리플렉션, 계약, 패턴 및 라이브러리 확장 등을 포함한 다음 표준을 개발하고 있다. 다만 표준이 정식 발행되기 전까지 세부 기능과 문법은 변경될 수 있다.^[15]

C++의 표준화는 기존 프로그램과 구현체의 호환성을 유지하면서 새 추상화 기능을 추가하는 방식으로 진행된다. 이 때문에 오래된 C++ 코드가 현대 컴파일러에서도 상당 부분 유지되는 반면, 서로 다른 시대의 프로그래밍 방식이 하나의 언어 안에 공존한다.

C++의 주요 역사적 흐름

• C with Classes
  • 1979년 Cpre 개발
  • 1980년 클래스 기반 초기 구현
  • 1981년 인라인 함수와 기본 인자
• C++
  • 1983년 C++ 명칭과 가상 함수
  • 1985년 Cfront 1.0과 최초 상용 공개
  • 1989년 C++ 2.0
  • 1990년 ARM
• ISO C++
  • 1998년 C++98
  • 2003년 C++03
  • 2011년 C++11
  • 2014년 C++14
  • 2017년 C++17
  • 2020년 C++20
  • 2023년 C++23 기술 작업 완료
  • C++26 표준화 진행

C++는 특정 CPU 명령어 집합이나 운영체제, 실행 파일 형식에 직접 종속된 언어로 정의되지 않는다. C++ 표준은 프로그램이 실행되는 개념적 환경인 추상 기계와 그 안에서 발생하는 객체 생성, 표현식 평가, 함수 호출, 입출력 및 스레드 간 동작을 규정한다. 실제 컴파일러는 이 추상 기계의 동작을 대상 플랫폼의 기계어와 운영체제 기능으로 변환한다.

이 구조를 통해 같은 C++ 소스 코드를 서로 다른 프로세서와 운영체제에서 구현할 수 있다. 표준은 프로그램의 의미와 관찰 가능한 결과를 규정하지만, 레지스터 배치, 명령어 선택, 함수 호출 규약과 실행 파일 구성처럼 플랫폼에 따라 달라지는 세부 사항은 구현체에 맡긴다.

C++의 설계는 고수준 추상화를 제공하면서도 사용하지 않는 기능에 불필요한 실행 비용을 부과하지 않는 무비용 추상화 원칙과 연결된다. 이 원칙은 사용하지 않는 기능에는 시간이나 공간 비용을 지불하지 않고, 사용하는 기능은 같은 작업을 수작업으로 구현한 것보다 본질적으로 비효율적이지 않아야 한다는 방향을 뜻한다.^[16]

추상 기계와 구현

C++ 표준의 추상 기계는 실제 컴퓨터를 그대로 묘사한 가상 CPU가 아니다. 프로그램의 의미를 정의하기 위해 필요한 객체, 값, 메모리 위치, 실행 스레드, 평가 순서와 입출력 동작을 설명하는 규범적 모델이다.

적합한 C++ 구현체는 올바르게 작성된 프로그램을 실행했을 때, 표준의 추상 기계가 허용하는 실행 가운데 하나와 같은 관찰 가능한 동작을 만들어야 한다.^[17]

관찰 가능한 동작에는 일반적으로 다음과 같은 요소가 포함된다.

• 프로그램이 외부 파일에 기록한 데이터
• 표준 입출력 스트림을 통한 입출력
• volatile 객체에 대한 접근
• 원자적 연산과 스레드 간 동기화에 의해 드러나는 동작
• 프로그램의 정상 종료 또는 비정상 종료

컴파일러는 관찰 가능한 결과를 유지하는 범위에서 소스 코드와 다른 방식으로 프로그램을 실행할 수 있다. 이를 흔히 as-if 규칙이라고 한다. 컴파일러는 실제로 수행할 필요가 없는 계산을 제거하거나, 여러 연산을 하나로 합치거나, 함수를 호출하지 않고 본문을 삽입할 수 있다.

다음 코드에서 temporary의 계산 결과는 외부에서 관찰되지 않는다.

int calculate()
{
    int temporary = 10 * 20;
    return 42;
}

최적화된 프로그램에서는 temporary 변수와 곱셈 연산이 완전히 제거될 수 있다. 추상 기계의 관점에서 calculate()가 42를 반환한다는 관찰 가능한 결과가 유지되기 때문이다.

반면 출력과 같이 외부에서 관찰할 수 있는 동작은 임의로 제거할 수 없다.

#include <iostream>

int main()
{
    std::cout << "A";
    std::cout << "B";
}

구현체는 내부 호출 구조를 변경하거나 두 출력을 하나로 결합할 수 있지만, 정상적으로 실행되는 프로그램이 최종적으로 AB를 출력한다는 의미는 유지해야 한다.

C++ 구현은 크게 호스티드 구현과 프리스탠딩 구현으로 구분된다. 호스티드 구현은 일반적인 운영체제 환경에서 전체 표준 라이브러리와 정해진 프로그램 시작 규칙을 제공한다. 프리스탠딩 구현은 운영체제가 없는 환경에서도 실행될 수 있으며, 임베디드 시스템, 부트로더와 운영체제 커널 같은 프로그램을 지원한다.^[18]

// 프리스탠딩 환경에서는 구현체가 자체 진입점을 사용할 수 있다.
// 아래 이름과 주소는 특정 플랫폼의 예시일 뿐 C++ 표준이 정하지 않는다.

extern "C" void kernel_entry()
{
    for (;;) {
        // 하드웨어 이벤트를 처리한다.
    }
}

호스티드 환경에서는 일반적으로 main 함수가 프로그램의 시작점이지만, 프리스탠딩 환경의 시작 함수와 초기화 절차는 구현체와 대상 플랫폼이 정한다.

소스 파일과 번역 단위

C++ 프로그램은 하나 이상의 소스 파일로 구성될 수 있다. 그러나 표준에서 컴파일의 기본 단위는 파일 자체가 아니라 번역 단위다.

전처리 과정이 끝난 뒤 컴파일러가 하나의 단위로 구문과 의미를 분석하는 토큰의 집합을 번역 단위라고 한다. 헤더 파일을 #include하면 헤더가 독립적인 번역 단위로 컴파일되는 것이 아니라, 전처리 과정에서 포함한 소스 파일 안으로 들어간 것처럼 처리된다.

예를 들어 다음과 같은 헤더가 있다고 가정할 수 있다.

// calculator.hpp

#pragma once

int add(int left, int right);

구현은 별도의 소스 파일에 작성할 수 있다.

// calculator.cpp

#include "calculator.hpp"

int add(int left, int right)
{
    return left + right;
}

이를 사용하는 소스 파일은 또 다른 번역 단위를 이룬다.

// main.cpp

#include "calculator.hpp"
#include <iostream>

int main()
{
    std::cout << add(20, 22) << '\n';
}

일반적인 빌드에서는 calculator.cpp와 main.cpp가 각각 독립적으로 번역된다.

여러 소스 파일의 일반적인 빌드 흐름

1. calculator.cpp와 포함된 헤더
   ↓
2. 첫 번째 번역 단위 분석 및 목적 파일 생성
   ↓
3. main.cpp와 포함된 헤더
   ↓
4. 두 번째 번역 단위 분석 및 목적 파일 생성
   ↓
5. 목적 파일과 라이브러리 결합
   ↓
6. 실행 파일 또는 공유 라이브러리 생성

각 번역 단위는 다른 번역 단위의 소스 내용을 직접 알지 못한다. 대신 외부 연결을 가진 함수나 변수의 이름을 통해 서로 결합한다. 이후 링커가 각 번역 단위에서 생성된 목적 코드와 필요한 라이브러리를 결합한다.

C++20의 모듈도 번역 단위를 없애지 않는다. 모듈 인터페이스 단위, 모듈 구현 단위와 헤더 단위 역시 각각 번역 단위의 한 종류다.

// math.cppm

export module math;

export int multiply(int left, int right)
{
    return left * right;
}

// main.cpp

import math;

int main()
{
    return multiply(6, 7);
}

모듈은 공개할 이름을 명시적으로 관리하고, 전처리기 기반의 텍스트 포함에 의존하지 않고 번역된 선언을 가져올 수 있게 한다. 그러나 구체적인 모듈 파일 형식과 빌드 명령은 컴파일러와 빌드 시스템에 따라 달라진다.

번역 과정

C++ 표준은 소스 코드가 프로그램으로 해석되는 과정을 여러 번역 단계로 설명한다. 실제 컴파일러가 반드시 각 단계를 별도의 프로그램이나 순차 처리 과정으로 구현해야 하는 것은 아니지만, 결과는 표준이 규정한 단계의 순서와 같은 의미를 가져야 한다.^[19]

주요 흐름은 다음과 같이 정리할 수 있다.

C++ 번역의 개념적 흐름

1. 소스 파일의 문자 해석
   ↓
2. 줄 연결과 주석 처리
   ↓
3. 전처리 토큰 분석
   ↓
4. 전처리 지시문 실행과 헤더 포함
   ↓
5. 문자 및 문자열 리터럴 처리
   ↓
6. 인접 문자열 리터럴 결합
   ↓
7. 번역 단위의 구문 및 의미 분석
   ↓
8. 필요한 템플릿 인스턴스화
   ↓
9. 번역 단위와 라이브러리 결합

전처리기는 C++의 일반적인 타입 체계와 이름 공간을 이해하지 않는다. 매크로는 토큰 수준에서 처리되므로 일반 함수와 다른 의미를 가진다.

#define SQUARE(value) value * value

int result = SQUARE(1 + 2);

전처리 결과는 개념적으로 다음과 같다.

int result = 1 + 2 * 1 + 2;

연산자 우선순위 때문에 결과는 9가 아니라 5가 된다. 같은 기능을 함수나 constexpr 함수로 표현하면 C++의 타입 검사와 표현식 규칙을 적용할 수 있다.

constexpr int square(int value)
{
    return value * value;
}

static_assert(square(1 + 2) == 9);

템플릿은 전처리기 매크로와 달리 번역 단위의 구문 및 의미 분석 과정에 참여한다.

template<class T>
T maximum(T left, T right)
{
    return left < right ? right : left;
}

int integer = maximum(10, 20);
double real = maximum(1.5, 3.0);

컴파일러는 사용된 템플릿 인자에 따라 필요한 특수화를 생성하고 각 타입에 대해 표현식이 올바른지 검사한다.

선언과 정의

선언은 이름이나 개체를 프로그램에 도입하고, 그 이름의 타입과 의미를 컴파일러에 알린다. 정의는 선언의 한 종류이며, 함수 본문을 제공하거나 객체에 필요한 저장 공간을 마련하는 등 해당 개체를 실제로 구성한다.^[20]

다음 문장은 함수의 선언이다.

int calculate(int value);

함수 본문이 없으므로 이 선언만으로는 함수의 동작이 제공되지 않는다.

다음 문장은 같은 함수의 정의다.

int calculate(int value)
{
    return value * 2;
}

변수에서도 선언과 정의를 구분할 수 있다.

// 다른 번역 단위에 정의된 변수를 선언한다.
extern int global_count;

// 저장 공간을 갖는 변수를 정의한다.
int global_count = 0;

일반적으로 하나의 프로그램에서 odr-use되는 비인라인 함수와 변수는 하나의 정의만 가져야 한다. 이 규칙을 단일 정의 규칙, 즉 ODR이라고 한다.

다음과 같이 정의를 헤더 파일에 직접 작성하면 그 헤더를 포함한 여러 번역 단위에 같은 함수 정의가 생성될 수 있다.

// 잘못 구성된 header.hpp

int next_value()
{
    static int value = 0;
    return ++value;
}

함수에 inline을 지정하면 외부 또는 모듈 연결을 가진 동일한 정의를 여러 번역 단위에 둘 수 있다. 이 경우에도 프로그램 전체에서는 하나의 개체로 취급된다.^[21]

inline int next_value()
{
    static int value = 0;
    return ++value;
}

클래스 정의 내부에 작성한 멤버 함수와 함수 템플릿은 여러 번역 단위에서 사용할 수 있도록 별도의 관련 규칙을 적용받는다.

객체와 값

C++에서 객체는 특정 타입을 가지며, 데이터가 저장되는 메모리 영역을 차지할 수 있는 실행 중 개체다. 객체에는 저장 기간과 수명이 있으며, 다른 객체를 하위 객체로 포함할 수도 있다.^[22]

다음 코드에는 여러 객체가 존재한다.

struct Position {
    int x;
    int y;
};

Position player {10, 20};

player는 Position 타입의 완전한 객체다. 그 안의 x와 y는 각각 int 타입의 멤버 하위 객체다.

배열도 객체이며 각 원소는 배열의 하위 객체다.

int values[3] {10, 20, 30};

values는 배열 객체이고, values[0], values[1], values[2]는 각각 배열 원소 객체다.

C++의 변수와 객체는 같은 개념이 아니다. 변수는 선언으로 도입된 이름 있는 객체 또는 참조를 뜻하지만, 모든 객체가 변수인 것은 아니다. 임시 객체, 동적으로 생성한 이름 없는 객체와 다른 객체 내부의 하위 객체도 객체다.

#include <string>

void print(std::string text);

int main()
{
    // std::string 임시 객체가 생성된다.
    print(std::string("C++"));
}

값은 표현식을 평가한 결과로 사용된다. 같은 값이라도 서로 다른 객체에 저장될 수 있다.

int first = 42;
int second = 42;

first와 second는 서로 다른 객체지만 같은 값 42를 가진다.

C++ 객체의 메모리 표현은 타입, 정렬 요구 사항, 구현체와 대상 ABI에 영향을 받는다. 구조체 멤버 사이에는 정렬을 맞추기 위한 패딩이 삽입될 수 있다.

struct Record {
    char tag;
    int value;
};

이 구조체의 크기가 반드시 sizeof(char) + sizeof(int)와 같지는 않다. 구현체는 value를 적절한 주소에 배치하기 위해 tag 뒤에 패딩을 둘 수 있다.

#include <cstddef>

static_assert(sizeof(Record) >= sizeof(char) + sizeof(int));

표준 레이아웃 타입과 trivially copyable 타입에는 메모리 배치와 바이트 단위 복사에 관한 추가 보장이 존재하지만, 모든 클래스가 같은 보장을 받는 것은 아니다.

저장 기간과 객체 수명

저장 기간은 객체를 담는 저장 공간이 잠재적으로 얼마나 오래 유지되는지를 나타낸다. C++은 정적, 스레드, 자동, 동적 저장 기간을 규정한다.^[23]

다음 코드에는 여러 저장 기간의 객체가 함께 존재한다.

#include <memory>

int global_count = 0;             // 정적 저장 기간
thread_local int thread_count = 0; // 스레드 저장 기간

void process()
{
    int local_count = 0;          // 자동 저장 기간

    auto dynamic_count =
        std::make_unique<int>(0); // 가리키는 int 객체는 동적 저장 기간
}

저장 기간과 객체 수명은 관련되어 있지만 같은 개념은 아니다. 저장 공간이 존재한다고 해서 그 안에 항상 살아 있는 객체가 존재하는 것은 아니다. 객체의 수명은 초기화가 완료되는 등 타입에 맞는 조건이 충족될 때 시작하고, 소멸자가 시작되거나 저장 공간이 재사용 또는 해제될 때 끝난다.^[24]

다음 코드에서 resource의 수명은 함수 블록에 진입해 생성자가 완료된 뒤 시작하고, 블록을 벗어날 때 소멸자가 호출되면서 끝난다.

#include <iostream>

class Resource {
public:
    Resource()
    {
        std::cout << "획득\n";
    }

    ~Resource()
    {
        std::cout << "반환\n";
    }
};

void use_resource()
{
    Resource resource;

    std::cout << "사용\n";
}

실행 흐름은 다음과 같다.

자동 객체의 일반적인 수명

1. 객체를 위한 저장 공간 확보
   ↓
2. 생성자 실행
   ↓
3. 객체 수명 시작
   ↓
4. 객체 사용
   ↓
5. 소멸자 실행
   ↓
6. 객체 수명 종료
   ↓
7. 저장 공간 해제 또는 재사용

C++에서는 저장 공간을 객체의 수명과 별도로 직접 다룰 수도 있다. 배치 new는 이미 존재하는 저장 공간에 객체를 생성한다.

#include <cstddef>
#include <new>

struct Packet {
    int type;
    int size;
};

int main()
{
    alignas(Packet) std::byte storage[sizeof(Packet)];

    Packet* packet = new (storage) Packet {1, 128};

    int size = packet->size;

    packet->~Packet();

    return size;
}

storage 배열의 수명과 그 안에 생성된 Packet 객체의 수명은 서로 다르다. Packet의 소멸자를 호출한 뒤에도 바이트 배열의 저장 공간은 남아 있지만, 그 공간 안의 Packet 객체는 더 이상 살아 있지 않다.

일반적인 애플리케이션 코드에서는 이런 저수준 수명 조작보다 컨테이너와 스마트 포인터를 사용하는 편이 객체 수명을 명확하게 관리하기 쉽다.

#include <memory>

struct Device {
    void start();
    void stop();
};

void run()
{
    auto device = std::make_unique<Device>();

    device->start();

    // 함수가 끝나면 unique_ptr가 Device를 파괴한다.
}

값 범주와 참조

C++의 표현식은 단순히 값을 계산하는 것만이 아니라, 객체를 식별하거나 이동 가능한 자원을 나타낼 수도 있다. 이 차이를 표현하기 위해 각 표현식에는 값 범주가 부여된다.

모든 표현식은 최종적으로 다음 세 기본 범주 가운데 하나에 속한다.

• lvalue: 지속적인 정체성을 가진 객체나 함수를 나타내는 표현식
• xvalue: 정체성을 가지면서 자원을 재사용할 수 있는 객체를 나타내는 표현식
• prvalue: 값을 계산하거나 객체를 초기화하기 위한 순수 값을 나타내는 표현식

표준은 lvalue와 xvalue를 합쳐 glvalue, prvalue와 xvalue를 합쳐 rvalue라고 분류한다.^[25]

C++ 값 범주의 관계

• 표현식
  • glvalue
    • lvalue
    • xvalue
  • rvalue
    • prvalue
    • xvalue

다음 코드에서 이름이 있는 변수 표현식 value는 lvalue다.

int value = 42;

int* pointer = &value;
value = 100;

정수 리터럴 42와 덧셈 결과는 prvalue다.

int first = 20;
int second = 22;

int result = first + second;

std::move는 객체 자체를 이동하지 않는다. 전달받은 표현식을 이동 가능한 xvalue로 변환한다.

#include <string>
#include <utility>

std::string source = "C++";
std::string destination = std::move(source);

std::move(source)는 xvalue 표현식이다. 이를 이용해 destination의 이동 생성자가 source가 가진 내부 자원을 넘겨받을 수 있다. 이동 이후에도 source 객체의 수명은 계속되며, 유효하지만 구체적인 내용이 보장되지 않는 상태가 될 수 있다.

참조는 다른 객체나 함수에 대한 별칭을 제공한다.

int value = 10;

int& reference = value;
reference = 20;

reference를 통해 값을 변경하면 실제 객체인 value가 변경된다.

오른값 참조는 일반적으로 임시 객체나 이동 가능한 객체를 받아 자원 이전을 구현할 때 사용한다.

#include <string>
#include <utility>

void consume(std::string&& text)
{
    std::string owned = std::move(text);
}

int main()
{
    consume(std::string("temporary"));
}

참조 자체에도 수명이 있지만, 참조가 다른 객체의 수명을 항상 연장하는 것은 아니다. 특정한 초기화 문맥에서는 임시 객체의 수명이 참조에 맞춰 연장되지만, 함수 매개변수나 반환 과정에서는 같은 규칙이 그대로 적용되지 않을 수 있다.

#include <string>

const std::string& text = std::string("C++");

// 이 초기화에서는 임시 std::string의 수명이
// text의 수명에 맞춰 연장된다.

반면 지역 객체를 참조로 반환하면 함수 종료와 함께 객체의 수명이 끝난다.

#include <string>

const std::string& invalid_text()
{
    std::string text = "C++";

    // text는 함수가 끝날 때 파괴된다.
    return text;
}

반환된 참조를 사용하면 이미 수명이 끝난 객체에 접근하게 된다.

복사와 이동

C++의 객체는 타입이 제공하는 복사 생성자, 복사 대입 연산자, 이동 생성자와 이동 대입 연산자를 통해 상태를 전달할 수 있다.

복사는 원본과 독립적인 새 객체를 만든다.

#include <string>

std::string original = "C++";
std::string copied = original;

copied += "23";

original과 copied는 서로 다른 객체이며, 한쪽을 수정해도 다른 쪽의 문자열 값은 바뀌지 않는다.

이동은 원본 객체가 가진 자원을 새 객체가 재사용할 수 있게 한다.

#include <string>
#include <utility>
#include <vector>

std::vector<std::string> create_names()
{
    std::vector<std::string> names;

    names.push_back("C");
    names.push_back("C++");

    return names;
}

반환 시 구현체는 복사를 수행하는 대신 객체를 직접 호출자의 결과 저장 공간에 생성하거나 이동을 사용할 수 있다. C++17 이후 일부 상황에서는 이러한 복사 생략이 선택적 최적화가 아니라 언어 의미 자체로 보장된다.

직접 자원을 관리하는 클래스는 복사와 이동의 의미를 명확히 정의해야 한다.

#include <algorithm>
#include <cstddef>
#include <utility>

class Buffer {
    std::size_t size_ = 0;
    unsigned char* data_ = nullptr;

public:
    explicit Buffer(std::size_t size)
        : size_(size),
          data_(new unsigned char[size])
    {
    }

    ~Buffer()
    {
        delete[] data_;
    }

    Buffer(const Buffer& other)
        : size_(other.size_),
          data_(new unsigned char[other.size_])
    {
        std::copy(
            other.data_,
            other.data_ + other.size_,
            data_
        );
    }

    Buffer(Buffer&& other) noexcept
        : size_(std::exchange(other.size_, 0)),
          data_(std::exchange(other.data_, nullptr))
    {
    }
};

복사 생성자는 새로운 저장 공간을 할당하고 데이터를 복제한다. 이동 생성자는 기존 포인터를 넘겨받고 원본 객체가 더 이상 그 저장 공간을 소유하지 않도록 만든다.

실제 프로그램에서는 직접 배열을 소유하기보다 std::vector, std::string과 스마트 포인터처럼 복사와 이동 규칙이 이미 구현된 타입을 조합하는 방식이 일반적이다.

#include <string>
#include <vector>

class Document {
    std::string title_;
    std::vector<std::string> lines_;

public:
    Document(
        std::string title,
        std::vector<std::string> lines
    )
        : title_(std::move(title)),
          lines_(std::move(lines))
    {
    }
};

이 클래스는 소멸자와 복사·이동 함수를 직접 작성하지 않아도 각 멤버가 자신의 자원을 관리한다. 이를 0의 규칙이라고 부른다.

실행 순서와 표현식 평가

C++ 프로그램의 각 표현식은 하나 이상의 값 계산과 부수 효과를 발생시킬 수 있다. 값 계산은 객체의 값을 읽거나 결과를 계산하는 작업이고, 부수 효과는 객체 수정, 입출력, 함수 호출과 같은 상태 변화를 포함한다.

int value = 10;

int result = value++;

후위 증가 표현식은 증가 전의 값을 결과로 계산하고, value를 증가시키는 부수 효과를 발생시킨다.

C++은 모든 하위 표현식의 평가 순서를 항상 왼쪽에서 오른쪽으로 규정하지 않는다. 연산자와 문맥에 따라 평가 순서가 지정되거나, 순서만 불특정하거나, 서로 순서가 정해지지 않을 수 있다.

다음 코드에서 함수 인자들은 모두 함수 본문에 들어가기 전에 평가되지만, first()와 second() 가운데 어느 쪽이 먼저 호출되는지는 일반적으로 고정되지 않는다.

int first();
int second();
void use(int left, int right);

int main()
{
    use(first(), second());
}

호출 순서에 의존해야 한다면 표현식을 분리해 순서를 명시할 수 있다.

int left = first();
int right = second();

use(left, right);

논리 AND와 OR, 조건 연산자, 쉼표 연산자 등 일부 연산자는 특정한 평가 순서를 보장한다.

bool pointer_is_valid(const int* pointer)
{
    return pointer != nullptr && *pointer > 0;
}

&&의 왼쪽 피연산자가 false이면 오른쪽 피연산자는 평가되지 않으므로, 널 포인터를 역참조하지 않는다.

컴파일 시간과 실행 시간

C++은 일부 계산을 프로그램 실행 전에 번역 과정에서 수행할 수 있다. 상수 표현식은 배열 크기, 템플릿 인자, 열거형 값과 static_assert 같은 문맥에서 사용된다.

constexpr int square(int value)
{
    return value * value;
}

constexpr int area = square(12);

static_assert(area == 144);

constexpr 함수는 상수 표현식 문맥뿐 아니라 실행 시간에도 호출할 수 있다.

int read_value();

int main()
{
    int value = read_value();

    // 입력값은 번역 시 알 수 없으므로 실행 시간에 계산된다.
    int result = square(value);

    return result;
}

같은 square 함수라도 인자가 상수 표현식이면 컴파일 시간에 평가될 수 있고, 실행 중에 얻은 값이면 일반 함수처럼 실행된다.

consteval 함수는 반드시 상수 평가 과정에서 호출되어야 한다.

consteval unsigned long long hash_literal(const char* text)
{
    unsigned long long hash = 1469598103934665603ULL;

    while (*text != '\0') {
        hash ^= static_cast<unsigned char>(*text++);
        hash *= 1099511628211ULL;
    }

    return hash;
}

constexpr auto identifier = hash_literal("renderer");

이러한 기능은 타입 구성, 테이블 생성, 문자열 처리와 검증 작업을 실행 시간에서 번역 시간으로 옮길 수 있게 한다. 다만 컴파일 시간 계산도 추상 기계의 규칙에 따라 평가되며, 상수 표현식에서 허용되는 연산에는 별도의 제한이 적용된다.

정의된 동작과 구현 의존성

C++ 표준은 모든 상황에서 하나의 동일한 결과만을 요구하지 않는다. 프로그램의 동작은 표준이 얼마나 구체적으로 규정하는지에 따라 여러 범주로 나뉜다.

구현 정의 동작의 대표적인 예로 기본 정수 타입의 크기와 일반 char가 부호 있는 타입인지 여부 등이 있다.

#include <climits>
#include <iostream>

int main()
{
    std::cout << sizeof(int) << '\n';

#if CHAR_MIN < 0
    std::cout << "char is signed\n";
#else
    std::cout << "char is unsigned\n";
#endif
}

구현체는 이런 선택을 문서화해야 하며, 프로그램은 <limits>나 <climits>와 같은 표준 기능을 통해 현재 구현의 특성을 확인할 수 있다.

불특정 동작은 가능한 결과의 범위는 표준이 허용하지만, 구현체가 하나의 선택을 문서화할 필요는 없는 경우다. 함수 인자의 평가 순서처럼 프로그램이 특정 순서에 의존하지 않아야 하는 상황이 이에 포함될 수 있다.

미정의 동작은 표준이 결과에 어떤 요구도 하지 않는 동작이다.^[26]

다음 코드는 배열 범위를 벗어난다.

int values[3] {10, 20, 30};

int result = values[3];

유효한 인덱스는 0부터 2까지이므로 values[3] 접근의 동작은 정의되지 않는다.

수명이 끝난 객체에 접근하는 것도 미정의 동작이 될 수 있다.

int* create_pointer()
{
    int value = 42;
    return &value;
}

int main()
{
    int* pointer = create_pointer();

    return *pointer;
}

부호 있는 정수의 범위를 넘는 산술 오버플로도 미정의 동작이다.

#include <limits>

int value = std::numeric_limits<int>::max();
int result = value + 1;

반면 부호 없는 정수 산술은 타입의 표현 가능한 값 범위를 기준으로 모듈러 연산을 수행한다.

#include <limits>

unsigned int value =
    std::numeric_limits<unsigned int>::max();

unsigned int result = value + 1;

// result는 0이다.

컴파일러는 올바르게 정의된 프로그램을 번역한다고 가정해 최적화를 수행할 수 있다. 따라서 미정의 동작이 포함된 코드는 단순히 예측할 수 없는 값 하나를 반환하는 데 그치지 않고, 주변 코드의 제거와 재배치에도 영향을 줄 수 있다.

int divide(int value)
{
    int result = 100 / value;

    if (value == 0) {
        return 0;
    }

    return result;
}

나눗셈이 먼저 실행되는 경로에서 value가 0이면 이미 미정의 동작이 발생한다. 컴파일러는 정의된 실행에서는 value가 0일 수 없다고 추론할 수 있으므로 이후 검사를 의미 없는 코드로 판단할 수 있다.

검사는 동작이 발생하기 전에 수행해야 한다.

int divide(int value)
{
    if (value == 0) {
        return 0;
    }

    return 100 / value;
}

메모리 모델과 스레드

C++11부터 표준은 여러 실행 스레드가 하나의 프로그램 안에서 메모리를 공유할 때의 동작을 공식적으로 규정한다. 각 스레드의 평가 순서뿐 아니라 원자적 연산, 동기화와 happens-before 관계를 통해 한 스레드의 쓰기가 다른 스레드에서 언제 관찰되는지를 정의한다.

동기화 없이 여러 스레드가 같은 일반 객체에 접근하고, 그중 하나 이상이 쓰기 작업을 수행하면 데이터 경쟁이 발생할 수 있다. 데이터 경쟁이 발생한 프로그램의 동작은 정의되지 않는다.

#include <thread>

int counter = 0;

void increment()
{
    for (int index = 0; index < 1000; ++index) {
        ++counter;
    }
}

int main()
{
    std::thread first(increment);
    std::thread second(increment);

    first.join();
    second.join();
}

두 스레드가 counter를 동시에 읽고 수정하므로 이 프로그램에는 데이터 경쟁이 존재한다.

원자적 객체를 사용하면 하나의 객체에 대한 기본 연산을 스레드 간에 안전하게 수행할 수 있다.

#include <atomic>
#include <thread>

std::atomic<int> counter = 0;

void increment()
{
    for (int index = 0; index < 1000; ++index) {
        counter.fetch_add(1, std::memory_order_relaxed);
    }
}

int main()
{
    std::thread first(increment);
    std::thread second(increment);

    first.join();
    second.join();

    return counter.load();
}

memory_order_relaxed는 counter 자체의 원자성은 보장하지만, 다른 메모리 접근 사이의 추가적인 순서 관계는 제공하지 않는다. 여러 객체의 상태를 하나의 불변 조건으로 보호해야 한다면 뮤텍스와 같은 상위 동기화 수단을 사용할 수 있다.

#include <mutex>
#include <string>

std::mutex state_mutex;
std::string state;

void update_state(std::string next)
{
    std::lock_guard<std::mutex> lock(state_mutex);

    state = std::move(next);
}

std::lock_guard는 생성될 때 뮤텍스를 잠그고, 블록을 벗어날 때 소멸되면서 잠금을 해제한다. 이는 객체 수명과 동기화 자원 관리를 결합한 RAII의 예다.

실행 모델과 최적화의 관계

C++ 컴파일러는 타입 정보, 객체 수명, 별칭 규칙과 미정의 동작 규정을 이용해 프로그램을 최적화한다. 따라서 추상 기계의 규칙은 문법적 설명에 그치지 않고 실제 생성 코드에 직접 영향을 준다.

다음 함수는 일반적인 최적화에서 상수 하나를 반환하는 코드로 축약될 수 있다.

int calculate()
{
    int left = 20;
    int right = 22;

    return left + right;
}

함수 호출도 호출 자체의 의미를 유지할 필요가 없다면 인라인될 수 있다.

int square(int value)
{
    return value * value;
}

int calculate()
{
    return square(12);
}

최적화된 결과에서는 함수 호출과 곱셈이 모두 제거되고 144가 직접 사용될 수 있다.

가상 함수 호출은 일반적으로 실행 시간 동적 디스패치를 사용하지만, 컴파일러가 실제 객체 타입을 확정할 수 있다면 호출 대상을 정적으로 결정할 수도 있다.

class Shape {
public:
    virtual int area() const = 0;
    virtual ~Shape() = default;
};

class Square final : public Shape {
    int side_;

public:
    explicit Square(int side)
        : side_(side)
    {
    }

    int area() const override
    {
        return side_ * side_;
    }
};

int calculate()
{
    Square square(10);

    return square.area();
}

Square가 final이고 실제 객체 타입이 명확하므로, 구현체는 가상 호출을 직접 호출로 바꾸고 결과를 추가로 최적화할 수 있다.

C++에서 추상화와 최적화는 서로 반대되는 개념이 아니다. 클래스, 템플릿, 람다와 범위 같은 고수준 구조도 컴파일러가 구체적인 타입과 실행 경로를 분석할 수 있다면 저수준 코드와 유사한 형태로 변환될 수 있다. 다만 객체 수명, 별칭, 평가 순서와 동시성 규칙을 위반한 프로그램은 이러한 최적화 가정과 충돌할 수 있다.

C++는 모든 객체, 참조, 함수와 표현식에 컴파일 시점의 타입을 부여하는 정적 타입 언어다. 타입은 값이 어떤 형태로 표현되는지, 객체가 어떤 연산을 지원하는지, 함수가 어떤 인자를 받고 무엇을 반환하는지, 그리고 서로 다른 표현식 사이에 어떤 변환이 허용되는지를 결정한다.

C++ 표준은 타입을 크게 기본 타입과 복합 타입으로 구분한다. 기본 타입은 언어가 직접 제공하는 산술 타입, void와 std::nullptr_t 등으로 이루어지며, 복합 타입은 배열, 함수, 포인터, 참조, 클래스, 공용체, 열거형과 멤버 포인터처럼 다른 타입이나 선언을 바탕으로 구성된다.^[27]

C++의 타입 체계는 단순히 변수에 붙는 이름 목록이 아니다. 다음 요소가 함께 작동한다.

• 객체와 표현식의 정적 타입
• 클래스 상속과 가상 함수에 의한 동적 타입
• 정수·부동소수점 타입의 표현 범위
• 포인터와 참조가 가리키는 대상 타입
• const와 volatile 한정
• 함수 오버로딩과 템플릿 인자 추론
• 암시적·명시적 타입 변환
• 개념과 requires를 통한 타입 제약
• 타입 특성과 컴파일 시간 타입 검사

#include <string>
#include <vector>

int count = 10;
double ratio = 0.5;
std::string name = "C++";
std::vector<int> values {1, 2, 3};

이 코드에서 각 객체의 타입은 컴파일 시점에 결정된다. count에는 int, ratio에는 double, name에는 std::string, values에는 std::vector<int> 타입이 부여된다. 실행 중에 count 객체의 타입이 double이나 문자열로 바뀌는 일은 없다.

정적 타입과 동적 타입

표현식의 정적 타입은 소스 코드를 번역할 때 결정되는 타입이다. 일반적인 객체에서는 정적 타입이 곧 그 객체의 타입이다.

int value = 42;
double result = value * 0.5;

value 표현식의 정적 타입은 int이며, 곱셈 과정에서는 value가 double로 변환되어 계산된다. 그러나 원래 객체의 타입이 변경되는 것은 아니다.

다형적 클래스의 포인터나 참조를 통해 객체를 다룰 때에는 동적 타입도 구분된다. 동적 타입은 실행 중 해당 표현식이 실제로 가리키는 가장 파생된 객체의 타입이다.

class Shape {
public:
    virtual double area() const = 0;
    virtual ~Shape() = default;
};

class Circle final : public Shape {
    double radius_;

public:
    explicit Circle(double radius)
        : radius_(radius)
    {
    }

    double area() const override
    {
        return 3.141592653589793 * radius_ * radius_;
    }
};

Circle circle(10.0);
Shape& shape = circle;

shape 표현식의 정적 타입은 Shape지만, 참조하는 객체의 동적 타입은 Circle이다. 따라서 shape.area()는 가상 함수 디스패치를 통해 Circle::area()를 호출한다.

double result = shape.area();

동적 타입은 모든 클래스에 존재하는 별도의 런타임 태그를 뜻하지 않는다. 다형적 클래스, 즉 하나 이상의 가상 함수를 가진 클래스에 대해 가상 함수 호출이나 dynamic_cast, typeid가 필요한 상황에서 중요한 개념이다.

기본 타입

기본 타입은 다른 타입으로부터 구성되지 않고 언어가 직접 제공하는 타입이다. 여기에는 void, std::nullptr_t, 정수 타입과 부동소수점 타입이 포함된다.^[28]

C++ 기본 타입

• 기본 타입
  • void
  • std::nullptr_t
  • 정수 타입
    • 불리언 타입
    • 문자 타입
    • 표준 부호 있는 정수 타입
    • 표준 부호 없는 정수 타입
    • 확장 정수 타입
  • 부동소수점 타입
    • float
    • double
    • long double
    • 구현체가 제공하는 확장 부동소수점 타입

void

void는 값의 집합이 없는 불완전 타입이다. 일반 객체나 참조의 타입으로 사용할 수 없지만, 값을 반환하지 않는 함수의 반환형과 타입이 지정되지 않은 객체를 가리키는 포인터에 사용된다.

void print_message()
{
}

void* raw_pointer = nullptr;

void 객체는 만들 수 없다.

void object;     // 오류
void& reference; // 오류

void*는 객체 타입을 가리키는 포인터를 저장할 수 있지만, 가리키는 타입에 관한 정보가 없으므로 직접 역참조할 수 없다.

int value = 42;

void* raw = &value;

// int result = *raw; // 오류: void 객체를 역참조할 수 없다.

int* typed = static_cast<int*>(raw);
int result = *typed;

원래 포인터가 가리키던 타입과 일치하지 않는 타입으로 변환해 접근하면 객체 표현과 별칭 규칙을 위반할 수 있다.

std::nullptr_t

nullptr 리터럴의 타입은 std::nullptr_t다. 이 타입의 값은 모든 객체 포인터와 함수 포인터 타입의 널 포인터 값으로 변환될 수 있다.

#include <cstddef>

std::nullptr_t empty = nullptr;

int* integer_pointer = empty;
void (*function_pointer)() = empty;

nullptr는 정수 0을 널 포인터 상수로 사용하던 기존 방식에서 발생하던 오버로드 모호성을 줄인다.

void open(int descriptor);
void open(const char* path);

open(0);       // int 오버로드
open(nullptr); // const char* 오버로드

불리언 타입

bool은 논리적 참과 거짓을 표현하는 정수 타입이다. 가능한 값은 true와 false다.

bool running = true;
bool finished = false;

정수와 포인터는 조건 문맥에서 bool로 변환될 수 있다.

int count = 3;
int* pointer = &count;

if (count) {
    // count가 0이 아니므로 실행된다.
}

if (pointer) {
    // pointer가 널 포인터가 아니므로 실행된다.
}

bool을 정수 타입으로 변환하면 false는 0, true는 1이 된다.

문자 타입

C++는 서로 구별되는 여러 문자 타입을 제공한다.

char, signed char, unsigned char는 서로 별개의 타입이다. char가 실제로 부호 있는 범위를 사용하는지 부호 없는 범위를 사용하는지는 구현 정의다.^[29]

char character = 'A';
signed char signed_byte = -1;
unsigned char byte = 255;

문자 리터럴의 접두사에 따라 타입이 달라진다.

char ordinary = 'A';
wchar_t wide = L'A';
char8_t utf8 = u8'A';
char16_t utf16 = u'A';
char32_t utf32 = U'A';

문자열 리터럴도 문자 타입에 대응하는 배열 타입을 가진다.

const char ordinary[] = "C++";
const wchar_t wide[] = L"C++";
const char8_t utf8[] = u8"C++";
const char16_t utf16[] = u"C++";
const char32_t utf32[] = U"C++";

char8_t, char16_t, char32_t가 유니코드 문자열 전체를 하나의 문자 단위로 직접 표현한다는 뜻은 아니다. 이들은 각각 인코딩의 코드 단위를 저장한다. 하나의 사용자 인식 문자가 여러 코드 단위로 구성될 수 있다.

표준 정수 타입

표준 부호 있는 정수 타입은 다음 순서로 최소 표현 범위가 커진다.

signed char
short
int
long
long long

각 부호 있는 정수 타입에는 대응하는 부호 없는 타입이 있다.

unsigned char
unsigned short
unsigned int
unsigned long
unsigned long long

다음 선언은 일부 생략형을 포함한다.

signed int first = -10;
unsigned int second = 10;

short third = -20;
unsigned short fourth = 20;

long fifth = -30;
unsigned long sixth = 30;

long long seventh = -40;
unsigned long long eighth = 40;

int의 정확한 비트 수는 표준이 하나로 고정하지 않는다. 대신 각 타입의 최소 표현 범위와 타입 간 크기 순서를 규정한다.

static_assert(sizeof(short) <= sizeof(int));
static_assert(sizeof(int) <= sizeof(long));
static_assert(sizeof(long) <= sizeof(long long));

정확한 폭이 필요한 프로그램에서는 <cstdint>의 선택적 고정 폭 정수 타입을 사용할 수 있다.

#include <cstdint>

std::int8_t small = 10;
std::uint16_t port = 8080;
std::int32_t count = 1'000'000;
std::uint64_t identifier = 0xFFFF'FFFF'FFFF'FFFFULL;

std::int32_t 같은 정확한 폭의 타입은 구현체가 패딩 없이 정확히 해당 폭을 가진 타입을 제공할 수 있을 때 정의된다. 모든 구현에서 반드시 존재하는 것은 아니다.

폭이 최소한 특정 크기 이상이면 되는 경우에는 std::int_least32_t나 std::int_fast32_t를 사용할 수 있다.

#include <cstdint>

std::int_least32_t stored_value = 0;
std::int_fast32_t calculation_value = 0;

부호 있는 정수와 부호 없는 정수

부호 없는 정수 연산은 표현 가능한 값의 개수를 법으로 하는 모듈러 산술을 따른다.

#include <limits>

unsigned int value =
    std::numeric_limits<unsigned int>::max();

value += 1;

// value는 0이 된다.

부호 있는 정수 연산이 표현 가능한 범위를 벗어나면 동작이 정의되지 않는다.

#include <limits>

int value = std::numeric_limits<int>::max();

// int result = value + 1;
// 부호 있는 정수 오버플로로 동작이 정의되지 않는다.

부호 없는 타입은 비트 마스크, 해시, 모듈러 산술과 객체 크기처럼 음수가 의미 없는 값을 표현할 때 사용된다. 그러나 단순히 음수를 금지하기 위해 모든 정수에 부호 없는 타입을 사용하면 비교와 뺄셈에서 예상하지 못한 변환이 발생할 수 있다.

int signed_value = -1;
unsigned int unsigned_value = 1;

bool result = signed_value < unsigned_value;

일반적인 산술 변환 과정에서 signed_value가 부호 없는 타입으로 변환될 수 있으므로 result가 직관과 다르게 false가 될 수 있다.

부동소수점 타입

표준 부동소수점 타입은 float, double, long double이다.

float single = 1.0F;
double normal = 1.0;
long double extended = 1.0L;

각 타입은 다음 타입보다 정밀도와 표현 범위가 작거나 같다.

float
≤ double
≤ long double

이 관계가 모든 구현에서 서로 다른 메모리 크기를 뜻하지는 않는다. 일부 구현에서는 double과 long double이 같은 표현 형식을 사용할 수 있다.

부동소수점 타입의 구체적인 정밀도와 표현 범위는 std::numeric_limits로 확인할 수 있다.

#include <limits>

constexpr int double_digits =
    std::numeric_limits<double>::digits;

constexpr double smallest_positive =
    std::numeric_limits<double>::min();

constexpr double largest =
    std::numeric_limits<double>::max();

부동소수점 값은 많은 십진수를 정확히 표현할 수 없다.

double value = 0.1 + 0.2;

bool exact = value == 0.3;

이 비교가 false가 될 수 있는 이유는 0.1, 0.2, 0.3이 일반적인 이진 부동소수점 형식에서 정확히 표현되지 않기 때문이다.

허용 오차를 사용하는 비교는 값의 규모와 계산 특성에 맞게 설계해야 한다.

#include <algorithm>
#include <cmath>

bool nearly_equal(double left, double right, double epsilon)
{
    double scale = std::max({
        1.0,
        std::abs(left),
        std::abs(right)
    });

    return std::abs(left - right) <= epsilon * scale;
}

복합 타입

복합 타입은 하나 이상의 기존 타입이나 선언을 바탕으로 구성된다. C++ 표준의 복합 타입에는 배열, 함수, 포인터, 참조, 클래스, 공용체, 열거형과 멤버 포인터 등이 포함된다.^[30]

C++ 복합 타입

• 복합 타입
  • 배열 타입
  • 함수 타입
  • 포인터 타입
    • 객체 포인터
    • 함수 포인터
  • 참조 타입
    • lvalue 참조
    • rvalue 참조
  • 클래스 타입
    • 클래스
    • 구조체
    • 공용체
  • 열거형 타입
  • 멤버 포인터 타입
    • 데이터 멤버 포인터
    • 멤버 함수 포인터

배열 타입

배열 타입은 같은 타입의 원소가 연속적으로 배치된 고정 크기 객체를 표현한다.

int values[4] {10, 20, 30, 40};

values의 타입은 “원소 네 개를 가진 int 배열”이다. 배열의 크기는 타입의 일부다.

int first[3];
int second[4];

// first와 second는 서로 다른 배열 타입이다.

배열은 많은 표현식에서 첫 번째 원소를 가리키는 포인터로 변환된다.

int values[3] {10, 20, 30};

int* pointer = values;

그러나 배열과 포인터는 같은 타입이 아니다.

int values[3];

static_assert(sizeof(values) == sizeof(int) * 3);

int* pointer = values;
static_assert(sizeof(pointer) == sizeof(int*));

배열을 참조로 받으면 배열 크기를 타입 정보로 유지할 수 있다.

#include <cstddef>

template<class T, std::size_t Size>
constexpr std::size_t array_size(const T (&)[Size])
{
    return Size;
}

int values[5];

static_assert(array_size(values) == 5);

일반적인 코드에서는 소유 배열로 std::array, 동적 크기 배열로 std::vector, 비소유 연속 범위로 std::span을 사용할 수 있다.

#include <array>
#include <span>
#include <vector>

std::array<int, 3> fixed {1, 2, 3};
std::vector<int> dynamic {1, 2, 3, 4};

std::span<int> view = dynamic;

함수 타입

함수도 타입을 가진다. 함수 타입은 반환형과 매개변수 타입 목록, 가변 인자 여부, 일부 한정과 예외 명세로 구성된다.

int add(int left, int right);

add는 int 두 개를 받아 int를 반환하는 함수다.

함수 타입은 타입 별칭으로 표현할 수 있다.

using BinaryOperation = int(int, int);

BinaryOperation add;
BinaryOperation subtract;

함수 객체 자체는 일반 객체처럼 복사하거나 배열에 저장할 수 없지만, 함수 포인터와 함수 참조를 사용할 수 있다.

int add(int left, int right)
{
    return left + right;
}

using Operation = int(int, int);

Operation& operation = add;

int result = operation(20, 22);

포인터 타입

포인터는 객체나 함수의 주소를 나타내는 값이다.

int value = 42;
int* pointer = &value;

int result = *pointer;

포인터 타입은 가리키는 대상 타입을 포함한다.

int* integer_pointer = nullptr;
double* double_pointer = nullptr;

// 서로 다른 타입이다.

포인터 자체도 객체이므로 별도의 주소와 수명을 가진다.

int value = 42;
int* pointer = &value;
int** pointer_to_pointer = &pointer;

포인터는 널 포인터 값, 유효한 객체 또는 함수의 주소, 객체의 끝 다음 위치, 또는 유효하지 않은 포인터 값을 가질 수 있다.

배열 반복에서는 끝 다음 포인터를 비교용으로 사용할 수 있지만 역참조할 수 없다.

int values[3] {10, 20, 30};

int* begin = values;
int* end = values + 3;

for (int* current = begin; current != end; ++current) {
    int value = *current;
}

참조 타입

참조는 기존 객체나 함수의 별칭을 나타낸다. C++에는 lvalue 참조 T&와 rvalue 참조 T&&가 있다.

int value = 42;

int& lvalue_reference = value;
int&& rvalue_reference = 10;

참조는 초기화된 뒤 다른 객체를 가리키도록 다시 지정할 수 없다.

int first = 10;
int second = 20;

int& reference = first;

reference = second;

마지막 문장은 참조 대상을 second로 바꾸는 것이 아니라 first에 second의 값인 20을 대입한다.

널 참조라는 정상적인 참조 값은 존재하지 않는다.

int* pointer = nullptr;

// int& reference = *pointer;
// 역참조 과정에서 유효한 객체가 없으므로 사용할 수 없다.

참조는 객체가 아니므로 일반적인 의미의 참조 배열이나 참조 포인터을 만들 수 없다.

// int& references[3]; // 오류
// int&* pointer;      // 오류

대신 참조를 보관해야 한다면 std::reference_wrapper를 사용할 수 있다.

#include <functional>
#include <vector>

int first = 10;
int second = 20;

std::vector<std::reference_wrapper<int>> references {
    first,
    second
};

references[0].get() = 100;

멤버 포인터 타입

멤버 포인터는 특정 클래스의 비정적 데이터 멤버나 멤버 함수를 식별한다. 일반 객체 포인터와는 다른 타입 체계를 가진다.

struct Position {
    int x;
    int y;
};

int Position::* member = &Position::x;

Position position {10, 20};

int value = position.*member;

객체 포인터와 함께 사용할 때는 ->* 연산자를 사용한다.

Position* pointer = &position;

int value = pointer->*member;

멤버 함수 포인터도 클래스 타입을 포함한다.

struct Device {
    void start();
    void stop();
};

void (Device::* action)() = &Device::start;

Device device;
(device.*action)();

멤버 포인터의 표현 방식은 상속 구조와 ABI에 따라 일반 주소보다 복잡할 수 있다.

사용자 정의 타입

C++에서 프로그램이 직접 정의할 수 있는 주요 타입은 클래스, 구조체, 공용체와 열거형이다. 타입 별칭을 통해 기존 타입에 새로운 이름을 부여할 수도 있다.

클래스와 구조체

class와 struct는 모두 클래스 타입을 정의한다. 두 키워드의 언어적 차이는 기본 접근 수준과 기본 상속 접근 수준이다.

class ClassType {
    int hidden;
};

struct StructType {
    int visible;
};

class의 멤버는 기본적으로 private, struct의 멤버는 기본적으로 public이다.

#include <string>

class User {
    std::string name_;
    int level_;

public:
    User(std::string name, int level)
        : name_(std::move(name)),
          level_(level)
    {
    }

    const std::string& name() const
    {
        return name_;
    }

    int level() const
    {
        return level_;
    }
};

클래스 타입은 데이터 표현과 동작, 불변 조건, 생성과 파괴 규칙을 하나의 타입으로 묶을 수 있다.

공용체

공용체는 여러 비정적 데이터 멤버가 같은 저장 공간을 공유하는 클래스 타입이다. 일반적으로 한 시점에는 하나의 멤버만 활성 상태가 된다.

union Number {
    int integer;
    double real;
};

Number number;
number.integer = 42;

이후 number.real을 읽는 것은 일반적으로 활성 멤버와 다른 멤버에 접근하는 것이므로 제한된 예외를 제외하면 올바른 타입 판별 방식이 아니다.

활성 타입을 안전하게 추적해야 한다면 std::variant를 사용할 수 있다.

#include <string>
#include <variant>

using Value = std::variant<
    int,
    double,
    std::string
>;

Value value = 42;
value = std::string("C++");

열거형

열거형은 이름 있는 상수의 집합을 정의하는 별개의 타입이다.

enum Direction {
    North,
    South,
    East,
    West
};

범위 없는 열거형의 열거자는 바깥 범위로 들어가며 정수 타입으로 암시적 변환될 수 있다.

Direction direction = North;
int value = direction;

범위 있는 열거형 enum class는 열거자를 열거형 범위 안에 유지하며 정수로 암시적 변환되지 않는다.

enum class Status : unsigned char {
    Idle,
    Running,
    Finished
};

Status status = Status::Running;

// int value = status; // 오류

필요한 경우 명시적으로 기반 타입으로 변환할 수 있다.

int value = static_cast<int>(status);

열거형의 기반 타입을 지정하면 저장 표현과 외부 인터페이스를 더 명확하게 관리할 수 있다.

타입 별칭

using과 typedef는 기존 타입에 별칭을 부여한다. 새로운 별개의 타입을 만드는 것은 아니다.

using UserId = unsigned long long;

UserId first = 100;
unsigned long long second = first;

UserId와 unsigned long long은 같은 타입이다. 서로 다른 논리적 의미를 컴파일러가 구별하게 하려면 별도의 클래스 타입을 정의할 수 있다.

class UserId {
    unsigned long long value_;

public:
    explicit UserId(unsigned long long value)
        : value_(value)
    {
    }

    unsigned long long value() const
    {
        return value_;
    }
};

class ProductId {
    unsigned long long value_;

public:
    explicit ProductId(unsigned long long value)
        : value_(value)
    {
    }
};

이제 UserId와 ProductId는 저장 표현이 비슷하더라도 서로 다른 타입이다.

불완전 타입

크기와 전체 정의가 아직 알려지지 않은 타입을 불완전 타입이라고 한다. void, 경계가 알려지지 않은 배열과 선언만 된 클래스 등이 이에 해당한다.

class Renderer;

Renderer* create_renderer();
void destroy_renderer(Renderer* renderer);

Renderer의 전체 정의가 없어도 포인터나 참조를 선언할 수 있다. 그러나 객체를 직접 만들거나 sizeof를 적용하려면 완전한 정의가 필요하다.

class Renderer;

// Renderer renderer;          // 오류
// sizeof(Renderer);           // 오류

Renderer* pointer = nullptr;   // 가능
Renderer& get_renderer();      // 가능

전방 선언은 헤더 의존성을 줄이고 구현 세부 사항을 숨기는 데 사용된다.

// window.hpp

#include <memory>

class Window {
    class Impl;

    std::unique_ptr<Impl> impl_;

public:
    Window();
    ~Window();

    void show();
};

Impl의 정의는 소스 파일에 둘 수 있다.

// window.cpp

#include "window.hpp"

class Window::Impl {
public:
    void show_native_window()
    {
    }
};

Window::Window()
    : impl_(std::make_unique<Impl>())
{
}

Window::~Window() = default;

void Window::show()
{
    impl_->show_native_window();
}

const와 volatile

C++는 타입에 const와 volatile 한정자를 적용할 수 있다. 두 한정자를 합쳐 cv 한정자라고 한다.^[31]

const

const로 한정된 객체는 해당 경로를 통해 수정할 수 없다.

const int value = 42;

// value = 100; // 오류

const는 객체 자체의 불변성을 항상 보장하는 전역적인 속성이 아니라, 특정 타입과 접근 경로에 적용되는 한정이다.

int value = 42;
const int* pointer = &value;

// *pointer = 100; // 오류

value = 100; // 다른 비 const 경로에서는 수정 가능

포인터에서는 포인터 자체와 가리키는 대상에 각각 const를 적용할 수 있다.

int first = 10;
int second = 20;

const int* pointer_to_const = &first;
int* const const_pointer = &first;
const int* const const_pointer_to_const = &first;

각 선언의 의미는 다음과 같다.

클래스의 const 멤버 함수는 const 객체에서도 호출할 수 있으며, 기본적으로 비정적 데이터 멤버를 수정할 수 없다.

class Counter {
    int value_ = 0;

public:
    int value() const
    {
        return value_;
    }

    void increment()
    {
        ++value_;
    }
};

const Counter counter;

int value = counter.value();

// counter.increment(); // 오류

논리적으로 객체의 외부 상태를 바꾸지 않는 캐시나 동기화 도구는 mutable로 선언할 수 있다.

#include <mutex>

class Cache {
    mutable std::mutex mutex_;
    mutable bool initialized_ = false;
    mutable int value_ = 0;

public:
    int value() const
    {
        std::lock_guard lock(mutex_);

        if (!initialized_) {
            value_ = 42;
            initialized_ = true;
        }

        return value_;
    }
};

volatile

volatile은 해당 객체에 대한 접근이 구현체가 관찰해야 하는 부수 효과일 수 있음을 나타낸다.

volatile unsigned int register_value = 0;

일반적인 컴파일러는 volatile 객체에 대한 읽기와 쓰기를 불필요한 일반 메모리 접근처럼 제거하지 않는다. 이 특성은 구현체가 지원하는 메모리 매핑 장치 레지스터나 신호 처리와 같은 제한된 상황에서 사용될 수 있다.

volatile unsigned int* const device_status =
    reinterpret_cast<volatile unsigned int*>(0x4000'0000);

unsigned int status = *device_status;

정확한 하드웨어 주소와 접근 의미는 C++ 표준이 아니라 대상 플랫폼과 구현체가 정의한다.

volatile은 스레드 동기화 수단이 아니다. 여러 스레드가 같은 일반 volatile 객체를 동시에 수정해도 원자성이나 메모리 순서가 보장되지 않는다.

volatile int counter = 0;

// 여러 스레드에서 ++counter를 실행해도 안전하지 않다.

스레드 간 공유 상태에는 std::atomic이나 뮤텍스 같은 동기화 수단을 사용한다.

#include <atomic>

std::atomic<int> counter = 0;

void increment()
{
    counter.fetch_add(1, std::memory_order_relaxed);
}

타입 동일성과 별칭

두 선언에 사용된 타입 별칭의 이름이 달라도 최종적으로 같은 타입을 가리키면 같은 타입으로 취급된다.

using Integer = int;
using Count = Integer;

static_assert(
    std::is_same_v<Count, int>
);

반면 구조가 같은 두 클래스는 서로 다른 타입이다.

struct First {
    int value;
};

struct Second {
    int value;
};

// First와 Second는 서로 다른 타입이다.

C++의 클래스와 열거형은 주로 선언된 이름과 정의에 의해 구별되는 명목적 타입이다. 멤버 구성이 우연히 같다고 해서 서로 대입할 수 있는 구조적 타입으로 취급되지 않는다.

First first {42};

// Second second = first; // 오류

필요한 변환은 생성자나 변환 함수를 통해 명시적으로 정의할 수 있다.

struct Second {
    int value;

    explicit Second(const First& first)
        : value(first.value)
    {
    }
};

Second second(first);

타입 변환

타입 변환은 표현식의 값을 다른 타입의 값으로 해석하거나 변환하는 과정이다. C++에는 암시적 변환과 명시적 변환이 있으며, 변환의 종류와 우선순위는 함수 오버로딩과 템플릿 선택에도 영향을 준다.^[32]

암시적 변환

암시적 변환은 대입, 초기화, 함수 인자 전달, 반환과 연산자 적용 과정에서 별도의 캐스트 없이 수행된다.

int integer = 42;
double real = integer;

integer의 값은 double로 변환되어 real을 초기화한다.

정수 승격

bool, char, signed char, unsigned char, short 등의 좁은 정수 타입은 많은 산술 연산에서 int 또는 unsigned int로 승격된다.

unsigned char left = 200;
unsigned char right = 100;

auto result = left + right;

result의 타입은 일반적으로 unsigned char가 아니라 int다.

#include <type_traits>

static_assert(
    std::is_same_v<decltype(result), int>
);

일반적인 산술 변환

서로 다른 산술 타입이 하나의 연산에 참여하면 공통 타입을 결정하기 위한 변환이 수행된다.

int count = 3;
double scale = 0.5;

auto result = count * scale;

count가 double로 변환되므로 result의 타입은 double이다.

축소 변환

더 넓은 범위나 정밀도의 타입을 더 좁은 타입으로 변환하면 정보가 손실될 수 있다.

double real = 3.75;
int integer = real;

integer에는 소수 부분이 제거된 3이 저장된다.

중괄호 초기화는 여러 축소 변환을 컴파일 오류로 막는다.

double real = 3.75;

// int value {real}; // 오류: 축소 변환

컴파일 시 값이 정확히 표현될 수 있는 상수인 경우 일부 변환은 허용된다.

constexpr int value = 100;

unsigned char byte {value};

포인터 변환

파생 클래스 객체를 가리키는 포인터는 접근 가능한 기반 클래스 포인터로 변환될 수 있다.

class Base {
public:
    virtual ~Base() = default;
};

class Derived : public Base {
};

Derived derived;
Base* base = &derived;

객체 포인터는 void*로 변환될 수 있다.

int value = 42;

int* typed = &value;
void* raw = typed;

nullptr는 모든 포인터 타입의 널 포인터 값으로 변환될 수 있다.

int* object_pointer = nullptr;
void (*function_pointer)() = nullptr;

사용자 정의 변환

클래스는 단일 인자 생성자와 변환 함수를 통해 사용자 정의 변환을 제공할 수 있다.

class Distance {
    double meters_;

public:
    Distance(double meters)
        : meters_(meters)
    {
    }
};

Distance distance = 10.0;

이 생성자는 double에서 Distance로 암시적 변환을 허용한다.

암시적 변환을 원하지 않으면 explicit를 사용한다.

class Distance {
    double meters_;

public:
    explicit Distance(double meters)
        : meters_(meters)
    {
    }
};

// Distance distance = 10.0; // 오류
Distance distance(10.0);

변환 연산자는 클래스 객체를 다른 타입으로 변환할 수 있다.

class Handle {
    int value_;

public:
    explicit Handle(int value)
        : value_(value)
    {
    }

    explicit operator bool() const
    {
        return value_ >= 0;
    }
};

explicit operator bool은 조건 문맥에서는 사용할 수 있지만 일반적인 정수 변환으로 연쇄되지는 않는다.

Handle handle(10);

if (handle) {
}

// int value = handle; // 오류

명시적 캐스트

C++는 목적에 따라 구분된 네 가지 명명된 캐스트를 제공한다.

static_cast

double real = 3.75;
int integer = static_cast<int>(real);

열거형과 기반 정수 타입 사이의 변환에도 사용할 수 있다.

enum class Mode {
    Windowed = 1,
    Fullscreen = 2
};

int value = static_cast<int>(Mode::Fullscreen);

dynamic_cast

dynamic_cast는 다형적 클래스 계층에서 실제 객체 타입을 검사한다.

class Base {
public:
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void run()
    {
    }
};

void process(Base* base)
{
    if (Derived* derived = dynamic_cast<Derived*>(base)) {
        derived->run();
    }
}

포인터 변환에 실패하면 널 포인터를 반환한다. 참조 변환에 실패하면 std::bad_cast 예외를 던진다.

const_cast

const_cast는 타입의 const 또는 volatile 한정을 변경한다.

void legacy_api(char* text);

void call_legacy(const char* text)
{
    legacy_api(const_cast<char*>(text));
}

원래 객체가 실제로 const라면 한정을 제거한 포인터를 통해 수정하는 동작은 정의되지 않는다.

const int value = 42;

int* pointer = const_cast<int*>(&value);

// *pointer = 100;
// 실제 const 객체를 수정하므로 동작이 정의되지 않는다.

reinterpret_cast

reinterpret_cast는 포인터와 정수, 서로 다른 포인터 타입 등 저수준 표현 사이의 변환에 사용된다.

#include <cstdint>

int value = 42;
int* pointer = &value;

std::uintptr_t address =
    reinterpret_cast<std::uintptr_t>(pointer);

변환이 문법적으로 허용된다고 해서 변환된 타입을 통해 객체를 안전하게 읽을 수 있다는 뜻은 아니다. 정렬, 객체 수명, 표현 형식과 별칭 규칙을 함께 만족해야 한다.

타입 추론

C++는 변수 선언, 함수 반환형, 템플릿 인자와 클래스 템플릿 인자를 문맥에서 추론할 수 있다. 타입 추론은 동적 타입을 부여하는 기능이 아니라, 컴파일러가 정적 타입을 계산해 대신 작성하는 기능이다.

auto

auto는 초기화 표현식으로부터 변수의 타입을 추론한다.

auto integer = 42;
auto real = 3.14;
auto text = "C++";

추론 결과는 각각 int, double, const char*다.

#include <type_traits>

static_assert(
    std::is_same_v<decltype(integer), int>
);

static_assert(
    std::is_same_v<decltype(real), double>
);

static_assert(
    std::is_same_v<decltype(text), const char*>
);

일반 auto 추론은 템플릿 인자 추론과 유사하게 최상위 const와 참조를 제거할 수 있다.

const int value = 42;
const int& reference = value;

auto first = value;
auto second = reference;

first와 second의 타입은 모두 int다.

const와 참조를 유지하려면 선언에 직접 작성한다.

const auto& first = value;
auto& second = value;

배열도 일반 auto 변수에서는 포인터로 변환된다.

int values[3] {1, 2, 3};

auto pointer = values;
auto& array = values;

pointer는 int*, array는 int (&)[3] 타입이다.

decltype

decltype은 표현식의 타입과 값 범주를 바탕으로 타입을 계산한다.

int value = 42;

decltype(value) first = 10;
decltype((value)) second = value;

괄호 없는 이름 표현식 decltype(value)는 선언된 타입인 int를 얻는다. 괄호를 추가한 decltype((value))는 lvalue 표현식의 규칙에 따라 int&가 된다.

#include <type_traits>

static_assert(
    std::is_same_v<decltype(value), int>
);

static_assert(
    std::is_same_v<decltype((value)), int&>
);

decltype(auto)는 반환 표현식의 타입과 값 범주를 더 직접적으로 보존할 때 사용한다.

int global_value = 42;

decltype(auto) get_value()
{
    return (global_value);
}

괄호 때문에 반환 표현식이 lvalue이며, 함수의 반환형은 int&가 된다.

함수 반환형 추론

함수 반환형에 auto를 사용하면 반환문으로부터 타입을 추론한다.

auto add(int left, int right)
{
    return left + right;
}

여러 반환문이 있다면 추론되는 타입이 서로 일치해야 한다.

auto select(bool condition)
{
    if (condition) {
        return 10;
    }

    // return 20.0;
    // int와 double이 서로 달라 오류가 발생한다.

    return 20;
}

후행 반환형은 매개변수 이름을 반환형 계산에 사용할 때 유용하다.

template<class Left, class Right>
auto multiply(const Left& left, const Right& right)
    -> decltype(left * right)
{
    return left * right;
}

템플릿 인자 추론

함수 템플릿을 호출하면 함수 인자와 매개변수 타입을 비교해 템플릿 인자를 추론한다.^[33]

template<class T>
T maximum(T left, T right)
{
    return left < right ? right : left;
}

int integer = maximum(10, 20);
double real = maximum(1.5, 2.5);

첫 번째 호출에서는 T가 int, 두 번째 호출에서는 double로 추론된다.

두 인자가 서로 다른 타입이면 하나의 T를 일관되게 추론할 수 없다.

// auto value = maximum(10, 20.5);
// 첫 번째 인자에서는 int, 두 번째에서는 double이 추론되어 충돌한다.

서로 다른 타입을 허용하도록 템플릿 매개변수를 분리할 수 있다.

#include <type_traits>

template<class Left, class Right>
auto maximum(Left left, Right right)
    -> std::common_type_t<Left, Right>
{
    using Result = std::common_type_t<Left, Right>;

    return left < right
        ? static_cast<Result>(right)
        : static_cast<Result>(left);
}

전달 참조

함수 템플릿에서 추론되는 T&&는 특정 조건에서 lvalue와 rvalue를 모두 받을 수 있는 전달 참조가 된다.

template<class T>
void forward_value(T&& value)
{
}

lvalue를 전달하면 T는 lvalue 참조로 추론되고, 참조 축약 규칙에 의해 최종 매개변수 타입도 lvalue 참조가 된다.

int value = 42;

forward_value(value);
forward_value(42);

원래 값 범주를 다른 함수로 전달하려면 std::forward를 사용한다.

#include <utility>

template<class T>
void relay(T&& value)
{
    consume(std::forward<T>(value));
}

클래스 템플릿 인자 추론

C++17부터 생성자 인자로부터 클래스 템플릿 인자를 추론할 수 있다.

#include <pair>
#include <vector>

std::pair pair(10, 20.5);

pair의 타입은 std::pair<int, double>로 추론된다.

사용자 정의 클래스에도 추론 가이드를 작성할 수 있다.

#include <string>

template<class T>
class Box {
    T value_;

public:
    explicit Box(T value)
        : value_(std::move(value))
    {
    }
};

Box(const char*) -> Box<std::string>;

Box first(42);
Box second("C++");

first는 Box<int>, second는 명시한 추론 가이드에 따라 Box<std::string>이 된다.

템플릿 매개변수와 타입 의존성

템플릿은 타입, 상수 값과 다른 템플릿을 매개변수로 받을 수 있다.

#include <array>
#include <cstddef>

template<
    class T,
    std::size_t Size,
    template<class, std::size_t> class Container
>
class Storage;

일반적으로 다음 세 종류로 나뉜다.

• 타입 템플릿 매개변수
• 상수 템플릿 매개변수
• 템플릿 템플릿 매개변수

타입 템플릿 매개변수

template<class T>
class Box {
    T value_;
};

class 대신 typename을 사용할 수 있다.

template<typename T>
class Box {
    T value_;
};

이 문맥에서 class와 typename의 의미는 같다.

상수 템플릿 매개변수

상수 템플릿 매개변수는 컴파일 시간 값을 타입 구성에 포함한다.

#include <cstddef>

template<class T, std::size_t Size>
class FixedBuffer {
    T data_[Size];
};

FixedBuffer<int, 16> buffer;

FixedBuffer<int, 16>과 FixedBuffer<int, 32>는 서로 다른 타입이다.

FixedBuffer<int, 16> first;
FixedBuffer<int, 32> second;

// first = second; // 서로 다른 타입

템플릿 템플릿 매개변수

템플릿 자체를 매개변수로 받을 수도 있다.

#include <memory>
#include <vector>

template<
    class T,
    template<class, class> class Container
>
class Collection {
    Container<T, std::allocator<T>> values_;
};

Collection<int, std::vector> collection;

의존 타입

템플릿 안에서 템플릿 매개변수에 따라 달라지는 타입을 의존 타입이라고 한다.

template<class Container>
void process(const Container& container)
{
    typename Container::value_type value {};
}

Container::value_type이 타입이라는 사실은 템플릿 정의 시점에 확정되지 않으므로 typename을 붙인다.

의존 객체를 통해 멤버 템플릿을 호출할 때는 template 구분자가 필요할 수 있다.

template<class Object>
void call(Object& object)
{
    object.template convert<int>();
}

개념과 제약 조건

템플릿은 본래 사용된 연산이 인스턴스화 과정에서 유효한지를 검사했다. C++20의 개념과 requires는 템플릿 인자가 충족해야 하는 요구 사항을 명시적으로 표현한다.^[34]

표준 개념

표준 라이브러리는 타입 관계와 연산 가능성을 표현하는 여러 개념을 제공한다.

#include <concepts>

template<std::integral T>
T double_value(T value)
{
    return value * 2;
}

이 함수는 정수 개념을 만족하는 타입만 허용한다.

int integer = double_value(10);
unsigned int natural = double_value(20U);

// double real = double_value(1.5);
// std::integral을 만족하지 않아 오류

여러 개념을 조합할 수 있다.

#include <concepts>

template<class T>
concept Number =
    std::integral<T> ||
    std::floating_point<T>;

template<Number T>
T square(T value)
{
    return value * value;
}

requires 표현식

requires 표현식은 특정 문법과 연산이 유효한지를 검사한다.

#include <concepts>

template<class T>
concept Addable = requires(T left, T right) {
    left + right;
};

표현식의 반환 타입까지 제한할 수 있다.

template<class T>
concept Ordered = requires(T left, T right) {
    { left < right } -> std::convertible_to<bool>;
};

중첩 요구 사항을 사용할 수도 있다.

#include <type_traits>

template<class T>
concept SmallObject = requires {
    requires sizeof(T) <= 16;
    requires std::is_trivially_copyable_v<T>;
};

requires 절

함수 선언 뒤에 requires 절을 붙일 수 있다.

#include <concepts>

template<class T>
T add(T left, T right)
    requires std::integral<T>
{
    return left + right;
}

앞쪽에 배치할 수도 있다.

template<class T>
requires std::floating_point<T>
T average(T left, T right)
{
    return (left + right) / static_cast<T>(2);
}

제약된 자리표시자 타입

auto에 개념을 적용해 변수나 함수 매개변수의 추론 타입을 제한할 수 있다.

#include <concepts>

std::integral auto count = 42;
std::floating_point auto ratio = 0.5;

함수 매개변수에 사용하면 축약 함수 템플릿이 된다.

#include <concepts>

auto multiply(
    std::integral auto left,
    std::integral auto right
)
{
    return left * right;
}

이는 개념적으로 별도의 템플릿 매개변수를 가진 함수 템플릿과 유사하다.

template<std::integral Left, std::integral Right>
auto multiply(Left left, Right right)
{
    return left * right;
}

개념은 단순한 문서용 주석이 아니다. 오버로드 후보 선택과 템플릿 부분 순서 결정에 참여한다.

#include <concepts>
#include <string>

template<class T>
std::string describe(const T&)
{
    return "value";
}

template<std::integral T>
std::string describe(const T&)
{
    return "integer";
}

정수 타입을 전달하면 더 구체적으로 제약된 오버로드가 선택된다.

타입 특성과 컴파일 시간 검사

표준 라이브러리의 <type_traits>는 타입의 분류와 속성을 검사하고, 새로운 타입으로 변환하기 위한 템플릿을 제공한다.^[35]

타입 분류

#include <type_traits>

static_assert(std::is_integral_v<int>);
static_assert(std::is_floating_point_v<double>);
static_assert(std::is_pointer_v<int*>);
static_assert(std::is_reference_v<int&>);
static_assert(std::is_class_v<std::string>);

타입 관계

#include <type_traits>

class Base {
};

class Derived : public Base {
};

static_assert(std::is_same_v<int, int>);
static_assert(!std::is_same_v<int, long>);
static_assert(std::is_base_of_v<Base, Derived>);
static_assert(std::is_convertible_v<Derived*, Base*>);

타입 변환 특성

#include <type_traits>

using First = std::remove_const_t<const int>;
using Second = std::remove_reference_t<int&>;
using Third = std::add_pointer_t<double>;

static_assert(std::is_same_v<First, int>);
static_assert(std::is_same_v<Second, int>);
static_assert(std::is_same_v<Third, double*>);

참조와 cv 한정을 모두 제거하려면 std::remove_cvref_t를 사용할 수 있다.

#include <type_traits>

using Type =
    std::remove_cvref_t<const int&>;

static_assert(std::is_same_v<Type, int>);

호출 가능성 검사

#include <type_traits>

int add(int left, int right)
{
    return left + right;
}

static_assert(
    std::is_invocable_v<
        decltype(add),
        int,
        int
    >
);

static_assert(
    std::is_invocable_r_v<
        int,
        decltype(add),
        int,
        int
    >
);

static_assert

static_assert는 타입 관계와 컴파일 시간 조건을 검증한다.

#include <cstdint>
#include <type_traits>

struct PacketHeader {
    std::uint16_t type;
    std::uint16_t size;
};

static_assert(
    std::is_trivially_copyable_v<PacketHeader>
);

static_assert(
    sizeof(PacketHeader) == 4
);

두 번째 검사는 대상 ABI의 패딩과 타입 크기에 의존하므로, 외부 바이너리 형식과 연결할 때는 플랫폼 요구 사항을 함께 명시해야 한다.

타입 안전성과 저수준 제어

C++의 정적 타입 체계는 잘못된 함수 호출, 호환되지 않는 대입과 허용되지 않는 연산을 번역 시점에 탐지한다.

#include <string>

void set_count(int count);

set_count(10);

// set_count(std::string("ten"));
// 변환할 수 없는 타입이므로 오류

클래스와 열거형을 사용하면 서로 다른 개념을 타입 수준에서 분리할 수 있다.

struct Meters {
    double value;
};

struct Seconds {
    double value;
};

Meters distance {100.0};
Seconds time {10.0};

// distance = time; // 서로 다른 타입

동시에 C++는 포인터 변환, 공용체, 수동 객체 수명 관리와 reinterpret_cast 같은 저수준 기능도 제공한다. 이러한 기능은 운영체제, 드라이버, 직렬화, 외부 ABI와 메모리 관리 구현에 활용할 수 있지만, 타입 체계가 일반적으로 제공하는 검사를 일부 우회한다.

#include <cstddef>
#include <span>

void inspect_bytes(
    std::span<const std::byte> bytes
)
{
}

struct Header {
    int type;
    int size;
};

Header header {1, 128};

auto bytes = std::as_bytes(
    std::span(&header, 1)
);

inspect_bytes(bytes);

객체의 바이트 표현을 읽기 위해서는 임의의 포인터 재해석보다 std::as_bytes, std::bit_cast, std::memcpy와 같이 의도가 명확한 표준 기능을 사용할 수 있다.

#include <bit>
#include <cstdint>

float value = 1.0F;

std::uint32_t bits =
    std::bit_cast<std::uint32_t>(value);

std::bit_cast는 원본과 대상 타입의 크기가 같고 요구 조건을 만족할 때 객체 표현의 비트를 새 타입의 값으로 복사한다.

C++의 타입 체계는 고수준의 추상화와 저수준 메모리 접근을 하나의 언어 안에서 제공한다. 타입 추론과 템플릿을 사용해 반복적인 타입 표기를 줄일 수 있지만, 최종 타입은 여전히 컴파일 시점에 확정된다. 개념과 타입 특성을 사용하면 템플릿이 요구하는 연산과 속성을 명시할 수 있으며, 클래스와 강한 래퍼 타입을 사용하면 프로그램의 논리적 개념을 서로 구분된 타입으로 표현할 수 있다.