C++ 균일 초기화 | "Uniform Initialization" 가이드

균일 초기화란?

균일 초기화(uniform initialization) 는 C++11에서 도입된 모든 타입을 {}로 초기화하는 일관된 문법입니다. 기본 타입, 배열, 구조체, 클래스, 컨테이너 등 모든 타입에 동일한 문법을 사용할 수 있습니다.

// C++03 이전: 다양한 초기화 방법
int x = 10;
int arr[] = {1, 2, 3};
std::vector<int> vec;
vec.push_back(1);

// C++11: 균일 초기화
int x{10};
int arr[]{1, 2, 3};
std::vector<int> vec{1, 2, 3};

왜 필요한가?:

• 일관성: 모든 타입에 동일한 문법
• 안전성: narrowing 변환 방지
• 명확성: Most Vexing Parse 해결
• 편의성: 컨테이너 초기화 간소화

초기화 방법 비교:

초기화 방법	문법	narrowing	Most Vexing Parse
복사 초기화	int x = 10;	⚠️ 허용	-
직접 초기화	int x(10);	⚠️ 허용	❌ 문제 있음
균일 초기화	int x{10};	✅ 방지	✅ 해결

기본 사용법

// 기본 타입
int x{10};
double y{3.14};
char c{'A'};

// 배열
int arr[]{1, 2, 3, 4, 5};

// 구조체
struct Point {
    int x, y;
};
Point p{10, 20};

// 클래스
std::string s{"Hello"};
std::vector<int> vec{1, 2, 3};

narrowing 방지

// ❌ narrowing 에러
int x{3.14};  // 컴파일 에러: double -> int

// ✅ 명시적 변환
int x{static_cast<int>(3.14)};

// 일반 초기화는 허용 (경고만)
int y = 3.14;  // OK (경고)

narrowing 변환 상세:

균일 초기화는 다음과 같은 정보 손실 변환을 컴파일 에러로 막습니다:

// ❌ 부동소수점 → 정수
double d = 3.14;
int x{d};  // 에러

// ❌ 큰 정수 → 작은 정수
long long big = 1000000000000LL;
int y{big};  // 에러

// ❌ 정수 → 부동소수점 (정밀도 손실)
int large = 16777217;
float f{large};  // 에러 (float는 정확히 표현 불가)

// ❌ 부호 있는 정수 → 부호 없는 정수 (음수)
int negative = -1;
unsigned int u{negative};  // 에러

// ✅ 명시적 변환으로 해결
int x2{static_cast<int>(d)};
int y2{static_cast<int>(big)};
float f2{static_cast<float>(large)};
unsigned int u2{static_cast<unsigned int>(negative)};

실무 활용:

// ✅ API 파라미터 타입 안전성
void setVolume(int volume) {
    // volume: 0~100
}

double userInput = 75.5;
// setVolume({userInput});  // 컴파일 에러 (narrowing)
setVolume(static_cast<int>(userInput));  // 명시적 의도

// ✅ 설정 파일 파싱
int parsePort(const std::string& value) {
    double parsed = std::stod(value);
    // return {parsed};  // 에러: double → int
    return static_cast<int>(parsed);  // 명시적
}

Most Vexing Parse 해결

class Widget {
public:
    Widget() {}
};

// ❌ Most Vexing Parse
Widget w();  // 함수 선언으로 해석!

// ✅ 균일 초기화
Widget w{};  // 객체 생성

Most Vexing Parse란?:

C++에서 ()는 함수 선언과 객체 생성 모두에 사용될 수 있어, 컴파일러가 함수 선언으로 해석하는 문제입니다.

class Timer {
public:
    Timer() { std::cout << "Timer 생성\n"; }
};

int main() {
    Timer t();  // ❌ 함수 선언: Timer t();
    // t.start();  // 에러: t는 함수
    
    Timer t2{};  // ✅ 객체 생성
    // t2.start();  // OK
}

더 복잡한 예시:

#include <fstream>
#include <iterator>
#include <algorithm>

int main() {
    std::ifstream file("data.txt");
    
    // ❌ Most Vexing Parse
    std::vector<int> data(
        std::istream_iterator<int>(file),
        std::istream_iterator<int>()
    );
    // data는 함수 선언으로 해석됨!
    
    // ✅ 해결 방법 1: 중괄호
    std::vector<int> data{
        std::istream_iterator<int>(file),
        std::istream_iterator<int>()
    };
    
    // ✅ 해결 방법 2: 추가 괄호
    std::vector<int> data2(
        (std::istream_iterator<int>(file)),
        (std::istream_iterator<int>())
    );
}

실전 예시

예시 1: 컨테이너 초기화

#include <vector>
#include <map>
#include <set>

int main() {
    // vector
    std::vector<int> numbers{1, 2, 3, 4, 5};
    
    // map
    std::map<std::string, int> ages{
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35}
    };
    
    // set
    std::set<int> uniqueNumbers{5, 2, 8, 1, 9};
    
    // 중첩 컨테이너
    std::vector<std::vector<int>> matrix{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
}

예시 2: 구조체/클래스

struct Person {
    std::string name;
    int age;
    double height;
};

class Rectangle {
private:
    int width, height;
    
public:
    Rectangle(int w, int h) : width{w}, height{h} {}
    
    int area() const {
        return width * height;
    }
};

int main() {
    // 구조체
    Person p{"Alice", 30, 165.5};
    
    // 클래스
    Rectangle rect{10, 20};
    std::cout << rect.area() << std::endl;  // 200
}

예시 3: 동적 할당

#include <memory>

int main() {
    // new
    int* ptr = new int{42};
    delete ptr;
    
    // 배열
    int* arr = new int[5]{1, 2, 3, 4, 5};
    delete[] arr;
    
    // 스마트 포인터
    auto unique = std::make_unique<int>(42);
    auto shared = std::make_shared<std::string>("Hello");
    
    // 벡터
    auto vec = std::make_unique<std::vector<int>>(
        std::initializer_list<int>{1, 2, 3, 4, 5}
    );
}

예시 4: 반환값

#include <vector>

std::vector<int> getNumbers() {
    return {1, 2, 3, 4, 5};
}

struct Point {
    int x, y;
};

Point getOrigin() {
    return {0, 0};
}

int main() {
    auto numbers = getNumbers();
    auto origin = getOrigin();
}

= vs {}

// = 초기화
int x = 10;
int y = 3.14;  // narrowing 허용 (경고)

// {} 초기화
int a{10};
// int b{3.14};  // 에러: narrowing

// 복사 초기화
std::string s1 = "Hello";  // OK
std::string s2{"Hello"};   // OK

// 직접 초기화
std::vector<int> v1(10);    // 10개 요소 (기본값)
std::vector<int> v2{10};    // 1개 요소 (값 10)

초기화 리스트 우선순위

class MyClass {
public:
    MyClass(int x) {
        std::cout << "int 생성자" << std::endl;
    }
    
    MyClass(std::initializer_list<int> list) {
        std::cout << "initializer_list 생성자" << std::endl;
    }
};

int main() {
    MyClass obj1(10);   // int 생성자
    MyClass obj2{10};   // initializer_list 생성자 (우선!)
}

자주 발생하는 문제

문제 1: vector 크기 vs 값

// ❌ 의도와 다름
std::vector<int> v1(10);    // 10개 요소 (0으로 초기화)
std::vector<int> v2{10};    // 1개 요소 (값 10)

// ✅ 명확하게
std::vector<int> v3(10, 0);      // 10개, 모두 0
std::vector<int> v4{1, 2, 3};    // 3개 요소

문제 2: auto와 함께

// ❌ 의도하지 않은 타입
auto x = {1, 2, 3};  // std::initializer_list<int>

// ✅ 명시적 타입
std::vector<int> y = {1, 2, 3};

문제 3: narrowing

// ❌ narrowing 에러
int x{3.14};
char c{1000};

// ✅ 명시적 변환
int x{static_cast<int>(3.14)};
char c{static_cast<char>(1000)};

문제 4: 빈 초기화

class MyClass {
public:
    MyClass() {
        std::cout << "기본 생성자" << std::endl;
    }
    
    MyClass(std::initializer_list<int> list) {
        std::cout << "initializer_list 생성자" << std::endl;
    }
};

int main() {
    MyClass obj1;      // 기본 생성자
    MyClass obj2{};    // 기본 생성자
    MyClass obj3{{}};  // initializer_list 생성자 (빈 리스트)
}

멤버 초기화

class MyClass {
private:
    int x{10};              // C++11: 멤버 초기화
    std::string s{"Hello"};
    std::vector<int> vec{1, 2, 3};
    
public:
    MyClass() = default;
    
    MyClass(int value) : x{value} {}  // 생성자 초기화 리스트
};

집합 초기화

struct Point {
    int x, y, z;
};

// 집합 초기화
Point p1{1, 2, 3};
Point p2{1, 2};     // z는 0
Point p3{};         // 모두 0

// 중첩 구조체
struct Line {
    Point start, end;
};

Line line{{0, 0, 0}, {10, 10, 10}};

장단점

// ✅ 장점
// 1. 균일한 문법
int x{10};
std::vector<int> vec{1, 2, 3};

// 2. narrowing 방지
// int y{3.14};  // 에러

// 3. Most Vexing Parse 방지
Widget w{};  // 객체 생성

// ❌ 단점
// 1. initializer_list 우선순위
std::vector<int> v{10};  // 1개 요소 (의도: 10개?)

// 2. auto와 혼동
auto x = {1, 2, 3};  // initializer_list

장점 상세:

장점	설명	예시
일관성	모든 타입에 동일한 문법	int x{10}; vector<int> v{1,2,3};
안전성	narrowing 방지	int x{3.14}; // 에러
명확성	Most Vexing Parse 해결	Widget w{}; // 객체
편의성	컨테이너 초기화 간소화	map<string,int> m{{"a",1}};

단점 상세:

단점	설명	해결 방법
initializer_list 우선순위	{}는 항상 initializer_list 생성자 우선	() 사용
vector 크기 혼동	vector<int> v{10};은 1개 요소	vector<int> v(10);
auto 타입 추론	auto x = {1,2,3};은 initializer_list	명시적 타입

실무 권장:

// ✅ 균일 초기화 사용 권장
// 1. 기본 타입
int x{10};
double d{3.14};

// 2. 구조체
Point p{10, 20};

// 3. 컨테이너 (요소 나열)
std::vector<int> v{1, 2, 3};

// ⚠️ 괄호 사용 권장
// 1. vector 크기 지정
std::vector<int> v(100);  // 100개 요소

// 2. 생성자 인자가 명확할 때
std::string s(10, 'x');  // "xxxxxxxxxx"

사용 권장사항

// ✅ 사용 권장
// 1. 컨테이너 초기화
std::vector<int> vec{1, 2, 3};

// 2. 구조체 초기화
Point p{10, 20};

// 3. narrowing 방지 필요
int x{value};  // narrowing 체크

// ❌ 주의 필요
// 1. vector 크기 지정
std::vector<int> v(10);  // () 사용

// 2. auto와 함께
std::vector<int> v = {1, 2, 3};  // 명시적 타입

실무 패턴

패턴 1: 설정 객체

struct ServerConfig {
    std::string host = "localhost";
    int port = 8080;
    int maxConnections = 100;
    bool enableSSL = false;
};

// 균일 초기화로 간결하게
ServerConfig cfg{
    "0.0.0.0",
    3000,
    500,
    true
};

패턴 2: 반환값 최적화

struct Result {
    bool success;
    std::string message;
    int code;
};

Result processRequest() {
    if (error) {
        return {false, "Error occurred", 500};
    }
    return {true, "Success", 200};
}

패턴 3: 멤버 초기화

class Connection {
    std::string host_{"localhost"};
    int port_{8080};
    std::vector<std::string> options_{
        "keepalive=true",
        "timeout=30"
    };
    
public:
    Connection() = default;
    Connection(std::string host, int port) 
        : host_{std::move(host)}, port_{port} {}
};

FAQ

Q1: 균일 초기화는 언제 사용하나요?

A:

• 컨테이너 초기화 (요소 나열)
• narrowing 변환 방지가 중요할 때
• 일관된 코드 스타일을 원할 때

Q2: () vs {}의 차이는?

A:

• {}: narrowing 방지, initializer_list 생성자 우선, Most Vexing Parse 해결
• (): 일반 생성자 호출, vector 크기 지정

Q3: narrowing이란 무엇인가요?

A: 정보 손실이 발생하는 타입 변환입니다 (예: double → int, long long → int).

Q4: Most Vexing Parse란?

A: Widget w();가 함수 선언으로 해석되는 문제입니다. Widget w{};로 해결합니다.

Q5: initializer_list 생성자 우선순위는?

A: {}를 사용하면 initializer_list 생성자가 항상 우선합니다.

std::vector<int> v1{10};  // initializer_list: 요소 1개
std::vector<int> v2(10);  // 일반 생성자: 크기 10

Q6: 빈 중괄호 {}는 무엇을 의미하나요?

A: 값 초기화(value initialization)를 수행합니다. 기본 타입은 0, 클래스는 기본 생성자를 호출합니다.

Q7: 균일 초기화의 성능은?

A: 일반 초기화와 동일합니다. 컴파일러가 최적화하므로 런타임 오버헤드가 없습니다.

Q8: 균일 초기화 학습 리소스는?

A:

• “Effective Modern C++” by Scott Meyers (Item 7)
• cppreference.com - List initialization
• “C++ Primer” by Lippman, Lajoie, Moo

관련 글: List Initialization, initializer_list, Value Initialization.

한 줄 요약: 균일 초기화는 중괄호로 모든 타입을 일관되게 초기화하며, narrowing 변환을 방지합니다.

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ initializer_list | “초기화 리스트” 가이드
• C++ 초기화 리스트 생성자 | “Initializer List” 가이드
• C++ call_once | “한 번만 호출” 가이드

관련 글

• C++ call_once |
• C++ initializer_list |
• C++ Aggregate Initialization |
• C++ Aggregate Initialization 완벽 가이드 | 집합 초기화
• C++ async & launch |