C++ 초기화 리스트 생성자 | 'Initializer List' 가이드

초기화 리스트 생성자란?

std::initializer_list를 받는 생성자

#include <initializer_list>
#include <vector>

class MyVector {
private:
    std::vector<int> data;
    
public:
    // 초기화 리스트 생성자
    MyVector(std::initializer_list<int> list) {
        for (int x : list) {
            data.push_back(x);
        }
    }
};

int main() {
    MyVector vec = {1, 2, 3, 4, 5};  // 초기화 리스트 사용
}

기본 사용법

#include <initializer_list>
#include <iostream>

class IntArray {
private:
    int* data;
    size_t size;
    
public:
    IntArray(std::initializer_list<int> list) 
        : size(list.size()), data(new int[list.size()]) {
        size_t i = 0;
        for (int x : list) {
            data[i++] = x;
        }
    }
    
    ~IntArray() {
        delete[] data;
    }
    
    void print() const {
        for (size_t i = 0; i < size; i++) {
            std::cout << data[i] << " ";
        }
        std::cout << std::endl;
    }
};

int main() {
    IntArray arr = {1, 2, 3, 4, 5};
    arr.print();  // 1 2 3 4 5
}

표준 컨테이너와 함께

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

int main() {
    // vector
    std::vector<int> vec = {1, 2, 3, 4, 5};
    
    // map
    std::map<std::string, int> ages = {
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35}
    };
    
    // set
    std::set<int> numbers = {5, 2, 8, 1, 9};
}

실전 예시

예시 1: 행렬 클래스

#include <initializer_list>
#include <vector>

class Matrix {
private:
    std::vector<std::vector<int>> data;
    size_t rows, cols;
    
public:
    // 2D 초기화 리스트
    Matrix(std::initializer_list<std::initializer_list<int>> list) {
        rows = list.size();
        cols = list.begin()->size();
        
        for (const auto& row : list) {
            data.push_back(std::vector<int>(row));
        }
    }
    
    void print() const {
        for (const auto& row : data) {
            for (int val : row) {
                std::cout << val << " ";
            }
            std::cout << std::endl;
        }
    }
};

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

예시 2: 설정 클래스

#include <initializer_list>
#include <map>
#include <string>

class Config {
private:
    std::map<std::string, std::string> settings;
    
public:
    Config(std::initializer_list<std::pair<const std::string, std::string>> list) {
        for (const auto& pair : list) {
            settings[pair.first] = pair.second;
        }
    }
    
    std::string get(const std::string& key) const {
        auto it = settings.find(key);
        return it != settings.end() ? it->second : "";
    }
    
    void print() const {
        for (const auto& [key, value] : settings) {
            std::cout << key << " = " << value << std::endl;
        }
    }
};

int main() {
    Config config = {
        {"host", "localhost"},
        {"port", "8080"},
        {"debug", "true"}
    };
    
    config.print();
}

예시 3: 가변 인자 함수

#include <initializer_list>

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

double average(std::initializer_list<double> list) {
    if (list.size() == 0) return 0.0;
    
    double total = 0.0;
    for (double x : list) {
        total += x;
    }
    return total / list.size();
}

int main() {
    std::cout << sum({1, 2, 3, 4, 5}) << std::endl;  // 15
    std::cout << average({1.5, 2.5, 3.5}) << std::endl;  // 2.5
}

예시 4: 빌더 패턴

#include <initializer_list>
#include <string>
#include <vector>

class QueryBuilder {
private:
    std::string table;
    std::vector<std::string> columns;
    std::string whereClause;
    
public:
    QueryBuilder& from(const std::string& t) {
        table = t;
        return *this;
    }
    
    QueryBuilder& select(std::initializer_list<std::string> cols) {
        columns = cols;
        return *this;
    }
    
    QueryBuilder& where(const std::string& condition) {
        whereClause = condition;
        return *this;
    }
    
    std::string build() const {
        std::string query = "SELECT ";
        
        for (size_t i = 0; i < columns.size(); i++) {
            query += columns[i];
            if (i < columns.size() - 1) query += ", ";
        }
        
        query += " FROM " + table;
        
        if (!whereClause.empty()) {
            query += " WHERE " + whereClause;
        }
        
        return query;
    }
};

int main() {
    auto query = QueryBuilder()
        .from("users")
        .select({"id", "name", "email"})
        .where("age > 18")
        .build();
    
    std::cout << query << std::endl;
    // SELECT id, name, email FROM users WHERE age > 18
}

우선순위

class MyClass {
public:
    MyClass(int x) {
        std::cout << "int 생성자: " << x << 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 생성자 (우선!)
    MyClass obj3 = {10};   // initializer_list 생성자
}

자주 발생하는 문제

문제 1: 생성자 모호성

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

int main() {
    MyClass obj1(1, 2);    // 두 int 생성자
    MyClass obj2{1, 2};    // initializer_list 생성자 (우선!)
}

문제 2: narrowing 변환

// ❌ narrowing 에러
std::initializer_list<int> list = {1, 2, 3.14};  // 에러

// ✅ 명시적 변환
std::initializer_list<int> list = {1, 2, static_cast<int>(3.14)};

문제 3: 빈 리스트

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 생성자 (빈 리스트)
}

initializer_list 특징

#include <initializer_list>

void func(std::initializer_list<int> list) {
    // 읽기 전용
    // list[0] = 10;  // 에러
    
    // 크기 확인
    std::cout << "크기: " << list.size() << std::endl;
    
    // 반복
    for (int x : list) {
        std::cout << x << " ";
    }
}

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

initializer_list 동작 원리

std::initializer_list<T>는 컴파일러가 생성한 임시 배열을 가리키는 얇은 래퍼입니다. {1, 2, 3} 같은 브레이스 초기화가 발생하면, 구현은 보통 const T[] 형태의 저장소를 스택(또는 정적 저장 영역)에 두고, initializer_list는 그 배열의 시작 포인터와 길이만 담습니다.

• 수명: 리스트는 보통 함수 호출 인자로 전달되는 경우 호출이 끝날 때까지 유효합니다. auto il = {1,2,3};처럼 지역 변수에 바인딩하면, 해당 변수가 스코프를 벗어나기 전까지 동일한 배열을 참조합니다. 다만 initializer_list를 멤버로 오래 보관하면서 원본 배열 수명이 끝난 뒤 접근하면 UB이므로, 장기 보관이 필요하면 vector 등으로 복사하는 편이 안전합니다.
• 복사 의미: initializer_list 객체를 복사해도 내부적으로는 같은 배열을 가리키는 포인터/크기를 공유하는 수준이라 가벼운 편입니다. 하지만 요소 자체의 복사는 초기화 시점에 이미 일어났을 수 있습니다(예: string 요소).
• const 뷰: 요소는 const T로 노출되며, 크기 변경·요소 대입은 불가능합니다. “가변 길이 배열”이 아니라 고정 길이 읽기 전용 뷰로 이해하면 됩니다.

void take(std::initializer_list<int> il) {
    // il.begin(), il.end(), il.size()
    for (int x : il) { /* 읽기만 */ }
}

벡터 생성자와의 관계

std::vector는 대표적으로 (size, value), (iterator 쌍), initializer_list 생성자를 제공합니다. 여기서 {} 초기화는 규칙에 따라 initializer_list 쪽으로 해석될 수 있어, vector 문서에서 자주 경고하는 “두 요소짜리 리스트 vs (size, value)” 혼동과 연결됩니다.

• vector v(10, 20): 크기 10, 값 20.
• vector v{10, 20}: 요소 두 개인 리스트 10, 20 → initializer_list 생성자.

커스텀 클래스에서도 일반 생성자와 initializer_list 생성자가 함께 있으면, {}는 후자를 우선 시도합니다(이 글 앞쪽 “우선순위” 절 참고). API 설계 시 “요소 나열”과 “두 스칼라 인자”를 동시에 두면 사용자가 혼동하기 쉬우므로, ()와 {}의 의미를 팀 규칙으로 정리하거나 explicit·별도 팩토리 함수로 의도를 나누는 경우가 많습니다.

vector에 리스트를 넣을 때 내부적으로는 initializer_list 범위로 한 번에 삽입하는 경로가 사용되며, 이미 길이를 아는 경우 reserve 후 assign/insert와의 미세한 차이는 있지만, 대부분은 가독성과 “모호성 없는 호출 문법”이 더 큰 이슈입니다.

실전 패턴 보강

• API에서 “여러 값 나열”: select({...}), 옵션 플래그 집합, 테스트 픽스처 구성 등에 initializer_list를 쓰면 호출부가 간결해집니다. 다만 템플릿 추론과 섞이면 의도치 않은 initializer_list 선택이 나올 수 있어, 공개 API는 오버로드 최소화가 중요합니다.
• 비용이 큰 타입: initializer_list<string>처럼 요소가 비싼 타입이면, 호출부에서 임시 문자열이 여러 개 만들어질 수 있습니다. 이때는 string_view 기반 오버로드나 span/vector를 받는 별도 API를 고려합니다.
• 명시적 균일 초기화: 팀에서 ()/{} 규칙을 통일하면(예: 컨테이너는 {}, 스칼라 변환은 ()), 리뷰 시 “모호한 중괄호” 논쟁을 줄일 수 있습니다.

성능 고려사항

• 할당: initializer_list 자체는 보통 추가 힙 할당 없이 배열을 가리킵니다. 그러나 이를 vector에 넣는 과정에서 컨테이너 쪽 할당은 발생합니다. 크기를 미리 알면 reserve로 재할당 횟수를 줄일 수 있습니다.
• 이중 작업: 직접 initializer_list를 순회하며 push_back만 반복하면, vector에 넘길 때와 비교해 불필요한 한 번 더 순회가 될 수 있습니다. 가능하면 범위 생성자/할당자를 사용하거나, 한 번의 순회로 필요한 용량을 계산합니다.
• 인라인 배열: 요소가 많고 핫 루프에서 매번 리스트 리터럴을 만들면, 컴파일러·최적화에 따라 스택 사용과 캐시 영향이 달라질 수 있습니다. 이런 경우 정적 array/vector 상수로 빼 두는 편이 측정상 유리한 경우가 있습니다.

FAQ

Q1: initializer_list는 언제 사용?

A:

• 컨테이너 초기화
• 가변 인자 함수
• 균일 초기화

Q2: 우선순위는?

A: initializer_list 생성자가 우선. {}는 항상 initializer_list 시도.

Q3: 성능은?

A: 경량 프록시. 복사 비용 낮음.

Q4: 수정 가능?

A: 불가. 읽기 전용.

Q5: 빈 리스트는?

A: {{}} 사용. {}는 기본 생성자.

Q6: initializer_list 학습 리소스는?

A:

• “Effective Modern C++”
• cppreference.com
• “C++ Primer”

---

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

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

• C++ initializer_list | “초기화 리스트” 가이드
• C++ 균일 초기화 | “Uniform Initialization” 가이드
• C++ explicit Keyword | “explicit 키워드” 가이드

관련 글

• C++ default와 delete |
• C++ explicit Keyword |
• 배열과 리스트 | 코딩 테스트 필수 자료구조 완벽 정리
• C++ Adapter Pattern 완벽 가이드 | 인터페이스 변환과 호환성
• C++ ADL |

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

이 부록은 앞선 본문에서 다룬 주제(「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’ 가이드」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

1. 입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
2. 핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
3. 실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
4. 호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
5. 부하 후 검증: 피크 대비 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, constructor, 초기화, C++11 등으로 검색하시면 이 글이 도움이 됩니다.