initializer_list는 컨테이너와 같은가요?

아닙니다. **가벼운 뷰에 가깝고** 요소는 읽기 전용 배열을 가리킵니다. 복사해도 같은 저장소를 공유할 수 있어 “값 복사”라고 생각하면 위험합니다.

왜 vector 생성자에서 중괄호 한 개와 두 개의 의미가 달라지나요?

오버로드 결정에서 **initializer_list 후보**가 있으면 중괄호 묶음이 리스트 초기화로 해석될 수 있습니다. 크기·값을 동시에 넣고 싶다면 괄호 생성자나 reserve+push_back 등을 검토하세요.

initializer_list를 매개변수로 받을 때 성능은?

추가 할당 없이 전달되지만, 호출부에서 임시 배열이 생길 수 있습니다. 핫패스에서는 span이나 반복자 범위 오버로드를 함께 두는 경우도 있습니다.

가변 인자 대신 initializer_list를 쓰면 안 되는 경우는?

모든 인자가 **동일 타입**이어야 하고, 개수는 컴파일 타임에 고정된 리스트 형태입니다. 타입이 섞이면 템플릿 가변 인자나 variant를 고려합니다.

C++ initializer_list | '초기화 리스트' 가이드

2026년 3월 12일 · 10분 읽기 · 수정 2026년 3월 12일 초급 튜토리얼

이 글의 핵심

std::initializer_list 는 C++11에서 도입된 표준 라이브러리 타입으로, 중괄호 {}로 전달된 값들을 받을 수 있습니다. 가변 개수의 인자를 간결하게 처리할 수 있으며, 컨테이너 초기화와 함수 매개변수로 널리 사용됩니다.

initializer_list란?

std::initializer_list 는 C++11에서 도입된 표준 라이브러리 타입으로, 중괄호 {}로 전달된 값들을 받을 수 있습니다. 가변 개수의 인자를 간결하게 처리할 수 있으며, 컨테이너 초기화와 함수 매개변수로 널리 사용됩니다.

#include <initializer_list>
#include <vector>
// 필요한 모듈 import
using namespace std;

void print(initializer_list<int> list) {
    for (int x : list) {
        cout << x << " ";
    }
    cout << endl;
}

int main() {
    print({1, 2, 3, 4, 5});
}

왜 필요한가?:

가변 인자: 개수 제한 없이 값 전달
타입 안전: 템플릿 가변 인자보다 간단하고 타입 안전
표준 컨테이너: 모든 STL 컨테이너가 지원

// ❌ 가변 인자 템플릿: 복잡
template<typename....Args>
void print(Args....args) {
    ((std::cout << args << " "), ...);
}

// ✅ initializer_list: 간결
void print(std::initializer_list<int> list) {
    for (int x : list) {
        std::cout << x << " ";
    }
}

컨테이너 초기화

C/C++ 예제 코드입니다.

// 벡터
vector<int> v1 = {1, 2, 3, 4, 5};
vector<int> v2{1, 2, 3, 4, 5};

// 맵
map<string, int> m = {
    {"Alice", 90},
    {"Bob", 85},
    {"Charlie", 95}
};

// 셋
set<int> s = {1, 2, 3, 4, 5};

커스텀 클래스

class MyVector {
private:
    vector<int> data;
    
public:
    MyVector(initializer_list<int> list) : data(list) {
        cout << "초기화 리스트 생성자" << endl;
    }
    
    void print() const {
        for (int x : data) {
            cout << x << " ";
        }
        cout << endl;
    }
};

int main() {
    MyVector v = {1, 2, 3, 4, 5};
    v.print();
}

실전 예시

예시 1: 가변 인자 함수

int sum(initializer_list<int> list) {
    int total = 0;
    for (int x : list) {
        total += x;
    }
    return total;
}

int main() {
    cout << sum({1, 2, 3}) << endl;           // 6
    cout << sum({10, 20, 30, 40}) << endl;    // 100
}

예시 2: 행렬 초기화

class Matrix {
private:
    vector<vector<int>> data;
    
public:
    Matrix(initializer_list<initializer_list<int>> rows) {
        for (const auto& row : rows) {
            data.emplace_back(row);
        }
    }
    
    void print() const {
        for (const auto& row : data) {
            for (int x : row) {
                cout << x << " ";
            }
            cout << endl;
        }
    }
};

int main() {
    Matrix m = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    
    m.print();
}

예시 3: 옵션 파서

class Options {
private:
    map<string, string> data;
    
public:
    Options(initializer_list<pair<const string, string>> list) : data(list) {}
    
    string get(const string& key, const string& defaultValue = "") const {
        auto it = data.find(key);
        return it != data.end() ? it->second : defaultValue;
    }
};

int main() {
    Options opts = {
        {"host", "localhost"},
        {"port", "8080"},
        {"timeout", "30"}
    };
    
    cout << "호스트: " << opts.get("host") << endl;
    cout << "포트: " << opts.get("port") << endl;
}

예시 4: 통계 함수

struct Stats {
    double mean;
    double min;
    double max;
};

Stats calculate(initializer_list<double> values) {
    if (values.size() == 0) {
        return {0, 0, 0};
    }
    
    double sum = 0;
    double minVal = *values.begin();
    double maxVal = *values.begin();
    
    for (double x : values) {
        sum += x;
        if (x < minVal) minVal = x;
        if (x > maxVal) maxVal = x;
    }
    
    return {sum / values.size(), minVal, maxVal};
}

int main() {
    auto stats = calculate({1.5, 2.3, 4.7, 3.2, 5.1});
    
    cout << "평균: " << stats.mean << endl;
    cout << "최소: " << stats.min << endl;
    cout << "최대: " << stats.max << endl;
}

유니폼 초기화

// 기본 타입
int x{10};
double y{3.14};

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

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

Point p{10, 20};

// 클래스
vector<int> v{1, 2, 3};

자주 발생하는 문제

문제 1: 중괄호 vs 괄호

C/C++ 예제 코드입니다.

// 중괄호: initializer_list 우선
vector<int> v1{10};     // {10} (1개 원소)
vector<int> v2(10);     // 크기 10

vector<int> v3{10, 20}; // {10, 20}
vector<int> v4(10, 20); // 20이 10개

문제 2: narrowing 방지

C/C++ 예제 코드입니다.

// ❌ narrowing 에러
int x = 3.14;  // OK (경고만)

int y{3.14};   // 에러! (narrowing)

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

문제 3: most vexing parse

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

// ✅ 중괄호 초기화
Widget w{};  // 객체 생성

initializer_list 특성

initializer_list<int> list = {1, 2, 3};

// 크기
cout << list.size() << endl;  // 3

// 반복자
for (auto it = list.begin(); it != list.end(); ++it) {
    cout << *it << " ";
}

// 복사 (얕은 복사)
auto list2 = list;  // 같은 배열 참조

initializer_list 내부 구조:

initializer_list는 경량 프록시 객체입니다. 실제 데이터는 컴파일러가 생성한 임시 배열에 저장되며, initializer_list는 이 배열을 가리키는 포인터와 크기만 저장합니다.

// 개념적 구조
// 실행 예제
template<typename T>
class initializer_list {
    const T* begin_;
    size_t size_;
    
public:
    const T* begin() const { return begin_; }
    const T* end() const { return begin_ + size_; }
    size_t size() const { return size_; }
};

주요 특징:

const: 요소를 수정할 수 없음
얕은 복사: 복사 시 같은 배열 참조
경량: 포인터 + 크기만 저장 (8~16바이트)
수명: 임시 배열의 수명에 의존

#include <initializer_list>
#include <iostream>

void dangerousFunction() {
    std::initializer_list<int> list = {1, 2, 3};
    // list는 스택의 임시 배열을 가리킴
    
    // ❌ 위험: list를 반환하면 댕글링 포인터
    // return list;
}

// ✅ 안전: 즉시 복사
std::vector<int> safeFunction() {
    return {1, 2, 3};  // vector로 복사됨
}

복사 동작:

C/C++ 예제 코드입니다.

std::initializer_list<int> list1 = {1, 2, 3};
auto list2 = list1;  // 얕은 복사 (같은 배열 참조)

std::cout << (list1.begin() == list2.begin()) << '\n';  // true

// ✅ 깊은 복사가 필요하면 vector 사용
std::vector<int> vec1 = {1, 2, 3};
auto vec2 = vec1;  // 깊은 복사

실무 패턴

패턴 1: 빌더 패턴

class QueryBuilder {
    std::vector<std::string> conditions_;
    
public:
    QueryBuilder& where(std::initializer_list<std::string> conditions) {
        for (const auto& cond : conditions) {
            conditions_.push_back(cond);
        }
        return *this;
    }
    
    std::string build() const {
        std::string query = "SELECT * FROM table WHERE ";
        for (size_t i = 0; i < conditions_.size(); ++i) {
            if (i > 0) query += " AND ";
            query += conditions_[i];
        }
        return query;
    }
};

// 사용
auto query = QueryBuilder()
    .where({"age > 18", "status = 'active'", "country = 'KR'"})
    .build();

패턴 2: 로깅

class Logger {
public:
    void log(std::initializer_list<std::string> messages) {
        for (const auto& msg : messages) {
            std::cout << "[LOG] " << msg << '\n';
        }
    }
};

Logger logger;
logger.log({"서버 시작", "포트: 8080", "준비 완료"});

패턴 3: 집합 연산

C/C++ 예제 코드입니다.

template<typename T>
std::set<T> makeSet(std::initializer_list<T> list) {
    return std::set<T>(list);
}

auto s1 = makeSet({1, 2, 3, 4, 5});
auto s2 = makeSet({3, 4, 5, 6, 7});

// 교집합
std::set<int> intersection;
std::set_intersection(s1.begin(), s1.end(),
                      s2.begin(), s2.end(),
                      std::inserter(intersection, intersection.begin()));

FAQ

Q1: initializer_list는 언제 사용하나요?

가변 개수의 같은 타입 인자를 받을 때
컨테이너를 간결하게 초기화할 때
함수 매개변수로 여러 값을 전달할 때

Q2: 중괄호 vs 괄호 차이는?

중괄호 {}: narrowing 방지, initializer_list 생성자 우선
괄호 (): 기존 방식, 일반 생성자 호출

std::vector<int> v1{10};  // 요소 1개: 10
std::vector<int> v2(10);  // 크기 10

Q3: 성능은 어떤가요?

A: 컴파일러가 최적화하여 오버헤드가 거의 없습니다. 임시 배열은 스택에 생성되며, 복사 생략(copy elision)이 적용됩니다.

Q4: 가변 인자 템플릿 vs initializer_list?

가변 인자 템플릿: 다른 타입 가능, 복잡, 컴파일 타임 처리
initializer_list: 같은 타입만, 간단, 런타임 처리

Q5: initializer_list를 수정할 수 있나요?

A: 아니요. initializer_list의 요소는 const입니다. 수정이 필요하면 std::vector 등으로 복사하세요.

std::initializer_list<int> list = {1, 2, 3};
// list[0] = 10;  // 에러: const

std::vector<int> vec = {1, 2, 3};
vec[0] = 10;  // OK

Q6: initializer_list의 수명은?

A: initializer_list가 가리키는 임시 배열은 initializer_list 객체가 사용되는 전체 표현식이 끝날 때까지 유효합니다. 반환하면 댕글링 포인터가 됩니다.

Q7: 빈 initializer_list는 어떻게 전달하나요?

A: {}로 전달합니다.

void func(std::initializer_list<int> list) {}

func({});  // 빈 리스트

Q8: initializer_list 학습 리소스는?

cppreference.com - std::initializer_list
“Effective Modern C++” by Scott Meyers (Item 7)
“C++11/14/17 Features” by Bartlomiej Filipek

한 줄 요약: initializer_list는 중괄호로 가변 개수의 같은 타입 값을 전달할 수 있는 경량 프록시 객체입니다.

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

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

심화 부록: 구현·운영 관점

이 부록은 앞선 본문에서 다룬 주제(「C++ initializer_list | ‘초기화 리스트’ 가이드」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.

내부 동작과 핵심 메커니즘

flowchart TD
  A[입력·요청·이벤트] --> B[파싱·검증·디코딩]
  B --> C[핵심 연산·상태 전이]
  C --> D[부작용: I/O·네트워크·동시성]
  D --> E[결과·관측·저장]

sequenceDiagram
  participant C as 클라이언트/호출자
  participant B as 경계(런타임·게이트웨이·프로세스)
  participant D as 의존성(API·DB·큐·파일)
  C->>B: 요청/이벤트
  B->>D: 조회·쓰기·RPC
  D-->>B: 지연·부분 실패·재시도 가능
  B-->>C: 응답 또는 오류(코드·상관 ID)

불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.

프로덕션 운영 패턴

영역	운영 관점 질문
관측성	요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가
안전성	입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가
신뢰성	재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가
성능	캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가
배포	롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가
용량	피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가

스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.

확장 예시: 엔드투엔드 미니 시나리오

앞선 본문 주제(「C++ initializer_list | ‘초기화 리스트’ 가이드」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.

handle(request):
  ctx = newCorrelationId()
  validated = validateSchema(request)
  authorize(validated, ctx)
  result = domainCore(validated)
  persistOrEmit(result, idempotentKey)
  recordMetrics(ctx, latency, outcome)
  return result

문제 해결(Troubleshooting)

증상	가능 원인	조치
간헐적 실패	레이스, 타임아웃, 외부 의존성, DNS	최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검
성능 저하	N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스	프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거
메모리 증가	캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납	상한·TTL·힙/FD 스냅샷 비교
빌드·배포만 실패	환경 변수, 권한, 플랫폼 차이, lockfile	CI 로그와 로컬 diff, 런타임·이미지 버전 핀
설정 불일치	프로필·시크릿·기본값, 리전	스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화
데이터 불일치	비멱등 재시도, 부분 쓰기, 캐시 무효화 누락	멱등 키·아웃박스·트랜잭션 경계 재검토

권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.

배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.

이 글에서 다루는 키워드 (관련 검색어)

C++, initializer_list, C++11, 초기화, 중괄호 등으로 검색하시면 이 글이 도움이 됩니다.

이 글이 도움이 되셨나요?

여러분의 피드백은 더 나은 콘텐츠를 만드는 데 도움이 됩니다

문제가 있거나 개선 제안이 있으시면 연락처로 알려주세요.

Keyboard Shortcuts

C++ initializer_list | '초기화 리스트' 가이드

이 글의 핵심

initializer_list란?

컨테이너 초기화

커스텀 클래스

실전 예시

예시 1: 가변 인자 함수

예시 2: 행렬 초기화

예시 3: 옵션 파서

예시 4: 통계 함수

유니폼 초기화

자주 발생하는 문제

문제 1: 중괄호 vs 괄호

문제 2: narrowing 방지

문제 3: most vexing parse

initializer_list 특성

실무 패턴

패턴 1: 빌더 패턴

패턴 2: 로깅

패턴 3: 집합 연산

FAQ

Q1: initializer_list는 언제 사용하나요?

Q2: 중괄호 vs 괄호 차이는?

Q3: 성능은 어떤가요?

Q4: 가변 인자 템플릿 vs initializer_list?

Q5: initializer_list를 수정할 수 있나요?

Q6: initializer_list의 수명은?

Q7: 빈 initializer_list는 어떻게 전달하나요?

Q8: initializer_list 학습 리소스는?

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

관련 글

심화 부록: 구현·운영 관점

내부 동작과 핵심 메커니즘

프로덕션 운영 패턴

확장 예시: 엔드투엔드 미니 시나리오

문제 해결(Troubleshooting)

이 글에서 다루는 키워드 (관련 검색어)

이 글이 도움이 되셨나요?