시작하기
Hello World
모든 C++ 프로그램은 main()에서 시작합니다. <iostream>은 std::cout(표준 출력)과 std::cin(표준 입력)을 제공합니다. std:: 접두어는 표준 네임스페이스를 참조; using namespace std;로 피할 수 있지만 전역 네임스페이스를 오염시키므로 헤더에서는 권장하지 않습니다.
#include <iostream>
int main() {
std::cout << "Hello, World!" << std::endl;
return 0;
}변수 & auto
auto는 초기화자에서 타입을 추론합니다(C++11). 타입이 명확하거나 장황할 때(반복자) auto를 사용하세요. const는 값을 불변으로 만듭니다; constexpr은 컴파일 타임에 평가되어 바이너리에 임베드된 진정한 상수입니다.
int age = 30;
double pi = 3.14159;
char grade = 'A';
bool is_dev = true;
std::string name = "Alice";
auto x = 42; // int
auto y = 3.14; // double
const double TAX = 0.08;입력 & 출력
std::getline은 공백을 포함한 전체 줄을 읽고, std::cin >>는 공백에서 중지합니다. 둘을 혼합하면 버퍼에 줄바꿈이 남음; getline과 >> 사이에 std::cin.ignore()를 호출하여 버리세요.
#include <iostream>
#include <string>
int main() {
std::string name;
int age;
std::cout << "Name: ";
std::getline(std::cin, name);
std::cout << "Age: ";
std::cin >> age;
std::cout << "Hi " << name << ", " << age << "\n";
}참조
참조는 초기화되어야 하고 다른 객체로 재할당할 수 없는 별칭입니다. 참조로 전달은 복사를 피하고 호출자의 변수를 수정할 수 있게 합니다. 비싼 복사를 피하기 위해 읽기 전용 매개변수에는 const T&를 사용하세요.
int x = 10;
int &ref = x; // alias for x
ref = 20;
std::cout << x; // 20
void increment(int &n) { n++; }
int a = 5;
increment(a); // a is now 6타입 변환
의도가 명확하고 컴파일 타임에 검사되므로 C 스타일 캐스트보다 static_cast를 선호하세요. std::stoi, std::stod는 문자열을 숫자로 변환; std::to_string은 역방향. 잘못된 입력에 std::out_of_range를 주의하세요.
double d = 3.99;
int i = (int)d; // C-style: 3
int j = static_cast<int>(d); // C++: 3
int n = 65;
char c = static_cast<char>(n); // 'A'
// string <-> number
int num = std::stoi("42");
std::string s = std::to_string(3.14);문자열
std::string 기본
std::string은 자체 메모리를 관리하고 필요에 따라 성장합니다. C char 배열과 달리 길이를 수동으로 관리하지 않습니다. .find()는 부분 문자열을 찾지 못하면 std::string::npos(매우 큰 값)를 반환하므로 항상 npos와 비교하세요.
#include <string>
std::string s = "Hello";
std::cout << s.length(); // 5
std::cout << s[0]; // H
s += ", World!";
std::cout << s; // Hello, World!
std::cout << s.substr(0, 3); // Hel
std::cout << s.find("World"); // 7비교 & 검색
비교는 사전순(사전 순서)입니다. .find()는 앞으로 검색, .rfind()는 뒤로 검색. 둘 다 찾지 못하면 std::string::npos를 반환하므로 결과를 boolean으로 취급하지 말고 항상 npos와 비교하세요.
std::string a = "apple", b = "banana";
if (a == b) { /* equal */ }
if (a < b) { /* apple comes before banana */ }
if (a.find("pp") != std::string::npos) {
std::cout << "found\n";
}
size_t pos = a.rfind("p"); // last occurrenceStringstream
stringstream은 문자열과 타입이 지정된 값을 연결하여 형식화된 문자열 구축(버퍼처럼)이나 공백으로 구분된 토큰 파싱에 유용. 직접 작업보다 느리지만 직렬화와 역직렬화에 매우 유연.
#include <sstream>
// Build a string
std::ostringstream oss;
oss << "Name=" << "Alice" << "&Age=" << 30;
std::string result = oss.str();
// Parse tokens
std::istringstream iss("10 20 30");
int a, b, c;
iss >> a >> b >> c; // a=10, b=20, c=30Raw 문자열 & 멀티라인
Raw 문자열 리터럴 R"(...)"는 백슬래시와 따옴표를 리터럴로 처리하여 정규식 패턴, Windows 파일 경로, JSON/XML 템플릿에 이상적. 괄호 안의 구분자는 임의, 예: R"x(...)x"는 내부에 )를 허용.
std::string raw = R"(C:\Users\name\file.txt)";
// No need to escape backslashes
std::string json = R"({
"name": "Alice",
"age": 30
})";char 배열 vs std::string
C 스타일 char 배열은 수동 크기 관리가 필요하고 오류 발생이 쉬움(버퍼 오버플로우). std::string을 선호; const char*를 예상하는 C API와 인터페이스할 때 .c_str() 사용. c_str()은 문자열이 살아있고 수정되지 않은 동안에만 유효.
char cstr[] = "Hello"; // null-terminated, size 6
std::string cppstr = "Hello";
#include <cstring>
std::cout << strlen(cstr); // 5
std::cout << cppstr.length(); // 5
std::string from_c = cstr; // C -> C++
const char* to_c = cppstr.c_str(); // C++ -> C숫자 & 수학
정수 & 부동 소수점 타입
플랫폼 간에 정확한 크기가 중요할 때 <cstdint> 고정 너비 타입(int32_t, int64_t)을 사용. ' 숫자 구분자(C++14)는 큰 숫자의 가독성을 향상. double이 기본 부동 타입이며 정밀도를 위해 float보다 선호.
#include <cstdint>
int32_t a = 100;
int64_t big = 9'000'000'000LL;
uint8_t byte = 255;
size_t sz = sizeof(a); // 4
float f = 1.5f; // 4 bytes
double d = 3.14159265; // 8 bytes (preferred)숫자 제한
<limits>는 숫자 속성에 대한 타입 트레이트를 제공. 하드코딩된 INT_MAX 매크로 대신 이것을 사용. epsilon()은 부동 소수점으로 구별 가능한 가장 작은 차이를 주어 허용 오차로 double을 비교하는 데 유용.
#include <limits>
std::cout << std::numeric_limits<int>::max(); // 2147483647
std::cout << std::numeric_limits<int>::min(); // -2147483648
std::cout << std::numeric_limits<double>::infinity();
std::cout << std::numeric_limits<double>::epsilon();수학 함수
<cmath>는 표준 수학 함수를 제공. 정수 오버플로우는 C++에서 정의되지 않은 동작; int64_t를 사용하거나 경계 확인. 재무 코드의 경우 부동 소수점이 부정확함을 기억 — 정수 센트나 십진수 라이브러리를 고려.
#include <cmath>
double x = 2.5;
std::pow(x, 3); // 15.625
std::sqrt(x); // 1.581
std::abs(-5); // 5
std::floor(3.7); // 3.0
std::ceil(3.2); // 4.0
std::round(3.5); // 4.0
std::fmod(10.5, 3); // 1.5난수
현대 C++은 rand() 대신 <random> 라이브러리를 사용. mt19937은 고품질 PRNG. 분포(uniform_int, uniform_real, normal)는 rand() % N을 괴롭히는 모듈로 편향 없이 원시 비트를 원하는 범위로 매핑.
#include <random>
std::random_device rd;
std::mt19937 gen(rd()); // Mersenne Twister engine
std::uniform_int_distribution<int> dist(1, 100);
for (int i = 0; i < 5; i++) {
std::cout << dist(gen) << " ";
}정수 오버플로우 & 캐스팅
부호 있는 정수 오버플로우는 C++에서 정의되지 않은 동작(컴파일러가 발생하지 않는다고 가정하고 최적화 가능). 곱하기 전에 항상 더 넓은 타입으로 캐스팅하거나 경계 확인. 부호 없는 오버플로우는 2^n modulo로 래핑되며 잘 정의됨.
int a = 100'000;
int b = a * a; // overflow! undefined behavior
long long safe = (long long)a * a; // OK
// Check before multiplying
if (a > 0 && b > INT_MAX / a) {
// would overflow, handle it
}제어 흐름
If / Else
C++17은 초기화자가 있는 if를 도입: if (auto it = m.find(k); it != m.end()) { ... }. 이는 변수를 if/else 블록으로 범위 지정하여 주변 범위를 깔끔하게 유지하고 우발적 재사용을 방지.
int score = 85;
if (score >= 90) {
std::cout << "A\n";
} else if (score >= 80) {
std::cout << "B\n";
} else {
std::cout << "C\n";
}Switch
의도하지 않은 fall-through를 방지하기 위해 항상 break 포함. C++17 [[fallthrough]] 속성은 경고를 억제하기 위해 의도적인 fall-through를 문서화. switch는 문자열이나 실수가 아닌 정수와 열거형 타입에서 작동.
int day = 3;
switch (day) {
case 1: std::cout << "Mon"; break;
case 2: std::cout << "Tue"; break;
case 3: std::cout << "Wed"; break;
default: std::cout << "Other";
}For 루프
범위 기반 for는 컨테이너를 깔끔하게 반복. 요소 복사를 피하기 위해 const auto& 사용(문자열과 큰 객체에 중요). 제 자리에서 요소를 수정하려면 auto&(비 const 참조) 사용.
// Classic for
for (int i = 0; i < 5; i++) {
std::cout << i << " ";
}
// Range-based for (C++11)
std::vector<int> v = {1, 2, 3};
for (int n : v) std::cout << n;
for (const auto &n : v) std::cout << n; // no copyWhile & Do-While
while은 실행 전에 조건 확인; do-while은 확인 전에 본문을 최소 한 번 실행. do-while은 조건을 평가하기 전에 본문이 실행되어야 하는 입력 검증과 메뉴 루프에 유용.
int n = 5;
while (n > 0) {
std::cout << n-- << " ";
}
int x;
do {
std::cin >> x;
} while (x < 0); // runs at least onceBreak, Continue & 중첩 루프
break는 가장 가까운 둘러싸는 루프를 종료; continue는 다음 반복으로 건너뜀. C++에는 Java 같은 레이블이 있는 break가 없음; 플래그 변수를 사용하거나 루프를 함수로 추출하고 return으로 중첩 루프에서 벗어나세요.
for (int i = 0; i < 10; i++) {
if (i == 3) continue; // skip 3
if (i == 7) break; // stop at 7
std::cout << i << " "; // 0 1 2 4 5 6
}
// C++ has no labeled break; use a flag
bool found = false;
for (int i = 0; i < n && !found; i++) {
for (int j = 0; j < m; j++) {
if (matrix[i][j] == target) { found = true; break; }
}
}함수 & 람다
정의 & 다중 반환
C++17 구조화 바인딩(auto [a, b] = ...)은 튜플, 쌍, 구조체를 깔끔하게 언팩. C++17 이전에는 std::tie나 출력 매개변수 사용. 값으로 반환은 복사를 생략하는 이동 의미론(RVO)으로 인해 저렴.
#include <tuple>
std::tuple<int, int> divide(int a, int b) {
return {a / b, a % b};
}
auto [q, r] = divide(17, 5); // q=3, r=2 (C++17)기본값 & Inline
기본 인수는 호출자가 후행 매개변수를 생략할 수 있게. inline은 컴파일러에게 함수를 인라인으로 확장하라는 힌트; 현대 컴파일러는 최적화 플래그에 따라 스스로 결정하므로 inline은 주로 ODR(단일 정의 규칙)에 관한 것.
inline int power(int base, int exp = 2) {
int r = 1;
for (int i = 0; i < exp; i++) r *= base;
return r;
}
// power(3) == 9, power(2, 5) == 32함수 오버로딩
오버로딩은 함수가 이름을 공유하지만 매개변수 타입이 다르게 허용. 컴파일러는 오버로드 해결로 최적 일치 선택. 모호한 오버로드는 컴파일 에러 유발; 본문이 타입 간에 동일할 때 템플릿을 선호.
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }
std::string add(std::string a, std::string b) { return a + b; }
add(1, 2); // int version
add(1.5, 2.5); // double version
add("a", "b"); // string version람다 표현식
람다는 인라인으로 익명 함수 객체를 생성. []는 변수 캡처: [=] 값으로, [&] 참조로, [x] 특정 값을, [&x] 특정 참조로. STL 알고리즘과 콜백에 필수. 참조로 캡처할 때 댕글링 참조 주의.
auto square = [](int x) { return x * x; };
std::cout << square(5); // 25
int factor = 3;
auto multiply = [factor](int x) { return x * factor; };
std::vector<int> v = {1, 2, 3};
std::for_each(v.begin(), v.end(), [](int n) {
std::cout << n << " ";
});함수 포인터 & std::function
std::function(<functional>에서)은 모든 callable을 보유: 함수, 람다, 펑터. 원시 함수 포인터보다 유연하지만 타입 소거로 인해 약간의 런타임 오버헤드. 콜백과 컨테이너에 callable을 저장하는 데 사용.
#include <functional>
int add(int a, int b) { return a + b; }
int (*fp)(int, int) = add; // raw function pointer
std::function<int(int, int)> f = add; // flexible wrapper
f = [](int a, int b) { return a * b; };
std::cout << f(3, 4); // 12STL 컨테이너
vector
vector는 동적 배열이자 기본 컨테이너 선택. push_back은 분할 상환 O(1). .at()은 경계 검사(std::out_of_range throw), operator[]는 안 함. 재할당을 피하기 위해 크기를 알면 선제적으로 reserve() 호출.
#include <vector>
std::vector<int> v = {1, 2, 3};
v.push_back(4);
v.pop_back();
v.size(); // 3
v[0] = 0;
v.at(5); // throws std::out_of_range
for (int n : v) std::cout << n;map & unordered_map
map은 키를 정렬된 상태로 유지(O(log n) 연산); unordered_map은 해싱 사용(O(1) 평균). 정렬된 반복이나 범위 쿼리가 필요하면 map; 순수 조회 속도에는 unordered_map. unordered_map 반복은 순서가 없음.
#include <map>
#include <unordered_map>
std::map<std::string, int> ordered; // sorted by key (red-black tree)
ordered["Alice"] = 30;
std::unordered_map<std::string, int> hashed; // hash table
hashed["Bob"] = 25;
for (auto &[k, v] : ordered) { // C++17 structured binding
std::cout << k << ":" << v;
}set & unordered_set
set은 고유한 정렬된 요소 저장(O(log n)). unordered_set은 해시 기반 버전(O(1) 평균). 중복 제거와 멤버십 테스트에 사용. lower_bound/upper_bound는 정렬된 집합에서 범위 쿼리를 가능하게.
#include <set>
std::set<int> s = {3, 1, 4, 1, 5};
// s contains: 1, 3, 4, 5 (sorted, unique)
s.insert(2);
s.erase(1);
if (s.count(4)) std::cout << "found";
auto it = s.lower_bound(3); // first >= 3array & deque
array는 STL 인터페이스가 있는 고정 크기 스택 할당 배열(C 배열보다 안전, 포인터로 붕괴 없음). deque(양끝 큐)은 양쪽 끝에서 O(1) push/pop 지원, 앞이 O(n)인 vector와 달리.
#include <array>
#include <deque>
std::array<int, 3> arr = {1, 2, 3}; // fixed size, stack-allocated
arr.size(); // 3
std::deque<int> dq = {1, 2, 3};
dq.push_front(0);
dq.push_back(4);
// dq: 0, 1, 2, 3, 4tuple & pair
tuple은 모든 타입 의 이질적 값을 보유. pair는 2요소 tuple. 구조화 바인딩(C++17)은 이를 명명된 변수로 분해. 요소가 (키, 값)의 쌍인 map을 반복할 때 일반적.
#include <tuple>
std::tuple<int, std::string, double> t = {1, "Alice", 3.14};
auto [id, name, val] = t; // C++17 structured binding
std::pair<int, int> p = {1, 2};
std::cout << p.first << p.second;
auto [a, b] = std::make_pair(10, 20);포인터 & 메모리
원시 포인터
포인터는 메모리 주소를 저장. &는 주소를 가져오고, *는 역참조. 포인터 산술은 배열에서 작동. 원시 포인터는 소유권을 추적하지 않아 누수와 댕글링 포인터 유발 — 소유 리소스에는 스마트 포인터를 선호.
int x = 10;
int *ptr = &x; // address of x
std::cout << *ptr; // 10 (dereference)
*ptr = 20;
std::cout << x; // 20
int arr[] = {1, 2, 3};
int *p = arr;
std::cout << *(p + 1); // 2참조 vs 포인터
참조는 더 안전(절대 null, 항상 유효)하고 더 깔끔한 구문. 함수 매개변수와 반환 값에는 참조 사용. null이 의미 있는 상태이거나 가리키는 것을 재할당해야 할 때 포인터 사용.