C++ Initialization Order 완벽 가이드 | 초기화 순서의 모든 것
이 글의 핵심
C++ Initialization Order 완벽 가이드에 대한 실전 가이드입니다. 초기화 순서의 모든 것 등을 예제와 함께 상세히 설명합니다.
Initialization Order란? 왜 중요한가
문제 시나리오: 초기화되지 않은 변수 사용
문제: 전역 변수 y가 전역 변수 x를 사용해 초기화되는데, 두 변수가 다른 파일에 있으면 어느 것이 먼저 초기화될지 알 수 없습니다.
file1.cpp:
int compute() { return 100; }
int x = compute(); // 동적 초기화file2.cpp:
extern int x;
int y = x * 2; // x가 초기화 안 됐을 수 있음!결과: y가 0이거나 쓰레기 값이 됩니다. 이것이 Static Initialization Order Fiasco입니다.
해결: 초기화 순서 규칙을 이해하고, Singleton 패턴이나 constinit을 사용해 문제를 피합니다.
flowchart TD
subgraph file1["file1.cpp"]
x["int x = compute()"]
end
subgraph file2["file2.cpp"]
y["int y = x * 2"]
end
subgraph order["초기화 순서"]
q["x, y 중 누가 먼저?"]
a["불확정!"]
end
x --> q
y --> q
q --> a
목차
- 초기화 단계
- 파일 내 초기화 순서
- 파일 간 초기화 순서
- 멤버 초기화 순서
- Static Initialization Order Fiasco
- 자주 발생하는 문제와 해결법
- 프로덕션 패턴
- 완전한 예제
1. 초기화 단계
3단계 초기화
// 1. Zero Initialization (정적 저장소)
static int a; // 0으로 초기화
// 2. Constant Initialization (컴파일 타임)
constexpr int b = 10;
constinit int c = 20;
// 3. Dynamic Initialization (런타임)
int func() { return 30; }
int d = func();
// 순서: Zero → Constant → Dynamic| 단계 | 시점 | 예시 |
|---|---|---|
| Zero | 프로그램 시작 전 | static int x; → 0 |
| Constant | 컴파일 타임 | constexpr int x = 10; |
| Dynamic | 런타임 | int x = func(); |
2. 파일 내 초기화 순서
선언 순서대로
같은 파일 내에서는 선언 순서대로 초기화됩니다.
// file.cpp
#include <iostream>
int a = 10;
int b = a * 2; // a가 먼저 초기화됨 → b = 20
int c = b + a; // b, a가 먼저 초기화됨 → c = 30
int main() {
std::cout << a << ", " << b << ", " << c << '\n'; // 10, 20, 30
}3. 파일 간 초기화 순서
불확정 순서
다른 파일에 있는 전역 변수의 초기화 순서는 불확정입니다.
file1.cpp:
#include <iostream>
struct Logger {
Logger() { std::cout << "Logger created\n"; }
void log(const char* msg) { std::cout << msg << '\n'; }
};
Logger logger; // 전역file2.cpp:
#include <iostream>
extern Logger logger;
struct Database {
Database() {
logger.log("Database created"); // 위험!
// logger가 초기화 안 됐을 수 있음
}
};
Database db; // 전역문제: db가 logger보다 먼저 초기화되면, logger.log()가 미초기화 객체를 사용합니다.
4. 멤버 초기화 순서
선언 순서 (초기화 리스트 무관)
멤버 변수는 선언 순서대로 초기화됩니다. 초기화 리스트의 순서는 무관합니다.
#include <iostream>
struct Data {
int b;
int a;
// 초기화 리스트 순서: a, b
Data() : a(10), b(a * 2) {
// 실제 초기화 순서: b, a (선언 순서)
// b = a * 2 실행 시 a는 미초기화!
std::cout << "a=" << a << ", b=" << b << '\n';
}
};
int main() {
Data d; // a=10, b=쓰레기값
}해결: 선언 순서와 초기화 리스트 순서를 일치시킵니다.
struct Data {
int a;
int b;
Data() : a(10), b(a * 2) {
// 순서: a, b
std::cout << "a=" << a << ", b=" << b << '\n';
}
};
int main() {
Data d; // a=10, b=20
}베이스 클래스 → 멤버 → 생성자 본문
#include <iostream>
struct Base {
Base() { std::cout << "1. Base\n"; }
};
struct Member {
Member() { std::cout << "2. Member\n"; }
};
struct Derived : Base {
Member m;
Derived() {
std::cout << "3. Derived\n";
}
};
int main() {
Derived d;
// 출력:
// 1. Base
// 2. Member
// 3. Derived
}5. Static Initialization Order Fiasco
문제 상황
file1.cpp:
int x = 100;file2.cpp:
extern int x;
int y = x * 2; // x가 초기화 안 됐을 수 있음해결법 1: Singleton (함수 내 정적 변수)
// file1.cpp
class Logger {
public:
static Logger& instance() {
static Logger logger; // 첫 호출 시 초기화 (스레드 안전)
return logger;
}
void log(const char* msg) { /* ... */ }
private:
Logger() { /* ... */ }
};
// file2.cpp
class Database {
public:
Database() {
Logger::instance().log("Database created"); // 안전!
}
};
Database db; // 전역해결법 2: constinit (C++20)
// file1.cpp
constinit int x = 100; // 컴파일 타임 초기화 보장
// file2.cpp
extern constinit int x;
constinit int y = x * 2; // 안전 (둘 다 constant initialization)해결법 3: 지연 초기화
// file1.cpp
int& get_x() {
static int x = 100;
return x;
}
// file2.cpp
int& get_y() {
static int y = get_x() * 2; // 첫 호출 시 초기화
return y;
}6. 자주 발생하는 문제와 해결법
문제 1: 멤버 초기화 순서 혼란
증상: 예상과 다른 값이 초기화됨.
struct Bad {
int b;
int a;
Bad() : a(10), b(a * 2) {
// b가 먼저 초기화되는데, a는 아직 미초기화
}
};
// ✅ 해결: 선언 순서 일치
struct Good {
int a;
int b;
Good() : a(10), b(a * 2) {
// a 먼저, b 나중
}
};문제 2: 전역 변수 파일 간 의존
증상: 프로그램 시작 시 크래시 또는 잘못된 값.
// ❌ 위험
// file1.cpp
int x = 100;
// file2.cpp
extern int x;
int y = x * 2; // x가 0일 수 있음
// ✅ 해결: Singleton
// file1.cpp
int& get_x() {
static int x = 100;
return x;
}
// file2.cpp
int& get_y() {
static int y = get_x() * 2;
return y;
}문제 3: 정적 소멸 순서
증상: 소멸자에서 이미 파괴된 객체 접근.
// file1.cpp
Logger logger;
// file2.cpp
extern Logger logger;
struct Database {
~Database() {
logger.log("Database destroyed"); // logger가 먼저 파괴됐을 수 있음
}
};
Database db;해결: 소멸자에서 다른 전역 객체를 사용하지 않거나, Singleton으로 수명 관리.
7. 프로덕션 패턴
패턴 1: Meyer’s Singleton
class ResourceManager {
public:
static ResourceManager& instance() {
static ResourceManager mgr; // 스레드 안전 (C++11)
return mgr;
}
void load() { /* ... */ }
private:
ResourceManager() { /* ... */ }
~ResourceManager() { /* ... */ }
ResourceManager(const ResourceManager&) = delete;
ResourceManager& operator=(const ResourceManager&) = delete;
};
// 사용
ResourceManager::instance().load();패턴 2: constinit으로 정적 초기화 보장
// config.cpp
constinit int MAX_CONNECTIONS = 1000;
constinit const char* DEFAULT_HOST = "localhost";
// 다른 파일에서 안전하게 사용
extern constinit int MAX_CONNECTIONS;패턴 3: 초기화 순서 명시 (Nifty Counter)
// header.h
class Logger {
public:
Logger();
~Logger();
void log(const char* msg);
};
extern Logger& get_logger();
// logger.cpp
static Logger* logger_ptr = nullptr;
static int init_count = 0;
struct LoggerInitializer {
LoggerInitializer() {
if (init_count++ == 0) {
logger_ptr = new Logger();
}
}
~LoggerInitializer() {
if (--init_count == 0) {
delete logger_ptr;
}
}
};
static LoggerInitializer initializer; // 각 번역 단위마다
Logger& get_logger() {
return *logger_ptr;
}8. 완전한 예제: 안전한 전역 리소스 관리
#include <iostream>
#include <memory>
#include <string>
// 리소스 관리자 (Singleton)
class ResourceManager {
public:
static ResourceManager& instance() {
static ResourceManager mgr;
return mgr;
}
void register_resource(const std::string& name) {
std::cout << "Registered: " << name << '\n';
resources.push_back(name);
}
void list_resources() {
std::cout << "Resources:\n";
for (const auto& r : resources) {
std::cout << " - " << r << '\n';
}
}
private:
ResourceManager() {
std::cout << "ResourceManager created\n";
}
~ResourceManager() {
std::cout << "ResourceManager destroyed\n";
}
std::vector<std::string> resources;
ResourceManager(const ResourceManager&) = delete;
ResourceManager& operator=(const ResourceManager&) = delete;
};
// 전역 객체들이 ResourceManager를 사용
struct Database {
Database() {
ResourceManager::instance().register_resource("Database");
}
~Database() {
std::cout << "Database destroyed\n";
}
};
struct Cache {
Cache() {
ResourceManager::instance().register_resource("Cache");
}
~Cache() {
std::cout << "Cache destroyed\n";
}
};
// 전역 객체
Database db;
Cache cache;
int main() {
std::cout << "Main started\n";
ResourceManager::instance().list_resources();
std::cout << "Main ended\n";
}
// 출력:
// ResourceManager created
// Registered: Database
// Registered: Cache
// Main started
// Resources:
// - Database
// - Cache
// Main ended
// Cache destroyed
// Database destroyed
// ResourceManager destroyed초기화 순서 규칙 요약
| 범위 | 순서 |
|---|---|
| 파일 내 | 선언 순서 |
| 파일 간 | 불확정 |
| 멤버 | 선언 순서 (초기화 리스트 무관) |
| 베이스/멤버 | 베이스 → 멤버 → 생성자 본문 |
| 소멸 | 초기화 역순 |
정리
| 개념 | 설명 |
|---|---|
| Zero Initialization | 정적 변수 0으로 초기화 |
| Constant Initialization | 컴파일 타임 초기화 |
| Dynamic Initialization | 런타임 초기화 |
| 파일 내 순서 | 선언 순서 |
| 파일 간 순서 | 불확정 |
| 멤버 순서 | 선언 순서 |
| Fiasco 해결 | Singleton, constinit, 지연 초기화 |
초기화 순서를 이해하면 Static Initialization Order Fiasco를 피하고, 안전한 전역 객체를 만들 수 있습니다.
FAQ
Q1: 파일 간 초기화 순서는?
A: 불확정입니다. 링커가 결정하며, 의존하면 안 됩니다.
Q2: Static Initialization Order Fiasco란?
A: 파일 간 전역 변수가 서로 의존할 때, 초기화 순서가 불확정이라 미초기화 변수를 사용하는 문제입니다.
Q3: 해결 방법은?
A: Singleton (함수 내 정적 변수), constinit (컴파일 타임 초기화), 지연 초기화를 사용하세요.
Q4: 멤버 초기화 순서는?
A: 선언 순서입니다. 초기화 리스트에 다른 순서로 써도, 실제로는 선언 순서대로 초기화됩니다.
Q5: constinit은 뭔가요?
A: C++20에서 추가된 키워드로, 변수가 컴파일 타임에 초기화됨을 보장합니다. 런타임 함수로 초기화하면 컴파일 에러가 납니다.
Q6: Initialization Order 학습 리소스는?
A:
- cppreference - Initialization
- “Effective C++” by Scott Meyers (Item 4)
- “C++ Primer” by Stanley Lippman
한 줄 요약: 초기화 순서를 이해하고 Fiasco를 피하면 안전한 전역 객체를 만들 수 있습니다. 다음으로 Static Initialization Order Fiasco를 읽어보면 좋습니다.
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ static 멤버 | “Static Members” 가이드
관련 글
- C++ Dynamic Initialization |
- C++ 정적 초기화 순서 |