C++11/14/17/20 새로운 기능 총정리 🚀
안녕하세요, 코딩 열정 가득한 여러분! 오늘은 C++의 진화 과정을 함께 살펴보는 흥미진진한 여정을 떠나볼까요? 🎢 C++11부터 C++20까지, 이 강력한 언어가 어떻게 발전해왔는지 알아보겠습니다. 마치 타임머신을 타고 C++의 역사를 탐험하는 것 같겠죠? 자, 안전벨트를 매시고 출발합니다! 🚗💨
💡 알고 계셨나요? C++은 1979년 비야네 스트롭스트룹에 의해 개발되었습니다. 그 이후로 계속해서 진화하며 현대 소프트웨어 개발의 중추적인 역할을 하고 있죠. 마치 우리의 재능넷(https://www.jaenung.net)이 다양한 재능을 연결하듯, C++도 다양한 프로그래밍 패러다임을 연결하고 있답니다!
C++11: 혁명의 시작 🌟
C++11은 마치 프로그래밍 세계의 르네상스와 같았습니다. 이전 버전들과는 비교할 수 없을 정도로 많은 새로운 기능들이 추가되었죠. 이제 하나씩 살펴볼까요?
1. 자동 타입 추론 (auto)
자동 타입 추론은 C++11의 가장 혁신적인 기능 중 하나입니다. 복잡한 타입 이름을 일일이 작성할 필요 없이, 컴파일러가 알아서 타입을 추론해주죠. 마치 똑똑한 비서가 여러분의 일정을 관리해주는 것과 같답니다! 😎
auto x = 5; // int로 추론
auto y = 3.14; // double로 추론
auto z = "Hello"; // const char*로 추론
이렇게 auto를 사용하면 코드가 훨씬 간결해지고 가독성도 좋아집니다. 특히 복잡한 iterator 타입을 다룰 때 정말 유용하죠!
2. 범위 기반 for 루프
C++11에서는 배열이나 컨테이너를 순회할 때 더욱 직관적인 방법을 제공합니다. 바로 범위 기반 for 루프죠!
std::vector<int> numbers = {1, 2, 3, 4, 5};
for (int num : numbers) {
std::cout << num << " ";
}
// 출력: 1 2 3 4 5
</int>
이 기능은 마치 마법 같아요! 복잡한 인덱스 관리 없이도 모든 요소를 순회할 수 있답니다. 재능넷에서 다양한 재능을 쉽게 찾아볼 수 있는 것처럼, 범위 기반 for 루프로 컨테이너의 모든 요소를 손쉽게 탐색할 수 있죠.
3. 람다 표현식
람다 표현식은 C++11에서 가장 강력한 기능 중 하나입니다. 익명 함수를 간단하게 만들 수 있게 해주죠. 마치 즉석에서 요리를 만들어내는 셰프와 같답니다! 🍳
auto greet = [](const std::string& name) {
return "Hello, " + name + "!";
};
std::cout << greet("C++ Developer"); // 출력: Hello, C++ Developer!
람다 표현식을 사용하면 코드의 가독성과 유지보수성이 크게 향상됩니다. 특히 STL 알고리즘과 함께 사용할 때 그 진가를 발휘하죠!
4. 스마트 포인터
메모리 관리는 C++ 프로그래밍에서 가장 까다로운 부분 중 하나였습니다. 하지만 C++11에서 도입된 스마트 포인터로 이 문제가 한결 쉬워졌죠.
#include <memory>
std::unique_ptr<int> ptr = std::make_unique<int>(42);
std::cout << *ptr; // 출력: 42
// ptr이 스코프를 벗어나면 자동으로 메모리가 해제됩니다.
</int></int></memory>
스마트 포인터는 마치 똑똑한 청소부와 같아요. 우리가 사용한 메모리를 알아서 깔끔하게 정리해주죠! 메모리 누수의 걱정 없이 안전하게 코딩할 수 있답니다.
5. 오른값 참조와 이동 의미론
C++11에서는 오른값 참조(&&)와 이동 의미론이라는 새로운 개념이 도입되었습니다. 이는 불필요한 복사를 줄이고 성능을 크게 향상시키는 혁신적인 기능이에요.
std::vector<int> createVector() {
return std::vector<int>{1, 2, 3, 4, 5};
}
std::vector<int> vec = createVector(); // 이동 생성자 호출
</int></int></int>
이 기능은 마치 텔레포트와 같아요! 🌠 객체를 복사하는 대신 효율적으로 '이동'시킬 수 있게 되었죠. 대규모 데이터를 다룰 때 특히 유용합니다.
6. constexpr
constexpr 키워드의 도입으로 컴파일 타임 상수 표현식이 가능해졌습니다. 이는 프로그램의 성능을 크게 향상시킬 수 있는 강력한 도구죠.
constexpr int factorial(int n) {
return (n <= 1) ? 1 : n * factorial(n - 1);
}
constexpr int result = factorial(5); // 컴파일 타임에 계산됨
constexpr은 마치 미리 준비된 답안지 같아요. 실행 시간이 아닌 컴파일 시간에 계산이 이루어져 프로그램의 효율성이 높아집니다!
7. 초기화 리스트
C++11에서는 중괄호를 사용한 초기화 문법이 도입되었습니다. 이는 모든 타입의 객체를 일관된 방식으로 초기화할 수 있게 해주죠.
std::vector<int> vec = {1, 2, 3, 4, 5};
std::map<:string int> map = {{"apple", 1}, {"banana", 2}};
</:string></int>
이 기능은 마치 레고 블록을 조립하는 것처럼 직관적이고 간편합니다. 복잡한 객체도 손쉽게 초기화할 수 있죠!
8. nullptr
C++11에서는 NULL 대신 nullptr이라는 새로운 키워드가 도입되었습니다. 이는 포인터 타입에 더 안전하고 명확한 null 값을 제공합니다.
int* ptr = nullptr;
if (ptr == nullptr) {
std::cout << "포인터가 null입니다.";
}
nullptr의 도입으로 포인터 관련 오류를 줄이고 코드의 의도를 더 명확하게 표현할 수 있게 되었습니다. 마치 안전벨트를 착용한 것처럼 더욱 안전한 코딩이 가능해졌죠!
9. 열거형 클래스 (enum class)
C++11에서는 강력한 형식의 열거형인 enum class가 도입되었습니다. 이는 기존 열거형의 문제점들을 해결하고 더 안전한 코드 작성을 가능하게 합니다.
enum class Color { Red, Green, Blue };
Color c = Color::Red;
enum class는 마치 잘 정리된 서랍장과 같아요. 각 항목이 자신만의 공간에 깔끔하게 정리되어 있어 혼란을 줄여줍니다!
10. 쓰레드 지원 라이브러리
C++11에서는 표준 라이브러리에 쓰레드 지원이 추가되었습니다. 이로 인해 멀티쓰레드 프로그래밍이 훨씬 쉬워졌죠.
#include <thread>
#include <iostream>
void hello() {
std::cout << "Hello from thread!" << std::endl;
}
int main() {
std::thread t(hello);
t.join();
return 0;
}
</iostream></thread>
표준 쓰레드 라이브러리의 도입으로 병렬 프로그래밍의 문이 활짝 열렸습니다. 마치 여러 명의 요리사가 동시에 일하는 주방처럼, 여러 작업을 동시에 처리할 수 있게 되었죠!
🎓 C++11 정리
C++11은 정말 혁명적인 변화였습니다. 자동 타입 추론, 람다 표현식, 스마트 포인터 등의 도입으로 C++ 프로그래밍이 한층 더 현대적이고 효율적으로 변모했죠. 마치 재능넷이 다양한 재능을 한 곳에 모아 효율적으로 연결하듯, C++11은 다양한 프로그래밍 패러다임을 효과적으로 통합했답니다!
C++14: 세련된 진화 🦋
C++14는 C++11의 혁명적인 변화 이후 나온 '세련된 업그레이드' 버전이라고 할 수 있습니다. C++11에서 도입된 기능들을 더욱 다듬고 개선하는 데 초점을 맞췄죠. 마치 좋은 와인이 시간이 지나면서 더욱 깊은 맛을 내는 것처럼, C++14는 C++11의 맛을 한층 더 깊게 만들어주었답니다. 🍷
1. 함수 반환 타입 추론
C++14에서는 함수의 반환 타입도 auto를 사용해 추론할 수 있게 되었습니다. 이는 코드를 더욱 간결하고 유연하게 만들어주죠.
auto multiply(int a, int b) {
return a * b;
}
이 기능은 마치 똑똑한 비서가 여러분의 말을 듣고 알아서 적절한 문서 형식을 선택해주는 것과 같아요. 프로그래머는 로직에만 집중할 수 있게 되었죠!
2. 람다 표현식의 개선
C++14에서는 람다 표현식이 더욱 강력해졌습니다. 제네릭 람다와 초기화 캡처 기능이 추가되었죠.
auto generic_lambda = [](auto x, auto y) { return x + y; };
cout << generic_lambda(5, 3); // 정수 덧셈
cout << generic_lambda(3.14, 2.0); // 부동소수점 덧셈
int x = 4;
auto lambda_capture = [y = x + 1]() { return y; };
cout << lambda_capture(); // 출력: 5
이러한 개선은 마치 스위스 아미 나이프에 새로운 도구가 추가된 것과 같아요. 더 다양한 상황에서 유연하게 사용할 수 있게 되었죠!
3. 변수 템플릿
C++14에서는 변수 템플릿이라는 새로운 기능이 추가되었습니다. 이를 통해 컴파일 타임에 계산되는 상수를 더 쉽게 정의할 수 있게 되었죠.
template<typename t>
constexpr T pi = T(3.1415926535897932385);
cout << pi<float> << endl; // float 타입의 pi
cout << pi<double> << endl; // double 타입의 pi
</double></float></typename>
이 기능은 마치 요리 레시피를 다양한 양에 맞춰 자동으로 조절해주는 앱과 같아요. 필요한 타입에 맞춰 자동으로 상수값을 제공해주니 얼마나 편리한가요?
4. 이진 리터럴
C++14에서는 이진 리터럴을 직접 표현할 수 있게 되었습니다. 이는 비트 연산을 다룰 때 특히 유용하죠.
int binary = 0b1010; // 10진수로 10
cout << binary << endl; // 출력: 10
이진 리터럴의 도입은 마치 컴퓨터의 언어를 직접 말할 수 있게 된 것과 같아요. 더 이상 10진수나 16진수로 변환할 필요 없이 직접 이진수를 코드에 쓸 수 있게 되었죠!
5. 숫자 구분자
C++14에서는 긴 숫자를 더 읽기 쉽게 만들기 위해 숫자 사이에 작은따옴표(')를 사용할 수 있게 되었습니다.
long long bigNumber = 1'000'000'000'000;
double pi = 3.141'592'653'589;
이 기능은 마치 큰 숫자에 쉼표를 찍어주는 것과 같아요. 긴 숫자를 한눈에 파악할 수 있게 되어 코드의 가독성이 크게 향상되었답니다!
6. constexpr 함수의 제한 완화
C++14에서는 constexpr 함수의 제한이 크게 완화되었습니다. 이제 더 복잡한 로직도 컴파일 타임에 실행할 수 있게 되었죠.
constexpr int factorial(int n) {
int result = 1;
for (int i = 1; i <= n; ++i) {
result *= i;
}
return result;
}
constexpr int fact5 = factorial(5); // 컴파일 타임에 계산
이 개선은 마치 슈퍼컴퓨터를 탑재한 계산기를 얻은 것과 같아요. 더 복잡한 연산도 컴파일 타임에 미리 처리할 수 있게 되어 프로그램의 실행 속도가 크게 향상되었답니다!
7. [[deprecated]] 속성
C++14에서는 [[deprecated]] 속성이 추가되어, 더 이상 사용을 권장하지 않는 함수나 클래스를 명시적으로 표시할 수 있게 되었습니다.
[[deprecated("Use newFunction() instead")]]
void oldFunction() {
// ...
}
이 기능은 마치 오래된 길에 '새 길이 생겼으니 이쪽으로 가세요'라는 안내판을 세워놓은 것과 같아요. 코드의 진화 과정을 더 명확하게 관리할 수 있게 되었죠!
8. 공유 타이머 유틸리티
C++14에서는 <chrono> 라이브러리에 std::chrono::literals 네임스페이스가 추가되어 시간 관련 리터럴을 더 쉽게 사용할 수 있게 되었습니다.
using namespace std::chrono_literals;
auto day = 24h;
auto moment = 1h + 30min + 15s;
이 기능은 마치 시계를 더 직관적으로 읽을 수 있게 해주는 것과 같아요. 시간 관련 코드를 작성할 때 훨씬 더 자연스럽고 읽기 쉬운 표현이 가능해졌답니다!
9. make_unique
C++14에서는 std::make_unique 함수가 추가되어 unique_ptr을 더 안전하고 편리하게 생성할 수 있게 되었습니다.
auto ptr = std::make_unique<int>(42);
</int>
이 기능은 마치 안전 장치가 내장된 도구를 제공받은 것과 같아요. 메모리 누수의 위험을 줄이면서도 더 간결한 코드를 작성할 수 있게 되었죠!
10. 표준 사용자 정의 리터럴
C++14에서는 표준 라이브러리에 여러 사용자 정의 리터럴이 추가되었습니다. 이를 통해 복소수, 시간 단위 등을 더 직관적으로 표현할 수 있게 되었죠.
using namespace std::complex_literals;
auto c = 3.0 + 4.0i; // std::complex<double>(3.0, 4.0)
using namespace std::chrono_literals;
auto duration = 1h + 30min; // 90분을 나타내는 std::chrono::duration
</double>
이 기능은 마치 프로그래밍 언어에 새로운 단어를 추가한 것과 같아요. 특정 도메인의 개념을 더 자연스럽게 코드로 표현할 수 있게 되었답니다!
🎓 C++14 정리
C++14는 C++11의 기반 위에 더욱 세련되고 편리한 기능들을 추가했습니다. 함수 반환 타입 추론, 제네릭 람다, 변수 템플릿 등의 기능은 코드를 더욱 간결하고 표현력 있게 만들어주었죠. 마치 재능넷이 다양한 재능을 더욱 세련되게 연결하듯, C++14는 프로그래머들이 자신의 아이디어를 더욱 우아하게 표현할 수 있도록 도와주었답니다!
C++17: 실용성의 극대화 🛠️
C++17은 '실용성'에 초점을 맞춘 버전이라고 할 수 있습니다. 이전 버전들이 언어의 기반을 다지고 새로운 패러다임을 도입했다면, C++17은 개발자들의 일상적인 코딩 경험을 개선하는 데 주력했죠. 마치 주방에 최신 요리 도구들을 들여놓은 것처럼, C++17은 프로그래머들에게 더욱 효율적인 도구를 제공했답니다. 🍳👨🍳
1. 구조화된 바인딩 (Structured Bindings)
구조화된 바인딩은 C++17에서 가장 흥미로운 기능 중 하나입니다. 이를 통해 여러 변수를 한 번에 초기화할 수 있게 되었죠.
std::pair<int std::string> getPersonInfo() {
return {30, "John"};
}
auto [age, name] = getPersonInfo();
std::cout << "Name: " << name << ", Age: " << age << std::endl;
</int>
이 기능은 마치 선물 상자를 한 번에 풀어 내용물을 꺼내는 것과 같아요. 복잡한 데이터 구조에서 원하는 값을 쉽게 추출할 수 있게 되었답니다!
2. if 문과 switch 문의 초기화 구문
C++17에서는 if 문과 switch 문 내에서 변수를 초기화할 수 있게 되었습니다. 이는 코드의 범위를 더욱 명확하게 제한하고 가독성을 높여줍니다.
if (auto it = m.find("key"); it != m.end()) {
// it를 사용
} else {
// it는 여기서도 유효하지만, m.end()와 같음
}
이 기능은 마치 요리 레시피에서 '재료 준비'와 '조리 과정'을 한 문장으로 표현할 수 있게 된 것과 같아요. 코드의 의도를 더욱 명확하게 전달할 수 있게 되었죠!
3. 인라인 변수
C++17에서는 헤더 파일에서 인라인 변수를 정의할 수 있게 되었습니다. 이는 ODR(One Definition Rule) 위반 없이 헤더 파일에 전역 변수를 정의할 수 있게 해줍니다.
// header.h
inline int globalVar = 42;
// source1.cpp와 source2.cpp에서 모두 사용 가능
인라인 변수는 마치 여러 요리사가 공유하는 레시피 북과 같아요. 모든 코드 파일에서 일관된 값을 쉽게 사용할 수 있게 되었답니다!
4. 중첩 네임스페이스
C++17에서는 중첩된 네임스페이스를 더 간단하게 정의할 수 있게 되었습니다.
네, 계속해서 C++17의 새로운 기능들에 대해 설명드리겠습니다.
<pre><code>
// C++17 이전
namespace A {
namespace B {
namespace C {
// ...
}
}
}
// C++17
namespace A::B::C {
// ...
}
이 기능은 마치 주소를 한 번에 말하는 것과 같아요. 코드의 구조를 더 간결하고 명확하게 표현할 수 있게 되었죠!
5. constexpr if
C++17에서는 컴파일 타임에 조건을 평가하는 constexpr if가 도입되었습니다. 이를 통해 템플릿 메타프로그래밍을 더 쉽게 할 수 있게 되었죠.
template<typename t>
auto get_value(T t) {
if constexpr (std::is_pointer_v<t>)
return *t;
else
return t;
}
</t></typename>
constexpr if는 마치 요리 레시피에서 재료에 따라 조리 방법을 자동으로 선택해주는 것과 같아요. 컴파일 타임에 최적의 코드를 생성할 수 있게 되었답니다!
6. 파일 시스템 라이브러리
C++17에서는 표준 파일 시스템 라이브러리가 추가되었습니다. 이를 통해 파일과 디렉토리 조작을 더 쉽고 안전하게 할 수 있게 되었죠.
#include <filesystem>
namespace fs = std::filesystem;
fs::path p = "/path/to/file.txt";
if (fs::exists(p) && fs::is_regular_file(p)) {
std::cout << "File size: " << fs::file_size(p) << " bytes\n";
}
</filesystem>
파일 시스템 라이브러리는 마치 컴퓨터의 파일 탐색기를 코드로 구현한 것과 같아요. 파일과 디렉토리를 다루는 작업이 훨씬 직관적이고 안전해졌답니다!
7. std::optional
C++17에서는 std::optional이 도입되어 값이 있을 수도 있고 없을 수도 있는 상황을 더 명확하게 표현할 수 있게 되었습니다.
std::optional<int> divide(int a, int b) {
if (b == 0) return std::nullopt;
return a / b;
}
auto result = divide(10, 2);
if (result) {
std::cout << "Result: " << *result << std::endl;
} else {
std::cout << "Division by zero!" << std::endl;
}
</int>
std::optional은 마치 선물 상자를 받았을 때 내용물이 있을 수도 있고 없을 수도 있는 상황을 표현하는 것과 같아요. 불확실성을 더 안전하게 다룰 수 있게 되었답니다!
8. std::variant
C++17에서는 std::variant가 추가되어 여러 타입 중 하나를 저장할 수 있는 타입-안전 유니온을 제공합니다.
std::variant<int float std::string> v;
v = 42; // v는 이제 int를 담고 있음
v = "hello"; // v는 이제 std::string을 담고 있음
std::cout << std::get<:string>(v) << std::endl; // "hello" 출력
</:string></int>
std::variant는 마치 변신 로봇 장난감과 같아요. 상황에 따라 다른 형태로 변할 수 있지만, 항상 안전하게 관리됩니다!
9. 병렬 알고리즘
C++17에서는 많은 표준 알고리즘에 병렬 실행 정책이 추가되었습니다. 이를 통해 멀티코어 프로세서의 성능을 쉽게 활용할 수 있게 되었죠.
#include <algorithm>
#include <execution>
std::vector<int> v = {/* ... */};
std::sort(std::execution::par, v.begin(), v.end());
</int></execution></algorithm>
병렬 알고리즘은 마치 여러 명의 요리사가 동시에 일하는 것과 같아요. 복잡한 작업을 더 빠르게 처리할 수 있게 되었답니다!
10. std::string_view
C++17에서는 std::string_view가 도입되어 문자열의 읽기 전용 뷰를 제공합니다. 이는 문자열 복사 없이 효율적으로 문자열을 참조할 수 있게 해줍니다.
void print(std::string_view sv) {
std::cout << sv << std::endl;
}
std::string str = "Hello, World!";
const char* cstr = "Hello, C++17!";
print(str); // std::string을 직접 전달
print(cstr); // const char*를 직접 전달
print("Literal string"); // 리터럴 문자열도 가능
std::string_view는 마치 책의 특정 페이지를 북마크하는 것과 같아요. 문자열 전체를 복사하지 않고도 효율적으로 참조할 수 있게 되었답니다!
🎓 C++17 정리
C++17은 실용성과 편의성에 중점을 둔 업데이트였습니다. 구조화된 바인딩, 파일 시스템 라이브러리, std::optional, std::variant 등의 기능은 일상적인 프로그래밍 작업을 더욱 쉽고 안전하게 만들어주었죠. 마치 재능넷이 다양한 재능을 더욱 효율적으로 연결하듯, C++17은 프로그래머들이 자신의 아이디어를 더욱 생산적으로 구현할 수 있도록 도와주었답니다!
C++20: 미래를 향한 도약 🚀
C++20은 C++ 언어의 역사에서 가장 큰 변화를 가져온 버전 중 하나입니다. 이 버전은 언어의 표현력을 크게 향상시키고, 동시성 프로그래밍을 더욱 쉽게 만들었으며, 코드의 가독성과 안정성을 높이는 여러 기능을 도입했습니다. 마치 우주 탐사선이 새로운 은하계를 발견한 것처럼, C++20은 프로그래머들에게 새로운 가능성의 세계를 열어주었죠! 🌌👨🚀
1. 컨셉(Concepts)
컨셉은 C++20에서 가장 혁신적인 기능 중 하나입니다. 이를 통해 템플릿의 제약 조건을 명확하게 표현할 수 있게 되었죠.
template<typename t>
concept Addable = requires(T a, T b) {
{ a + b } -> std::same_as<t>;
};
template<addable t>
T add(T a, T b) {
return a + b;
}
</addable></t></typename>
컨셉은 마치 레고 블록의 연결 부위를 정의하는 것과 같아요. 어떤 타입이 특정 연산을 지원해야 하는지 명확하게 표현할 수 있게 되었답니다!
2. 범위(Ranges)
C++20에서는 범위 라이브러리가 도입되어 컨테이너를 다루는 방식이 크게 개선되었습니다.
#include <ranges>
#include <vector>
#include <iostream>
std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto even = v | std::views::filter([](int i) { return i % 2 == 0; })
| std::views::transform([](int i) { return i * i; });
for (int i : even) {
std::cout << i << ' '; // 4 16 36 64 100
}
</int></iostream></vector></ranges>
범위 라이브러리는 마치 데이터를 처리하는 컨베이어 벨트를 만드는 것과 같아요. 복잡한 데이터 처리 과정을 직관적이고 효율적으로 표현할 수 있게 되었죠!
3. 코루틴(Coroutines)
C++20에서는 코루틴이 도입되어 비동기 프로그래밍을 더욱 쉽게 할 수 있게 되었습니다.
#include <coroutine>
#include <iostream>
generator<int> fibonacci() {
int a = 0, b = 1;
while (true) {
co_yield a;
int tmp = a;
a = b;
b += tmp;
}
}
int main() {
for (int i : fibonacci() | std::views::take(10)) {
std::cout << i << ' '; // 0 1 1 2 3 5 8 13 21 34
}
}
</int></iostream></coroutine>
코루틴은 마치 책갈피를 끼워두고 나중에 다시 읽기 시작하는 것과 같아요. 복잡한 비동기 로직을 마치 동기 코드처럼 간단하게 작성할 수 있게 되었답니다!
4. 모듈(Modules)
C++20에서는 모듈 시스템이 도입되어 코드의 구조화와 컴파일 속도 개선이 가능해졌습니다.
// math.cpp
export module math;
export int add(int a, int b) {
return a + b;
}
// main.cpp
import math;
#include <iostream>
int main() {
std::cout << add(2, 3) << std::endl; // 5
}
</iostream>
모듈은 마치 레고 세트의 각 부품을 정리하는 것과 같아요. 코드를 더 체계적으로 구성하고, 불필요한 재컴파일을 줄일 수 있게 되었답니다!
5. 삼중 비교 연산자(Spaceship Operator)
C++20에서는 삼중 비교 연산자(<=>)가 도입되어 비교 연산을 더 쉽게 정의할 수 있게 되었습니다.
struct Point {
int x, y;
auto operator<=>(const Point&) const = default;
};
Point p1{1, 2}, p2{3, 4};
if (p1 < p2) {
std::cout << "p1 is less than p2" << std::endl;
}
삼중 비교 연산자는 마치 만능 비교 도구를 얻은 것과 같아요. 모든 비교 연산을 한 번에 정의할 수 있게 되어 코드가 훨씬 간결해졌답니다!
6. constexpr 확장
C++20에서는 constexpr의 기능이 더욱 확장되어 더 많은 작업을 컴파일 타임에 수행할 수 있게 되었습니다.
constexpr std::string_view trim(std::string_view sv) {
sv.remove_prefix(std::min(sv.find_first_not_of(" "), sv.size()));
sv.remove_suffix(std::min(sv.size() - sv.find_last_not_of(" ") - 1, sv.size()));
return sv;
}
static_assert(trim(" hello ") == "hello");
constexpr의 확장은 마치 미리 계산된 답안지를 가지고 시험을 보는 것과 같아요. 더 많은 연산을 컴파일 타임에 처리할 수 있게 되어 런타임 성능이 크게 향상되었답니다!
7. 지정 초기화(Designated Initializers)
C++20에서는 구조체나 클래스의 특정 멤버만을 초기화할 수 있는 지정 초기화 기능이 추가되었습니다.
struct Point {
int x = 0;
int y = 0;
int z = 0;
};
Point p = { .x = 10, .z = 20 }; // y는 기본값 0으로 초기화됨
지정 초기화는 마치 주문서에 원하는 항목만 체크하는 것과 같아요. 필요한 멤버만 명확하게 초기화할 수 있어 코드의 의도가 더 잘 드러나게 되었답니다!
8. constinit
C++20에서는 constinit 키워드가 추가되어 변수가 컴파일 타임에 초기화되도록 강제할 수 있게 되었습니다.
constinit int global_var = 42;
int main() {
std::cout << global_var << std::endl; // 42
}
constinit은 마치 공연 전에 무대를 미리 세팅하는 것과 같아요. 프로그램 시작 전에 모든 준비를 마칠 수 있게 되어 런타임 성능과 안정성이 향상되었답니다!
9. std::span
C++20에서는 std::span이 도입되어 연속된 메모리 영역을 안전하게 참조할 수 있게 되었습니다.
void printFirstN(std::span<const int> arr, size_t n) {
for (size_t i = 0; i < std::min(arr.size(), n); ++i) {
std::cout << arr[i] << ' ';
}
}
int main() {
int arr[] = {1, 2, 3, 4, 5};
std::vector<int> vec = {6, 7, 8, 9, 10};
printFirstN(arr, 3); // 1 2 3
printFirstN(vec, 3); // 6 7 8
}
</int></const>
std::span은 마치 안전한 망원경으로 배열을 들여다보는 것과 같아요. 다양한 컨테이너를 일관된 방식으로 다룰 수 있게 되어 코드의 재사용성과 안전성이 높아졌답니다!
10. 동기화 라이브러리(Synchronization Library) 개선
C++20에서는 <latch>, <barrier>, <semaphore> 등 새로운 동기화 프리미티브가 추가되어 복잡한 동시성 시나리오를 더 쉽게 다룰 수 있게 되었습니다.
#include <latch>
#include <thread>
#include <vector>
void worker(std::latch& done) {
// 작업 수행
done.count_down();
}
int main() {
constexpr int num_threads = 5;
std::latch done(num_threads);
std::vector<:thread> threads;
for (int i = 0; i < num_threads; ++i) {
threads.emplace_back(worker, std::ref(done));
}
done.wait(); // 모든 작업이 완료될 때까지 대기
std::cout << "All workers finished!" << std::endl;
for (auto& t : threads) {
t.join();
}
}
</:thread></vector></thread></latch>
새로운 동기화 라이브러리는 마치 정교한 교통 신호 시스템을 도입한 것과 같아요. 복잡한 멀티스레드 시나리오를 더욱 안전하고 효율적으로 관리할 수 있게 되었답니다!
🎓 C++20 정리
C++20은 언어의 표현력과 안전성을 크게 향상시킨 혁명적인 업데이트였습니다. 컨셉, 범위, 코루틴, 모듈 등의 기능은 C++ 프로그래밍의 패러다임을 바꿀 만한 큰 변화를 가져왔죠. 마치 재능넷이 다양한 재능을 혁신적인 방식으로 연결하듯, C++20은 프로그래머들에게 더 강력하고 유연한 도구를 제공하여 복잡한 문제를 더 우아하게 해결할 수 있게 해주었답니다!
결론: C++의 진화와 미래 🌈
C++11부터 C++20까지의 여정을 돌아보면, C++ 언어가 얼마나 큰 발전을 이루었는지 알 수 있습니다. 각 버전마다 고유한 특징과 혁신을 가져왔으며, 이는 프로그래머들에게 더 나은 도구와 표현 방식을 제공했습니다.
- C++11: 현대적인 C++의 기초를 다졌습니다. 자동 타입 추론, 람다 표현식, 스마트 포인터 등은 C++ 프로그래밍의 패러다임을 바꾸었죠.
- C++14: C++11의 기능을 다듬고 확장했습니다. 제네릭 람다, 변수 템플릿 등으로 코드를 더욱 간결하고 표현력 있게 만들었습니다.
- C++17: 실용성에 초점을 맞추어 파일 시스템 라이브러리, 병렬 알고리즘 등을 도입했습니다. 개발자의 일상적인 작업을 더욱 쉽게 만들어주었죠.
- C++20: 언어의 표현력을 대폭 향상시켰습니다. 컨셉, 코루틴, 모듈 등은 C++ 프로그래밍의 새로운 지평을 열었습니다.
이러한 진화는 마치 재능넷(https://www.jaenung.net)이 다양한 재능을 연결하고 발전시키는 것과 유사합니다. 각 버전의 새로운 기능들은 프로그래머들의 재능을 더욱 효과적으로 발휘할 수 있게 해주었죠.
앞으로 C++는 어떻게 발전할까요? 아마도 더 안전하고, 더 표현력 있으며, 더 효율적인 언어로 진화할 것입니다. 인공지능, 양자 컴퓨팅, 사물인터넷 등 새로운 기술 영역에서의 요구사항을 충족시키기 위해 계속해서 발전할 것입니다.
C++ 프로그래머로서 우리의 역할은 이러한 진화를 따라가고, 새로운 기능들을 효과적으로 활용하는 것입니다. 끊임없이 학습하고, 실험하고, 적용하면서 우리의 코드를 더 나은 방향으로 발전시켜 나가야 합니다.
C++의 미래는 밝습니다. 그리고 그 미래를 만들어가는 것은 바로 우리, C++ 프로그래머들입니다. 함께 더 나은 코드, 더 나은 소프트웨어, 그리고 더 나은 세상을 만들어 나가봅시다! 🌟
