C++ initializer_list 생성자: vector{10, 20}과 (10, 20)이 다른 이유와 중괄호 초기화 우선순위
이 글의 핵심
std::initializer_list를 받는 생성자로 {1, 2, 3} 형태의 초기화를 지원하는 방법과, 중괄호 초기화에서 initializer_list 생성자가 다른 생성자보다 먼저 선택되는 규칙을 정리합니다. 요소가 항상 복사되고 unique_ptr 같은 이동 전용 타입은 넣을 수 없는 이유, auto·템플릿 추론 규칙, 수명 함정, 그리고 흔히 잘못 알려진 빈 리스트 전달법({{}}는 빈 리스트가 아님)까지 컴파일해 확인한 결과로 다룹니다.
초기화 리스트 생성자란?
std::initializer_list<T>를 매개변수로 받는 생성자를 두면, 표준 컨테이너처럼 {1, 2, 3} 형태의 중괄호 목록으로 객체를 만들 수 있습니다. C++11에서 균일 초기화와 함께 들어온 기능으로, 컴파일러가 중괄호 안의 값들로 임시 배열을 만들고 그 배열을 가리키는 initializer_list를 생성자에 넘깁니다. 개수가 정해지지 않은 같은 타입의 값을 받는다는 점에서 가변 인자 템플릿과 비슷해 보이지만, 모든 요소가 한 가지 타입 T로 변환되어야 하고 요소가 읽기 전용이라는 제약이 있습니다. 이 두 제약이 뒤에서 다룰 narrowing 에러와 “항상 복사된다”는 문제의 뿌리입니다.
#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
}IntArray는 설명을 위해 new[]를 직접 썼지만, 복사 생성자와 대입 연산자를 정의하지 않았기 때문에 IntArray b = arr;처럼 복사하는 순간 두 객체가 같은 포인터를 delete[]하게 됩니다. 실무 코드라면 std::vector<int> data를 멤버로 두고 data(list)로 초기화하는 것이 맞습니다. 또 멤버 초기화는 초기화 리스트의 순서가 아니라 멤버 선언 순서로 진행되므로, 위처럼 data가 size보다 먼저 선언된 상태에서 data(new int[size])라고 썼다면 초기화되지 않은 size를 읽게 됩니다. 예제가 list.size()를 쓴 이유입니다(-Wall이면 -Wreorder 경고가 이 문제를 알려 줍니다).
표준 컨테이너와 함께
#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};
}실전 예시
행렬 클래스
#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();
}중첩된 initializer_list<initializer_list<int>>로 2차원 리터럴을 받는 방식은 호출부가 수학 표기와 비슷해져 읽기 좋지만, 컴파일러는 각 행의 길이가 같은지 검사해 주지 않습니다. {{1, 2, 3}, {4, 5}}도 문제없이 컴파일되고, cols는 첫 행 기준으로 3이 되어 이후 cols를 믿고 인덱싱하는 코드가 범위를 벗어납니다. 빈 목록 {}를 넘기면 list.begin()->size()가 존재하지 않는 요소를 역참조합니다. 실제로 쓰려면 생성자에서 list.size() == 0을 먼저 처리하고, 행마다 row.size() != cols이면 예외를 던지는 검증을 넣어야 합니다. 크기가 컴파일 타임에 정해지는 행렬이라면 std::array<std::array<int, 3>, 3>처럼 타입에 크기를 담는 편이 이런 검사를 컴파일러에게 맡길 수 있습니다.
설정 클래스
#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();
}요소 타입을 std::pair<const std::string, std::string>, 즉 std::map의 value_type과 같게 둔 덕분에 {"host", "localhost"} 같은 안쪽 중괄호가 곧바로 pair로 변환됩니다. 같은 키가 두 번 나오면 동작이 구현 방식에 따라 달라진다는 점은 알아 둘 만합니다. 이 Config는 settings[key] = value로 넣으므로 나중 값이 이깁니다. 반면 std::map의 initializer_list 생성자는 insert와 같은 의미라서 이미 있는 키를 무시하고 먼저 나온 값이 남습니다. 설정 파일을 리터럴로 옮겨 적다가 키를 중복으로 적었을 때 어느 쪽이 적용될지가 타입마다 다르므로, 중복을 에러로 취급하고 싶다면 insert의 반환값을 확인해 예외를 던지는 편이 명확합니다.
가변 인자 함수
#include <initializer_list>
#include <iostream>
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
}C 스타일 가변 인자(...)와 달리 타입이 검사되고, 가변 인자 템플릿과 달리 함수가 템플릿이 아니어서 헤더에 구현을 둘 필요도 없고 인스턴스화가 늘어나지도 않습니다. 대신 모든 인자가 같은 타입이어야 하므로, sum({1, 2, 3.5})는 3.5가 int로 좁혀지는 narrowing이라 컴파일 에러입니다. 반대로 average({1, 2, 3})은 정수 상수가 double로 정확히 표현되므로 narrowing이 아니어서 컴파일됩니다. 주의할 점은 이 예외가 상수에만 적용된다는 것입니다. int n = 2; average({1.0, n});처럼 int 변수를 넣으면, 값이 double로 정확히 표현되더라도 정수→부동소수점 변환은 narrowing으로 취급되어 narrowing conversion of 'n' from 'int' to 'double' 에러가 납니다. 이때는 static_cast<double>(n)으로 의도를 드러내야 합니다.
빌더 패턴
#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
}select({"id", "name", "email"})는 문자열 리터럴 세 개가 각각 std::string 임시 객체로 만들어진 뒤, columns = cols에서 다시 한 번 vector로 복사됩니다. 빌더처럼 한 번만 호출되는 코드에서는 문제가 되지 않지만, 요소가 복사된다는 사실은 아래 “요소는 이동되지 않고 항상 복사된다”에서 성능과 컴파일 에러 양쪽으로 다시 등장합니다.
우선순위
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 생성자
}중괄호 초기화는 두 단계로 생성자를 고릅니다. 먼저 initializer_list 생성자만 후보로 놓고, 중괄호 안의 값들을 리스트 하나로 보고 변환이 가능한지 봅니다. 여기서 하나라도 맞으면 다른 생성자가 더 정확히 맞더라도 고려조차 하지 않습니다. 첫 단계에서 맞는 게 없을 때만 모든 생성자를 대상으로 일반 오버로드 해석을 합니다. 그래서 std::initializer_list<double> 생성자가 있으면 MyClass{10}처럼 int를 넣어도 double 리스트 쪽이 선택되고, 심지어 initializer_list<int> 생성자에 {1.5}를 넣으면 다른 생성자로 넘어가는 대신 narrowing 에러가 납니다. “더 잘 맞는 생성자가 있는데 왜 저걸 부르지?”라는 혼란은 대부분 이 규칙 때문입니다.
괄호 대신 중괄호를 쓰는 이유 중 하나인 most vexing parse도 같이 기억해 둘 만합니다. MyClass obj();는 객체가 아니라 함수 선언으로 해석되고, MyClass obj{};는 기본 생성자를 부르는 객체 정의입니다.
자주 발생하는 문제
생성자 선택이 바뀌는 문제
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 생성자 (우선!)
}이 문제가 실무에서 까다로운 이유는 라이브러리 쪽 변경이 호출부의 의미를 조용히 바꾼다는 데 있습니다. 처음에 MyClass(int, int)만 있던 클래스를 사용자들이 MyClass{1, 2}로 쓰고 있었다면, 나중에 initializer_list<int> 생성자를 추가하는 순간 기존 호출이 모두 새 생성자로 넘어갑니다. 컴파일 에러도 경고도 없습니다. 그래서 initializer_list 생성자는 클래스를 처음 설계할 때 넣을지 결정해야 하고, 나중에 추가해야 한다면 기존 중괄호 호출부를 전부 검색해 확인해야 합니다. 템플릿 코드에서 T{args...}와 T(args...) 중 무엇을 쓸지도 같은 이유로 신중해야 하는데, 표준 라이브러리의 make_unique와 emplace_back이 괄호 초기화를 쓰는 것도 이 때문입니다.
narrowing 변환
// ❌ narrowing 에러
std::initializer_list<int> list = {1, 2, 3.14}; // 에러
// ✅ 명시적 변환
std::initializer_list<int> list = {1, 2, static_cast<int>(3.14)};빈 리스트
class MyClass {
public:
MyClass() {
std::cout << "기본 생성자" << std::endl;
}
MyClass(std::initializer_list<int> list) {
std::cout << "initializer_list 생성자, 크기 " << list.size() << std::endl;
}
};
int main() {
MyClass obj1; // 기본 생성자
MyClass obj2{}; // 기본 생성자 (빈 리스트 아님!)
MyClass obj3{{}}; // initializer_list 생성자, 크기 1 (!)
MyClass obj4({}); // initializer_list 생성자, 크기 0
}빈 중괄호 {}는 기본 생성자가 있으면 기본 생성자를 부릅니다. 여기까지는 잘 알려져 있는데, 빈 리스트를 넘기는 방법으로 흔히 소개되는 obj3{{}}는 빈 리스트가 아닙니다. 바깥 중괄호가 리스트이고 안쪽 {}는 그 리스트의 첫 요소인 int를 값 초기화(0)하므로, 결과는 요소 하나짜리 {0}입니다. 컴파일도 되고 생성자도 맞게 불리니 출력으로 크기를 찍어 보기 전에는 알아차리기 어려운 종류의 실수입니다. 정말로 빈 리스트를 넘기려면 괄호 안에 넣은 obj4({})나 MyClass{std::initializer_list<int>{}}처럼 타입을 명시합니다.
요소는 이동되지 않고 항상 복사된다
struct Tracked {
Tracked(const char*) { std::cout << "construct\n"; }
Tracked(const Tracked&) { std::cout << "copy\n"; }
Tracked(Tracked&&) noexcept { std::cout << "move\n"; }
};
std::vector<Tracked> v{"a", "b"};
// construct, construct, copy, copy
std::vector<Tracked> w;
w.reserve(2);
w.emplace_back("a");
w.emplace_back("b");
// construct, constructinitializer_list<T>가 가리키는 배열의 요소는 const T입니다. const 객체에서는 이동할 수 없으므로, 컨테이너는 임시 배열에 만들어진 요소를 한 번 더 복사합니다. Tracked에 이동 생성자가 있는데도 move가 한 번도 찍히지 않는 것이 그 증거입니다. int 같은 작은 타입은 상관없지만, 긴 std::string이나 큰 구조체를 수백 개 나열하는 테이블 초기화라면 할당과 복사가 두 배가 됩니다.
같은 이유로 이동 전용 타입은 아예 넣을 수 없습니다.
std::vector<std::unique_ptr<int>> ptrs{std::make_unique<int>(1)}; // ❌ 컴파일 에러
// GCC 10: static assertion failed: result type must be constructible from value type of input range
std::vector<std::unique_ptr<int>> ptrs2;
ptrs2.push_back(std::make_unique<int>(1)); // ✅에러가 내 코드가 아니라 stl_uninitialized.h 내부의 static_assert로 나와서, 처음 보면 원인이 중괄호 초기화라는 것을 떠올리기 어렵습니다. unique_ptr, std::thread, std::mutex를 담는 컨테이너를 만들 때 한 번씩 부딪히는 문제이고, 해결은 reserve 후 emplace_back/push_back으로 넣거나 요소를 만드는 헬퍼 함수를 두는 것입니다. 직접 만드는 클래스라면 initializer_list 생성자와 별도로 가변 인자 템플릿 생성자(template <typename... Args> MyVec(Args&&... args))를 두면 이동 전용 타입도 받을 수 있습니다.
auto와 템플릿 추론
auto a = {1, 2}; // std::initializer_list<int>
auto b{1}; // int (N3922 규칙. 초기 C++11/14 컴파일러는 initializer_list<int>로 추론했고, 지금의 GCC는 -std=c++11에서도 int)
auto c{1, 2}; // ❌ error: direct-list-initialization of 'auto' requires exactly one element
template <typename T> void f(T);
template <typename T> void g(std::initializer_list<T>);
f({1, 2, 3}); // ❌ no matching function for call to 'f(<brace-enclosed initializer list>)'
g({1, 2, 3}); // ✅ T = intauto는 = {...} 형태에서만 중괄호를 initializer_list로 추론하는 특별 규칙이 있고, 일반 템플릿 매개변수 T는 중괄호에서 아무것도 추론하지 못합니다. 이 차이 때문에 emplace_back({1, 2})나 std::make_unique<Widget>({1, 2})처럼 템플릿을 거쳐 중괄호를 전달하는 코드는 컴파일되지 않습니다. 자세한 내용과 우회법은 완벽 전달이 실패하는 경우에 정리했습니다. 매개변수 타입을 std::initializer_list<T>로 명시한 g처럼 쓰면 추론이 됩니다.
initializer_list를 반환하거나 멤버로 저장
std::initializer_list<int> bad() {
return {1, 2, 3}; // ⚠️ GCC: returning temporary 'initializer_list' does not extend
// the lifetime of the underlying array [-Winit-list-lifetime]
}
class Holder {
std::initializer_list<int> values_; // ❌ 멤버로 보관
public:
Holder(std::initializer_list<int> v) : values_(v) {} // 생성자가 끝나면 배열 수명 종료 가능
};initializer_list는 배열을 소유하지 않는 포인터와 길이일 뿐입니다. 지역 변수로 auto il = {1, 2, 3};처럼 만들면 배열 수명이 그 변수만큼 연장되지만, 함수에서 반환하거나 멤버에 저장하면 원래 배열이 사라진 뒤에도 포인터만 남습니다. GCC는 반환하는 경우를 -Winit-list-lifetime(기본 활성)으로 경고해 주지만, 멤버로 보관하는 경우는 경고 없이 넘어가는 경우가 많습니다. 값을 오래 들고 있어야 한다면 생성자에서 곧바로 std::vector로 복사해 두는 것이 원칙입니다.
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의 size()로 필요한 용량을 먼저 알 수 있으므로 한 번의 할당으로 모든 요소를 복사합니다. 그래서 성능보다는 가독성과 “모호성 없는 호출 문법”이 더 큰 이슈입니다. 특히 std::vector<std::string> v{3, "x"}는 문자열 요소 두 개가 아니라 크기 3인 벡터를 만든다는 점이 헷갈리기 쉽습니다. 3이 std::string으로 변환되지 않아 첫 단계의 initializer_list 후보가 탈락하고, 일반 생성자 (size, value)가 선택되기 때문입니다. 요소 타입에 따라 같은 모양의 중괄호가 다른 생성자로 해석되므로, 템플릿 코드에서 std::vector<T>{n, value}를 쓰면 T에 따라 의미가 바뀔 수 있습니다.
실전 패턴 보강
- API에서 “여러 값 나열”:
select({...}), 옵션 플래그 집합, 테스트 픽스처 구성 등에initializer_list를 쓰면 호출부가 간결해집니다. 다만 템플릿 추론과 섞이면 의도치 않은initializer_list선택이 나올 수 있어, 공개 API는 오버로드 최소화가 중요합니다. - 비용이 큰 타입:
initializer_list<string>처럼 요소가 비싼 타입이면, 호출부에서 임시 문자열이 여러 개 만들어질 수 있습니다. 이때는string_view기반 오버로드나span/vector를 받는 별도 API를 고려합니다. - 명시적 균일 초기화: 팀에서
()/{}규칙을 통일하면(예: 컨테이너는{}, 스칼라 변환은()), 리뷰 시 “모호한 중괄호” 논쟁을 줄일 수 있습니다.
성능 고려사항
- 할당:
initializer_list자체는 보통 추가 힙 할당 없이 배열을 가리킵니다. 그러나 이를vector에 넣는 과정에서 컨테이너 쪽 할당은 발생합니다. 크기를 미리 알면reserve로 재할당 횟수를 줄일 수 있습니다. - push_back 반복: 이 글 첫 예제의
MyVector처럼 리스트를 순회하며push_back을 반복하면, 용량을 모르는 채로 늘려 가므로 재할당이 여러 번 일어날 수 있습니다. 멤버 초기화에서data(list)로vector의initializer_list생성자에 그대로 넘기거나, 최소한data.reserve(list.size())를 먼저 호출하는 편이 낫습니다. - 인라인 배열: 요소가 많고 핫 루프에서 매번 리스트 리터럴을 만들면, 컴파일러·최적화에 따라 스택 사용과 캐시 영향이 달라질 수 있습니다. 이런 경우 정적
array/vector상수로 빼 두는 편이 측정상 유리한 경우가 있습니다.
같이 보면 좋은 글
- C++11 중괄호 초기화: narrowing 방지, Most Vexing Parse, vector
{10}과 (10)의 차이 - 래퍼 함수에서 인자가 복사될 때: 유니버설 참조와 std::forward로 완벽한 전달 구현하기
- C++ explicit 키워드: 암시적 변환 막기, explicit operator bool, C++20 explicit(bool)
- C++ default와 delete
- 배열과 연결 리스트