C++11

C++11에서 도입된 auto 키워드는 변수 선언 시 컴파일러가 초기화 표현식의 타입을 자동으로 추론하도록 지시한다. 이는 특히 복잡한 타입 이름을 명시적으로 작성하는 번거로움을 줄여준다. 예를 들어, 표준 템플릿 라이브러리의 반복자나 람다 표현식의 타입과 같이 길고 복잡한 타입을 auto로 간결하게 대체할 수 있다.

auto의 사용은 코드의 가독성을 높이고 유지보수를 용이하게 하는 장점이 있다. 템플릿 프로그래밍에서 타입이 템플릿 매개변수에 의존하는 경우, auto를 사용하면 정확한 타입 이름을 몰라도 변수를 선언할 수 있다. 또한 범위 기반 for 루프와 함께 사용될 때 컨테이너 요소의 타입을 명시하지 않고 간편하게 순회할 수 있다.

그러나 auto의 사용에는 주의가 필요하다. 타입 추론은 초기화 표현식에 전적으로 의존하므로, 초기화되지 않은 auto 변수는 선언할 수 없다. 또한 프로그래머의 의도와 다른 타입으로 추론될 가능성이 있어, 코드의 명확성을 해치지 않도록 상황에 맞게 사용해야 한다. auto는 타입을 생략하는 것이지, 동적 타입이나 약타입을 의미하는 것은 아니다.

범위 기반 for 루프는 C++11에서 도입된 새로운 반복문 구문이다. 이 기능은 컨테이너나 배열과 같은 요소들의 시퀀스를 순회하는 코드를 간결하고 안전하게 작성할 수 있게 해준다. 기존의 인덱스 변수나 반복자를 명시적으로 사용하는 방식보다 훨씬 직관적이며, 실수로 인한 오류 가능성을 줄여준다.

이 루프의 기본 형식은 for (요소선언 : 범위표현식) 이다. 여기서 '범위표현식'은 순회 가능한 객체(예: std::vector, std::list, C 스타일 배열)이며, '요소선언'은 범위 내 각 요소의 타입과 이름을 선언한다. 컴파일러는 내부적으로 반복자를 사용하여 순회를 수행하지만, 프로그래머는 복잡한 반복자 조작 없이도 각 요소에 직접 접근할 수 있다.

범위 기반 for 루프는 STL의 모든 표준 컨테이너와 함께 사용할 수 있을 뿐만 아니라, 사용자 정의 타입도 begin() 및 end() 멤버 함수나 ADL을 통한 자유 함수를 제공하면 이 루프와 호환되도록 만들 수 있다. 이는 제네릭 프로그래밍과 템플릿 라이브러리 작성 시 큰 장점이 된다.

이 기능의 도입으로 C++ 코드의 가독성이 크게 향상되었으며, 특히 알고리즘 구현이나 데이터 처리를 위한 루프 문장을 작성할 때 널리 사용된다. 이는 C++11이 언어의 실용성과 현대성을 높이는 데 기여한 대표적인 사례 중 하나로 꼽힌다.

C++11에서 도입된 람다 표현식은 이름 없는 함수 객체를 간결하게 정의할 수 있는 기능이다. 익명 함수라고도 불리는 이 기능은 주로 알고리즘 함수의 인자로 사용되거나, 일회성의 간단한 연산을 캡슐화하는 데 유용하다. 기존에는 별도의 함수나 함수 객체를 정의해야 했던 상황을 한 줄의 코드로 대체할 수 있어 코드의 가독성과 생산성을 크게 향상시켰다.

람다 표현식의 기본 구문은 캡처 절, 매개변수 목록, 반환 타입, 함수 본문으로 구성된다. 캡처 절 []은 람다가 자신을 둘러싼 범위의 변수에 어떻게 접근할지를 결정하며, 값에 의한 캡처와 참조에 의한 캡처를 지원한다. auto 키워드와 함께 사용되면 특히 강력한 표현력을 발휘하여, 복잡한 타입을 명시하지 않고도 함수 객체를 생성할 수 있다.

이 기능은 C++의 표준 라이브러리 알고리즘, 특히 <algorithm> 헤더의 std::sort, std::for_each, std::transform 등과 함께 사용될 때 빛을 발한다. 사용자는 정렬 기준이나 변환 연산을 인라인으로 정의할 수 있어, 코드의 의도를 더 명확하게 전달할 수 있다. 또한 스레드 지원 라이브러리에서 새 스레드에 실행 코드를 전달할 때도 람다가 널리 활용된다.

람다 표현식의 도입은 C++의 함수형 프로그래밍 패러다임을 강화하는 중요한 계기가 되었다. 이를 통해 C++는 여전히 저수준 시스템 프로그래밍의 강점을 유지하면서도, 현대적인 고수준 추상화를 표현하는 데 필요한 도구를 확보하게 되었다.

C++11에서 도입된 스마트 포인터는 동적 메모리 할당으로 생성된 객체의 수명을 자동으로 관리하여 메모리 누수와 댕글링 포인터 문제를 해결하는 핵심 기능이다. 이들은 <memory> 헤더에 정의되어 있으며, RAII 패턴을 구현하여 자원 관리를 용이하게 한다.

주요 스마트 포인터로는 std::unique_ptr, std::shared_ptr, std::weak_ptr가 있다. std::unique_ptr는 특정 메모리 자원에 대한 독점적 소유권을 가지며, 복사가 불가능하고 이동만 가능하다. 이는 자원의 소유권 이전을 명확히 하고, 소멸 시점에 자동으로 메모리를 해제하도록 보장한다. std::shared_ptr는 참조 카운팅 방식을 사용하여 하나의 자원을 여러 포인터가 공유할 수 있게 한다. 자원을 참조하는 shared_ptr의 수가 0이 되면 메모리가 자동으로 해제된다. std::weak_ptr는 shared_ptr가 관리하는 자원에 대한 약한 참조로, 참조 카운트에 영향을 주지 않는다. 이는 순환 참조를 방지하기 위해 shared_ptr와 함께 사용된다.

이러한 스마트 포인터의 도입은 C++에서 메모리 안전성을 크게 향상시켰다. 개발자가 명시적으로 delete를 호출할 필요가 줄어들어 코드의 안정성이 높아졌고, 예외 안전성을 보장하기 쉬워졌다. 특히 std::unique_ptr는 성능 오버헤드가 거의 없어 기존의 날(raw) 포인터를 대체하는 데 널리 사용되며, std::shared_ptr와 std::weak_ptr는 복잡한 객체 소유권 구조를 가진 대규모 소프트웨어나 프레임워크 개발에 유용하다.

• cppreference.com - 이동 의미론

• cppreference.com - 우측값 참조

• Microsoft Learn - 우측값 참조 선언자: &&

• Microsoft Learn - 이동 의미론

• modoocode.com - C++11 이야기: 우측값 참조와 이동 생성자

• 모두의 코드 - 우측값 레퍼런스

• IBM Documentation - 우측값 참조(C++11)

• Stack Overflow - What are move semantics?

• isocpp.org - A Brief Introduction to Rvalue References

• Bjarne Stroustrup's FAQ - What are rvalue references?

nullptr은 C++11에서 도입된 새로운 키워드로, 널 포인터 상수를 나타낸다. 이전까지 C++에서는 널 포인터를 표현하기 위해 매크로 NULL이나 정수 리터럴 0을 사용했으나, 이는 타입 안전성과 함수 오버로딩에서 모호함을 초래하는 문제가 있었다. nullptr은 이러한 문제를 해결하기 위해 도입된 타입 안전한 널 포인터 상수이다.

nullptr의 핵심 특징은 그 타입이 std::nullptr_t라는 독립된 타입이라는 점이다. 이 타입은 모든 종류의 포인터 타입(원시 포인터, 멤버 함수 포인터, 스마트 포인터 등)으로 암시적 변환이 가능하지만, 정수 타입으로는 변환되지 않는다. 이로 인해 함수 오버로딩 시 정수를 인자로 받는 함수와 포인터를 인자로 받는 함수가 있을 때, nullptr을 전달하면 의도한 대로 항상 포인터 버전의 함수가 호출되도록 보장한다.

이전의 NULL 매크로는 대부분 정수 0으로 정의되어 있어, 정수와 포인터 간의 모호한 상황을 만들어냈다. 예를 들어, func(int)와 func(char*)라는 두 함수가 오버로딩되어 있을 때 func(NULL)을 호출하면 컴파일러에 따라 func(int)가 호출될 수 있었다. nullptr을 사용하면 func(nullptr)은 항상 func(char*)를 호출하게 되어 프로그래머의 의도를 명확히 반영한다.

nullptr의 도입은 C++ 언어의 타입 시스템을 더욱 견고하게 만들었으며, 코드의 명확성과 안전성을 크게 향상시켰다. 이는 템플릿 메타프로그래밍과 제네릭 프로그래밍에서 특히 유용하게 활용되며, 현대 C++ 프로그래밍에서 널 포인터를 표현하는 표준적인 방법으로 자리 잡았다.

constexpr는 C++11에서 도입된 키워드로, 컴파일 타임에 값을 계산하거나 평가될 수 있음을 지정하는 데 사용된다. 이 키워드는 변수, 함수, 생성자 등에 적용할 수 있으며, 이를 통해 상수 표현식의 범위를 확장하고 컴파일 타임 계산을 보장한다.

constexpr 변수는 반드시 컴파일 타임에 초기화되어야 하며, 그 값은 변경할 수 없다. 이는 기존의 const와 유사하지만, 초기화에 사용되는 식이 컴파일 타임 상수 표현식이어야 한다는 점에서 더 엄격한 요구사항을 가진다. 예를 들어, constexpr int size = 10;과 같이 선언하면 size는 컴파일 시점에 결정된 상수로 사용될 수 있다.

constexpr 함수는 컴파일 타임에 실행될 수 있는 함수를 정의한다. 이러한 함수는 제한된 문장만을 포함할 수 있으며, 인자가 컴파일 타임 상수일 때 그 결과도 컴파일 타임 상수가 된다. 이는 템플릿 메타프로그래밍의 복잡성을 줄이고, 배열 크기나 템플릿 인자와 같이 컴파일 타임에 값이 필요한 다양한 상황에서 유용하게 활용된다.

C++14와 C++17에서는 constexpr의 기능이 더욱 확장되어, 함수 내에서 루프와 조건문 사용이 자유로워지고, 가상 함수나 람다 표현식에도 적용할 수 있게 되었다. 이러한 발전은 템플릿 메타프로그래밍의 필요성을 줄이고, 보다 직관적인 코드로 컴파일 타임 계산을 수행할 수 있는 길을 열었다.

C++11은 변수, 객체, 배열, STL 컨테이너 등 다양한 대상을 초기화하는 방법을 통일하고 단순화하기 위해 유니폼 초기화와 초기화자 목록 기능을 도입했다. 이전에는 기본 타입, 배열, 클래스 타입, 집합체 등에 따라 중괄호 {}, 괄호 (), 할당 = 등 서로 다른 초기화 문법이 혼재되어 있었다. 유니폼 초기화는 중괄호 {}를 사용하는 단일한 문법을 제공하여 이러한 혼란을 해소하고, 초기화 과정에서 발생할 수 있는 데이터 손실(예: 형 변환으로 인한 값 잘림)을 방지하는 이점을 제공한다.

초기화자 목록은 std::initializer_list라는 새로운 템플릿 클래스 타입을 통해 구현된다. 이는 중괄호로 둘러싸인 값들의 목록을 함수나 생성자에 전달할 수 있게 해주며, 특히 컨테이너를 초기 값들로 채울 때 유용하다. 예를 들어, std::vector<int> v = {1, 2, 3, 4, 5};와 같이 벡터를 간결하게 선언하고 초기화할 수 있다. 사용자 정의 타입에서도 std::initializer_list를 매개변수로 받는 생성자를 정의함으로써 동일한 편의성을 누릴 수 있다.

이 기능들은 코드의 일관성과 가독성을 크게 향상시켰다. 특히 템플릿 메타프로그래밍이나 제네릭 프로그래밍과 같이 타입에 독립적인 코드를 작성할 때, 초기화 방식의 통일은 중요한 장점으로 작용한다. 다만, 유니폼 초기화 문법이 기존 생성자 호출과 충돌할 수 있는 경우(중괄호 초기화가 std::initializer_list 생성자를 우선시하는 등)가 있어 주의가 필요하다.

C++11에서 도입된 using 선언은 기존의 typedef와 유사하게 타입에 대한 별칭을 생성하는 기능을 제공하지만, 더 강력하고 직관적인 문법을 제공한다. typedef는 특히 템플릿과 함께 사용할 때 문법이 복잡해지는 경향이 있었으나, using은 템플릿 별칭을 지원하여 이 문제를 해결한다.

템플릿 별칭은 using의 가장 중요한 확장 기능이다. typedef로는 템플릿 매개변수를 부분적으로 특수화하거나 바인딩하는 별칭을 만들 수 없었지만, using 키워드를 사용하면 가능해진다. 이를 통해 복잡한 템플릿 타입 표현을 간결하고 재사용 가능한 이름으로 정의할 수 있어 코드의 가독성과 유지보수성이 크게 향상된다.

일반적인 타입 별칭 생성에도 typedef보다 using 선언이 더 명확한 문법을 가진다. typedef는 선언문에서 별칭 이름이 본래 타입 이름 뒤에 오는 반면, using 선언은 할당문처럼 별칭 이름을 왼쪽, 본래 타입을 오른쪽에 위치시킨다. 이는 변수 선언 방식과 유사하여 학습 곡선을 낮추고, 특히 함수 포인터와 같은 복합 타입을 정의할 때 그 장점이 두드러진다.

결과적으로, using 선언은 C++의 타입 시스템을 더욱 효율적으로 활용할 수 있게 하며, 템플릿 메타프로그래밍과 제네릭 프로그래밍을 지원하는 핵심 도구로 자리 잡았다. 현대 C++ 코드에서는 새로운 타입 별칭을 정의할 때 typedef보다 using을 사용하는 것이 권장되는 관행이 되었다.

정적 단언은 C++11에서 도입된 컴파일 타임 단언 기능이다. 이 기능은 컴파일러가 소스 코드를 컴파일하는 과정에서 특정 조건이 참인지 검사하며, 조건이 거짓일 경우 컴파일 오류를 발생시킨다. 이는 템플릿 메타프로그래밍이나 플랫폼 의존적인 코드를 작성할 때, 필요한 조건이 컴파일 시점에 만족되는지 보장하기 위해 사용된다.

static_assert의 기본 구문은 static_assert(상수_표현식, 오류_메시지) 형태이다. 첫 번째 인자인 상수 표현식은 부울로 평가될 수 있는 컴파일 타임 상수여야 하며, 이 값이 false로 평가되면 두 번째 인자로 제공된 문자열 리터럴이 컴파일 오류 메시지의 일부로 출력된다. 이를 통해 개발자는 템플릿이 특정 타입에 대해서만 인스턴스화되어야 하거나, 정수의 크기가 특정 값을 충족해야 하는 등의 제약을 명시적으로 표현할 수 있다.

이 기능은 특히 제네릭 프로그래밍에서 타입 특성을 검사하거나, 크로스 플랫폼 코드에서 데이터 타입의 크기를 검증하는 데 유용하다. 예를 들어, 특정 구조체의 크기가 항상 16바이트여야 하는 경우, static_assert를 사용하여 이 조건을 검증함으로써 메모리 정렬 문제나 이식성 문제를 초기에 발견할 수 있다.

static_assert는 런타임에 수행되는 assert 매크로와 달리 프로그램의 실행 성능에 전혀 영향을 주지 않으며, 오직 컴파일 타임에만 동작한다. 이는 C++ 표준 라이브러리의 타입 특성 라이브러리와 결합되어 광범위하게 활용되며, 이후 C++17 및 C++20 표준에서도 계속 개선되어 사용되고 있다.

C++11은 언어 차원에서 멀티스레딩을 지원하기 위한 라이브러리를 도입했다. 이전까지 C++에서 스레드를 사용하려면 운영체제에 종속적인 API(예: POSIX 스레드, 윈도우 API)나 서드파티 라이브러리를 사용해야 했으나, C++11부터는 표준 라이브러리에 포함된 <thread> 헤더를 통해 플랫폼 독립적인 스레드 생성과 관리가 가능해졌다.

이 라이브러리는 스레드의 기본적인 동작을 위한 핵심 클래스와 기능을 제공한다. std::thread 클래스를 사용하면 함수나 함수 객체, 람다 표현식을 실행하는 새로운 스레드를 쉽게 생성할 수 있다. 또한, 스레드 간의 동기화를 위해 뮤텍스 (std::mutex, std::recursive_mutex 등), 조건 변수 (std::condition_variable), 그리고 퓨처와 프라미스 (std::future, std::promise)를 이용한 비동기 작업 결과 통신 메커니즘도 표준으로 포함되었다.

이러한 표준화는 이식성을 크게 향상시켰다. 서로 다른 컴파일러와 플랫폼에서 동일한 스레드 관련 코드를 사용할 수 있게 되었으며, 데드락이나 경쟁 상태와 같은 일반적인 동시성 문제를 해결하기 위한 표준 도구를 제공하게 되었다. 특히 메모리 모델이 명시적으로 정의되면서, 여러 스레드가 공유 데이터에 접근할 때의 가시성과 순서 보장에 대한 기준이 마련되었다.

C++11의 스레드 지원 라이브러리는 고수준의 병렬 프로그래밍을 위한 기초를 닦았으며, 이후 C++14, C++17, C++20에서 병렬 알고리즘과 코루틴과 같은 더 진화된 동시성 기능이 추가되는 토대가 되었다.

C++11은 표준 라이브러리에 정규 표현식 처리를 위한 <regex> 헤더와 관련 클래스들을 도입했다. 이 라이브러리는 문자열에서 복잡한 패턴 매칭, 검색, 치환 작업을 수행할 수 있게 해주며, Perl, POSIX, ECMAScript 등 여러 정규 표현식 문법을 지원한다. 주요 클래스로는 패턴을 정의하는 basic_regex, 매칭 결과를 저장하는 match_results, 반복자 역할을 하는 regex_iterator와 regex_token_iterator 등이 있다.

이 라이브러리를 사용하면 기존의 C 스타일 문자열 함수나 수동 루프보다 훨씬 간결하고 강력하게 텍스트 처리 로직을 구현할 수 있다. 예를 들어, 이메일 주소나 URL 형식 검증, 로그 파일에서 특정 데이터 추출, 문자열 포맷팅 등의 작업에 활용된다. 라이브러리는 유니코드 문자열을 포함한 다양한 문자 타입(char, wchar_t)에 대해 템플릿화되어 있어 폭넓은 응용이 가능하다.

C++11 정규 표현식 라이브러리의 도입은 파싱과 텍스트 마이닝이 필요한 애플리케이션 개발을 용이하게 했으며, C++가 시스템 프로그래밍 외에도 스크립팅 언어들이 강점을 보이던 텍스트 처리 영역에서도 경쟁력을 갖추는 데 기여했다. 이는 C++ 표준 라이브러리가 현대 소프트웨어 개발의 실용적 요구를 반영하여 지속적으로 확장되고 있음을 보여주는 대표적인 사례이다.

C++11은 기존 표준 템플릿 라이브러리(STL)의 컨테이너 라인업을 보완하고 확장하여, 프로그래머에게 더욱 풍부하고 효율적인 데이터 구조 선택지를 제공한다. 새로 도입된 컨테이너들은 크게 정적 배열, 단방향 리스트, 그리고 해시 기반의 비순차 연관 컨테이너로 구분된다.

std::array는 C 스타일의 고정 크기 배열을 RAII 원칙에 따라 안전하게 감싼 래퍼 클래스이다. 기존의 std::vector와 달리 크기가 컴파일 타임에 고정되어 있으며, 스택에 할당되므로 동적 메모리 할당의 오버헤드가 없다. 이는 성능이 중요한 코드나 임베디드 시스템에서 유용하다. std::forward_list는 단일 연결 리스트를 구현한 컨테이너로, 각 요소가 다음 요소에 대한 포인터만을 가진다. std::list가 이중 연결 리스트라면, forward_list는 메모리 사용량이 더 적고 삽입 및 삭제 연산이 약간 더 빠르다는 특징이 있다. 다만, 역방향 순회는 지원하지 않는다.

가장 중요한 확장은 std::unordered_set, std::unordered_map, 그리고 그들의 멀티 버전과 중복 키 버전인 std::unordered_multiset, std::unordered_multimap으로 구성된 해시 테이블 기반의 비순차 연관 컨테이너 시리즈이다. 이들은 기존의 std::set이나 std::map과 달리 레드-블랙 트리 대신 해시 함수를 사용하여 요소를 저장하므로, 평균적인 경우 상수 시간(O(1))에 탐색, 삽입, 삭제가 가능하다. 이는 키의 순서를 보장하지 않는 대신, 대규모 데이터에서 빠른 조회 성능을 필요로 할 때 매우 효율적이다.

튜플은 C++11에서 표준 라이브러리에 새롭게 추가된 템플릿 클래스로, 서로 다른 타입의 객체들을 하나의 단일 객체로 묶어 관리할 수 있게 해준다. 이는 기존에 페어가 두 개의 값만을 저장할 수 있었던 것에서 확장된 개념으로, 임의의 개수와 타입의 요소들을 하나의 집합으로 다룰 수 있는 일반화된 도구이다.

튜플은 std::tuple 헤더를 포함하여 사용하며, std::make_tuple 함수를 통해 값을 담은 튜플 객체를 쉽게 생성할 수 있다. 튜플 내의 개별 요소에 접근하기 위해서는 std::get<인덱스>(튜플객체) 함수 템플릿을 사용하며, 컴파일 타임에 결정되는 정수형 템플릿 매개변수로 인덱스를 지정한다. 또한 std::tie를 사용하면 튜플의 요소들을 개별 변수에 한 번에 풀어서 할당하는 구조 분해가 가능하다.

튜플은 특히 함수가 여러 개의 값을 반환해야 할 때 유용하게 활용된다. 기존에는 구조체를 새로 정의하거나 참조 매개변수를 사용하는 등의 방법이 필요했지만, 튜플을 사용하면 별도의 타입 정의 없이도 편리하게 여러 타입의 값을 묶어 반환할 수 있다. 이는 제네릭 프로그래밍과 메타프로그래밍 코드를 작성할 때 강력한 유연성을 제공한다.

표준 라이브러리에는 튜플의 비교 연산(==, < 등)과 `std::tuple_size`, `std::tuple_element` 같은 타입 특성 질의 도구도 함께 제공되어, 튜플을 다양한 알고리즘과 라이브러리 기능과 함께 조화롭게 사용할 수 있도록 지원한다.

std::function은 C++11 표준 라이브러리에 도입된 함수 객체 래퍼 클래스 템플릿이다. 이는 호출 가능한 모든 대상을 일반화된 방식으로 저장하고, 복사하며, 호출할 수 있게 해주는 다형성 함수 래퍼를 제공한다. std::function을 사용하면 함수 포인터, 멤버 함수 포인터, 람다 표현식, 그리고 operator()를 오버로드한 모든 함수 객체를 동일한 타입으로 취급할 수 있어, 콜백 메커니즘과 이벤트 처리 시스템을 구현하는 데 매우 유용하다.

std::function의 주요 장점은 호출 가능 객체의 구체적인 타입을 감추고, 단일한 인터페이스 뒤에 추상화할 수 있다는 점이다. 이는 <functional> 헤더에 정의되어 있으며, 템플릿 인자로는 반환 타입과 매개변수 타입 목록을 받는다. 예를 들어, std::function<int(int, int)>는 두 개의 int를 받아 int를 반환하는 모든 호출 가능 객체를 저장할 수 있다. 이를 통해 런타임에 다른 종류의 함수 객체를 유연하게 교체하거나 컨테이너에 저장하는 것이 가능해진다.

std::function은 내부적으로 타입 지우기 기술을 사용하여 구현된다. 이는 템플릿 인스턴스화 시점에 알려진 구체적인 호출 가능 객체의 타입 정보를 감추고, 가상 함수 호출과 같은 메커니즘을 통해 실제 객체의 호출 연산을 수행한다. 따라서 사용 편의성과 유연성을 제공하지만, 약간의 오버헤드가 발생할 수 있다. 또한, std::function 객체가 비어 있을 때(즉, 호출 가능 대상을 가지고 있지 않을 때) 호출하면 std::bad_function_call 예외가 발생한다.

이 기능은 특히 디자인 패턴 중 전략 패턴이나 명령 패턴을 구현할 때, 그리고 표준 템플릿 라이브러리 알고리즘에 사용자 정의 연산을 전달할 때 광범위하게 활용된다. std::function의 등장으로 C++에서 고차 함수를 보다 안전하고 편리하게 사용할 수 있는 기반이 마련되었다.

위임 생성자는 C++11에서 도입된 기능으로, 하나의 생성자가 동일한 클래스 내의 다른 생성자를 호출하여 객체 초기화의 일부를 위임할 수 있게 한다. 이전 표준인 C++03에서는 생성자 간 코드 중복을 피하기 위해 별도의 초기화 함수를 만들어 호출해야 했으나, 위임 생성자를 통해 생성자 자체를 재사용하는 더 깔끔한 방법을 제공한다.

이 기능의 문법은 간단하다. 생성자의 초기화 리스트에서 다른 생성자를 호출하는 형태를 취한다. 이를 통해 공통적인 초기화 로직을 하나의 생성자에 집중시키고, 다른 생성자들은 특정 인자만 처리한 뒤 그 로직을 수행하는 생성자에게 초기화를 위임할 수 있다. 이는 코드의 유지보수성을 높이고 실수를 줄이는 데 기여한다.

위임 생성자는 생성자 오버로딩이 많은 클래스에서 특히 유용하다. 예를 들어, 다양한 매개변수 조합을 받는 여러 생성자들이 내부적으로 하나의 '기본' 생성자에게 실제 초기화 작업을 맡기는 구조를 만들 수 있다. 이때 위임받은 생성자의 실행이 완료된 후, 위임한 생성자의 본문이 추가로 실행된다는 점이 중요하다.

이 기능은 C++11의 여러 생산성 향상 기능 중 하나로, 이동 의미론이나 람다 표현식과 같은 큰 변화에 비해 주목받지 못했지만, 코드 품질을 높이는 실용적인 개선 사항이다. 이후 C++14 및 C++17에서도 계속 지원되며 표준 C++ 프로그래밍의 일반적인 기법으로 자리 잡았다.

상속 생성자는 파생 클래스가 기반 클래스의 생성자를 직접 상속하여 사용할 수 있게 하는 기능이다. C++11 이전에는 파생 클래스에서 기반 클래스의 생성자를 사용하려면 파생 클래스 생성자를 일일이 정의하고, 그 내부에서 기반 클래스 생성자를 명시적으로 호출해야 했다. 이는 특히 기반 클래스에 여러 생성자가 존재할 경우 중복 코드를 양산하는 원인이 되었다.

상속 생성자를 사용하면 using 선언을 통해 기반 클래스의 생성자를 파생 클래스의 생성자로 끌어올릴 수 있다. 구문은 using BaseClass::BaseClass;와 같이 간단하다. 이를 통해 파생 클래스는 기반 클래스가 가진 모든 생성자(오버로딩된 생성자 포함)를 마치 자신의 생성자인 것처럼 사용할 수 있게 된다. 이는 코드의 재사용성을 높이고 유지보수성을 개선한다.

파생 클래스에 새로운 멤버 변수가 추가된 경우, 상속된 생성자로는 이 새 멤버를 초기화할 수 없다. 이때는 파생 클래스에서 해당 생성자를 직접 정의하여 멤버 초기화 목록에서 새 멤버를 초기화하고, 기반 클래스 생성자를 위임 호출하는 방식으로 해결할 수 있다. 이는 위임 생성자 기능과 연계되어 사용된다.

이 기능은 특히 템플릿 메타프로그래밍과 제네릭 프로그래밍에서 유용하게 쓰인다. 기반 클래스가 템플릿으로 되어 있을 때, 파생 클래스에서 모든 생성자 버전을 자동으로 상속받을 수 있어 코드를 간결하게 유지하는 데 도움을 준다.

C++11에서는 특별한 멤버 함수의 생성과 삭제를 프로그래머가 명시적으로 제어할 수 있는 기능이 도입되었다. 이는 컴파일러가 특정 함수를 암시적으로 생성하는 기본 동작을 원하지 않을 때, 또는 특정 함수의 사용을 완전히 금지하고자 할 때 유용하다.

= default 지정자를 사용하면 컴파일러에게 해당 함수의 기본 구현을 생성하도록 지시할 수 있다. 이는 사용자 정의 생성자나 소멸자가 있어도, 특별한 멤버 함수(예: 복사 생성자, 이동 할당 연산자)의 기본 버전이 필요할 때 명시적으로 요청하는 데 사용된다. 반면, = delete 지정자는 해당 함수의 사용을 명시적으로 금지한다. 이는 의도하지 않은 객체 복사를 방지하거나, 특정 타입에 대해 원치 않는 함수 호출(예: int 타입에 대한 사용자 정의 리터럴 연산자)을 막는 데 활용된다.

이 기능은 특히 리소스 관리와 관련된 클래스 설계에서 중요하다. 예를 들어, 스마트 포인터와 같이 복사가 불가능해야 하는 객체는 복사 생성자와 복사 할당 연산자를 = delete로 선언하여 복사 시도를 컴파일 타임 오류로 만들 수 있다. 이는 C++03에서 사용되던 private 영역에 선언만 하고 정의는 제공하지 않는 방법보다 더 명확하고 직관적이다.

= default와 = delete 지정자는 이동 의미론과도 깊은 연관이 있다. 사용자가 이동 생성자나 이동 할당 연산자를 직접 정의하면, 컴파일러는 복사 연산을 위한 특별한 멤버 함수의 암시적 생성을 중단한다. 이 경우, 필요하다면 = default를 사용해 명시적으로 복사 연산을 기본 생성하도록 요청해야 한다. 이를 통해 객체의 복사 및 이동 동작에 대한 세밀한 제어가 가능해졌다.

override와 final 지정자는 C++11에서 도입된 키워드로, 가상 함수와 클래스 상속의 안전성과 명확성을 크게 향상시킨다. 이전 표준에서는 파생 클래스에서 기본 클래스의 가상 함수를 재정의할 때, 함수 시그니처(이름, 매개변수 타입, const 한정자 등)를 정확히 일치시키지 않으면 의도하지 않은 새로운 가상 함수가 생성되는 문제가 있었다. override 지정자는 이러한 실수를 방지하기 위해 컴파일러에게 명시적으로 재정의 의사를 알리는 역할을 한다.

override 지정자는 파생 클래스의 가상 함수 선언부 끝에 붙여 사용한다. 컴파일러는 이 지정자가 붙은 함수가 기본 클래스의 가상 함수를 정확히 재정의하는지 검사한다. 만약 매개변수 타입이 다르거나, 기본 클래스에 동일한 시그니처의 가상 함수가 존재하지 않으면 컴파일 오류를 발생시켜 개발자에게 즉시 알린다. 이는 함수 재정의 과정에서 발생할 수 있는 오타나 의도치 않은 오버로딩을 사전에 차단하여 코드의 안정성을 높인다.

반면 final 지정자는 두 가지 방식으로 사용된다. 첫째, 가상 함수에 적용하여 해당 함수를 파생 클래스에서 더 이상 재정의할 수 없도록 만든다. 둘째, 클래스 자체에 적용하여 해당 클래스를 다른 클래스가 상속받는 것을 완전히 금지한다. 이는 라이브러리 설계나 코드 보안 측면에서 유용하며, 특정 클래스 계층 구조를 고정시키거나 다형성의 확장을 의도적으로 제한할 때 사용된다.

이 두 지정자의 도입으로 C++의 객체 지향 프로그래밍은 더욱 명시적이고 실수를 줄일 수 있는 방향으로 발전했다. 특히 대규모 소프트웨어 프로젝트나 복잡한 클래스 상속 구조를 다룰 때, 코드의 의도를 명확히 전달하고 유지보수성을 높이는 데 기여한다.

C++11에서 도입된 열거형 클래스는 기존의 C 스타일 열거형의 여러 문제점을 해결한 강력한 형식의 새로운 열거형이다. 기존 열거형은 이름 공간 오염과 암시적 형 변환으로 인해 오류 가능성이 높았으나, enum class는 이를 개선하여 코드의 안전성과 가독성을 크게 향상시켰다.

enum class의 핵심 특징은 스코프 지정이다. 기존 열거형의 열거자들은 외부에 직접 노출되어 전역 변수와 충돌할 위험이 있었지만, 열거형 클래스의 열거자들은 반드시 열거형이름::열거자 형식으로 접근해야 한다. 이로 인해 이름 충돌이 방지되고 코드의 의도가 명확해진다. 또한, 암시적으로 정수형이나 다른 열거형으로 변환되지 않으며, 명시적인 형 변환을 통해서만 변환이 가능하다. 이는 의도하지 않은 비교나 산술 연산을 방지한다.

열거형 클래스는 내부 기본 타입을 명시적으로 지정할 수 있어 메모리 사용을 최적화할 수 있다. 예를 들어, enum class 색상 : unsigned char { 빨강, 초록, 파랑 };과 같이 선언하면 열거형의 크기를 1바이트로 제한할 수 있다. 이는 특히 임베디드 시스템이나 대규모 배열을 다룰 때 유용하다. 이러한 강력한 형식과 명시성 덕분에 enum class는 C++11 이후 모던 C++ 프로그래밍에서 기본적으로 권장되는 열거형 정의 방식으로 자리 잡았다.

C++11은 멀티스레드 프로그래밍을 언어 차원에서 공식적으로 지원하기 시작했으며, 이의 핵심 요소로 원자 연산 라이브러리가 도입되었다. 이 라이브러리는 <atomic> 헤더를 통해 제공되며, 원자적 연산을 수행할 수 있는 std::atomic 템플릿 클래스와 다양한 관련 함수를 정의한다. 원자 연산은 동시성 제어의 기본 단위로, 스레드 간에 공유되는 데이터에 대한 읽기, 쓰기, 수정 연산이 중간에 간섭받지 않고 완전히 실행되도록 보장한다. 이를 통해 뮤텍스나 세마포어 같은 무거운 동기화 기법 없이도 간단한 데이터 경쟁을 방지할 수 있다.

std::atomic은 정수형, 포인터형, 사용자 정의 타입 등 다양한 타입에 대해 특수화되어 제공된다. 이 클래스는 load(), store(), exchange(), compare_exchange_strong(), fetch_add(), fetch_sub() 등의 멤버 함수를 제공하여 원자적인 읽기, 쓰기, 읽기-수정-쓰기 연산을 수행한다. 특히 compare_exchange 계열 함수는 락 프리 알고리즘과 비블로킹 알고리즘 구현에 필수적인 도구이다. 또한 std::atomic_flag라는 최소한의 원자 불린 타입도 제공되어 간단한 스핀락 구현에 사용될 수 있다.

원자 연산 라이브러리는 메모리 동기화 순서에 대한 세밀한 제어를 가능하게 하는 메모리 순서 모델을 정의한다. memory_order_relaxed, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst 등의 열거형을 통해 프로그래머는 성능과 동기화 강도 사이에서 최적의 선택을 할 수 있다. 예를 들어, memory_order_seq_cst는 가장 강력한 순차 일관성을 보장하지만 오버헤드가 크며, memory_order_relaxed는 가장 약한 보장을 제공하지만 성능이 가장 빠르다. 이를 통해 고도로 최적화된 동시성 코드를 작성할 수 있게 되었다.

이 라이브러리의 도입은 C++로 멀티코어 프로세서 및 병렬 컴퓨팅 환경을 효율적으로 활용하는 프로그램을 작성하는 기반을 마련했다. 기존에 플랫폼별로 상이했던 인라인 어셈블리나 컴파일러 확장 기능에 의존하던 저수준 동기화 코드를 표준화된 고수준 API로 대체할 수 있게 되었으며, 이식성과 안정성을 크게 향상시켰다. 이는 C++11이 현대 시스템 프로그래밍 언어로서의 위상을 공고히 하는 데 기여한 중요한 요소 중 하나이다.

C++11은 다중 스레드 프로그래밍을 언어 차원에서 공식적으로 지원하기 위해 명시적인 메모리 모델을 도입했다. 이는 컴파일러와 CPU가 명령어를 재배치하는 최적화로 인해 발생할 수 있는 예측 불가능한 동작을 방지하고, 멀티스레딩 환경에서 데이터의 일관성과 동기화를 보장하는 기반을 마련한다.

핵심은 다양한 메모리 정렬 규칙을 정의하는 것이다. 기본적으로 원자 연산을 사용하지 않는 일반 변수 접근에는 특별한 보장이 없지만, std::atomic 타입과 함께 사용되는 메모리 순서 지정자를 통해 스레드 간 가시성과 연산 순서를 제어할 수 있다. 예를 들어, memory_order_seq_cst(순차적 일관성)는 가장 강력한 보장을 제공하지만, memory_order_relaxed(느슨한 순서)나 memory_order_acquire/release(획득-해제 의미론) 등을 상황에 맞게 선택해 성능을 최적화할 수 있다.

이 메모리 모델의 도입은 C++가 저수준 시스템 프로그래밍과 고수준 추상화를 모두 아우르는 언어로서의 위상을 공고히 했다. 개발자는 이제 플랫폼에 의존하지 않는 표준화된 방식으로 락-프리 알고리즘을 구현하거나 고성능 동시성 자료 구조를 설계할 수 있게 되었다. 이는 C++11의 스레드 지원 라이브러리 및 원자 연산 라이브러리와 밀접하게 연동되어 강력한 동시성 프로그래밍 툴킷을 완성한다.