C++ Copy Initialization | "복사 초기화" 가이드
이 글의 핵심
복사 초기화(copy initialization) 는 = expr 형태로 변수를 초기화하는 방식입니다. 리스트 초기화 {}와 구분되며, 이동 의미론·RVO/NRVO로 복사가 생략되는 경우가 많습니다. 복사·이동 생성자와 함께 보면 동작을 정리하기 좋습니다.
복사 초기화란?
복사 초기화(copy initialization) 는 = expr 형태로 변수를 초기화하는 방식입니다. 리스트 초기화 {}와 구분되며, 이동 의미론·RVO/NRVO로 복사가 생략되는 경우가 많습니다. 복사·이동 생성자와 함께 보면 동작을 정리하기 좋습니다.
int x = 10; // 복사 초기화
std::string s = "Hi"; // 복사 초기화
int y(10); // 직접 초기화
std::string s2("Hi"); // 직접 초기화왜 필요한가?:
- 가독성: 대입 연산자와 유사한 문법으로 직관적
- 호환성: C 스타일 초기화와 호환
- 암시적 변환: 타입 변환을 자동으로 수행
// 복사 초기화: 암시적 변환 허용
std::string s = "Hello"; // const char* → std::string
// 직접 초기화: 명시적
std::string s2("Hello");동작 원리:
복사 초기화는 다음 단계로 수행됩니다:
- 임시 객체 생성: 우변 표현식 평가
- 복사/이동 생성자 호출: 임시 객체를 변수로 복사/이동
- 복사 생략(Copy Elision): 컴파일러가 2단계를 최적화로 제거 가능
class Widget {
public:
Widget(int x) { std::cout << "생성자\n"; }
Widget(const Widget&) { std::cout << "복사 생성자\n"; }
};
Widget w = 10; // "생성자" (복사 생략됨)
// 개념적으로는: Widget temp(10); Widget w(temp);
// 실제로는: Widget w(10); (최적화)직접 초기화 vs 복사 초기화
class Widget {
public:
explicit Widget(int x) {}
};
// ❌ 복사 초기화: explicit 생성자 불가
// Widget w1 = 10;
// ✅ 직접 초기화: explicit 생성자 가능
Widget w2(10);
Widget w3{10};차이점 상세:
| 특징 | 복사 초기화 | 직접 초기화 |
|---|---|---|
| 문법 | T obj = expr; | T obj(expr); 또는 T obj{expr}; |
| explicit 생성자 | ❌ 불가 | ✅ 가능 |
| 암시적 변환 | ✅ 허용 | ✅ 허용 |
| 복사 생성자 필요 | ✅ 필요 (생략 가능) | ❌ 불필요 |
| 사용 위치 | 변수, 반환값, 인자 | 변수 |
실무 예시:
class FileHandle {
public:
explicit FileHandle(const std::string& path) {
// 파일 열기
}
};
// ❌ 복사 초기화: 실수로 암시적 변환 방지
// FileHandle f = "data.txt";
// ✅ 직접 초기화: 명시적
FileHandle f("data.txt");
FileHandle f2{"data.txt"};
// ✅ explicit의 이점: 의도하지 않은 변환 방지
void processFile(FileHandle handle) {}
// processFile("data.txt"); // 에러: explicit 생성자
processFile(FileHandle{"data.txt"}); // OK: 명시적복사 생성자 필요성:
class NonCopyable {
public:
NonCopyable(int x) {}
NonCopyable(const NonCopyable&) = delete; // 복사 금지
};
// ❌ 복사 초기화: 복사 생성자 필요 (생략되더라도)
// NonCopyable obj1 = NonCopyable(10); // 에러
// ✅ 직접 초기화: 복사 생성자 불필요
NonCopyable obj2(10); // OK
NonCopyable obj3{10}; // OK실전 예시
예시 1: 기본 타입
// 복사 초기화
int x = 10;
double d = 3.14;
char c = 'A';
// 직접 초기화
int x(10);
double d(3.14);
char c('A');
// 균일 초기화
int x{10};
double d{3.14};
char c{'A'};예시 2: 클래스
class String {
std::string data;
public:
String(const char* str) : data(str) {}
String(const String& other) : data(other.data) {
std::cout << "복사 생성자" << std::endl;
}
};
// 복사 초기화
String s1 = "Hello"; // const char* -> String
// 직접 초기화
String s2("Hello");예시 3: 암시적 변환
class Number {
int value;
public:
Number(int v) : value(v) {} // 암시적 변환 허용
};
void func(Number n) {}
int main() {
func(42); // int -> Number (복사 초기화)
Number n = 42; // 복사 초기화
}예시 4: 반환값
std::string getName() {
return "Alice"; // 복사 초기화
}
int getValue() {
int x = 10;
return x; // 복사 초기화
}explicit과 초기화
class Widget {
public:
explicit Widget(int x) {}
};
// ❌ 복사 초기화
// Widget w1 = 10;
// void func(Widget w) {}
// func(10);
// ✅ 직접 초기화
Widget w2(10);
Widget w3{10};자주 발생하는 문제
문제 1: explicit 생성자
class Array {
public:
explicit Array(size_t size) {}
};
// ❌ 복사 초기화
// Array arr = 10;
// ✅ 직접 초기화
Array arr(10);
Array arr2{10};문제 2: 변환 연산자
class Fraction {
public:
Fraction(int n, int d) {}
operator double() const {
return /* ... */;
}
};
Fraction f(1, 2);
double d = f; // 복사 초기화 (변환)문제 3: 초기화 리스트
// 복사 초기화
std::vector<int> v1 = {1, 2, 3};
// 직접 초기화
std::vector<int> v2{1, 2, 3};
// 둘 다 동일한 결과문제 4: auto 추론
auto x = 10; // int
auto y = {10}; // initializer_list<int>
auto z{10}; // C++17: int, C++11/14: initializer_list<int>성능 고려사항
// 복사 초기화
std::string s1 = "Hello"; // 임시 객체 생성 가능
// 직접 초기화
std::string s2("Hello"); // 직접 생성
// RVO로 최적화됨복사 생략(Copy Elision) 최적화:
현대 C++ 컴파일러는 복사 초기화 시 복사를 생략하여 직접 초기화와 동일한 성능을 냅니다.
class Widget {
public:
Widget(int x) { std::cout << "생성자\n"; }
Widget(const Widget&) { std::cout << "복사 생성자\n"; }
};
Widget createWidget() {
return Widget(10); // 복사 초기화
}
int main() {
Widget w = createWidget();
// 출력: "생성자" (복사 생략됨)
// 복사 생성자 호출 없음!
}RVO (Return Value Optimization):
std::string getName() {
std::string name = "Alice";
return name; // 복사 초기화
}
int main() {
std::string s = getName();
// RVO로 복사 없이 직접 생성됨
}성능 비교:
| 초기화 방법 | 복사 생성자 호출 | 최적화 후 |
|---|---|---|
Widget w = Widget(10); | 개념적으로 필요 | 생략됨 |
Widget w(10); | 불필요 | 불필요 |
Widget w{10}; | 불필요 | 불필요 |
실무 권장:
- 일반적인 경우: 복사 초기화 사용 (가독성)
- explicit 생성자: 직접 초기화 사용
- 성능 걱정 없음: 컴파일러가 최적화
다른 초기화 방식과의 관계
복사 초기화는 리스트 초기화 T x = {a};, 직접 초기화 T x(a);, 균일 초기화 T x{a};와 겹치는 영역이 있습니다.
| 문법 | 분류 | explicit 생성자 | 좁은 의미의 “복사 초기화” |
|---|---|---|---|
T x = v; | 복사 초기화 | 사용 불가 | 예 |
T x(v);, T x{v} | 직접 초기화 | 사용 가능 | 아님 |
T x = {a,b} | 문맥에 따라 다름 | 컨테이너·클래스마다 규칙 상이 | 종종 = 와 리스트로 읽힘 |
핵심은 = 가 있으면 우선 복사 초기화 규칙을 타고, 그다음 변환·생성자 해석이 이뤄진다는 점입니다. 팀 가이드에서 “스칼라·문자열은 = , 리소스 핸들은 {} 또는 직접”처럼 나누면 리뷰가 수월합니다.
실전 활용 사례 (보강)
- 가독성 우선 지역 변수:
auto s = std::string("x");처럼 의도가 “값 하나로 초기화”일 때=가 자연스럽습니다. - 템플릿·자동 추론과 함께:
auto x = f();는 복사 초기화 형태입니다. 반환형이 값이면 이동/RVO와 잘 맞습니다. - 예외 안전:
T x = factory();에서 RVO가 되면 예외 전에 불필요한 중간 객체가 줄어듭니다(C++17 mandatory elision 케이스).
성능 영향 (세부)
- C++17 이후 prvalue에서의 복사 생략이 의무인 경우가 있어,
T x = T(args);형태도 실제 복사·이동이 없이 대상에 직접 생성될 수 있습니다. - 여전히 암시적 변환이 끼면 임시 객체·변환 연산이 생길 수 있습니다. 예:
std::string s = "hi";는 개념적으로 변환을 거치지만 최적화로 얇아질 수 있습니다. - 거대한 객체를 복사 초기화로 받을 때만 문제가 될 경우는 드뭅니다. 이동 가능 타입이면 이동, RVO면 생성 한 번입니다.
컴파일러 최적화
- Mandatory copy elision (C++17):
T t = T(...);같은 특정 prvalue 패턴은 복사/이동을 의무적으로 생략합니다. - NRVO: 이름 붙은 지역 변수를 반환할 때 컴파일러가 객체를 호출자 공간에 직접 구축할 수 있습니다(조건은 구현·상황에 따름).
std::move남용 금지: 반환값에return std::move(local);는 종종 NRVO를 막습니다.return local;이 기본입니다.
흔한 실수 (보강)
explicit생성자 +=: 의도는 직접 초기화인데=를 쓴 경우. 컴파일 에러로 잘 걸립니다.auto y = {1};:initializer_list추론 이슈(C++17에서auto x{1};규칙도 정리). 복사 초기화와auto조합은 cppreferenceauto기준을 팀에서 고정하는 것이 좋습니다.- NonCopyable +
T x = f(): 복사/이동이 막혀 있으면 복사 초기화 경로 자체가 성립하지 않을 수 있습니다.
실무 패턴
패턴 1: 팩토리 함수
class Connection {
public:
explicit Connection(const std::string& host) {
// 연결 설정
}
};
Connection createConnection() {
return Connection("localhost"); // 복사 초기화 (RVO)
}
int main() {
Connection conn = createConnection(); // 복사 초기화
}패턴 2: 컨테이너 요소
class Widget {
public:
Widget(int x) { std::cout << "생성자\n"; }
Widget(const Widget&) { std::cout << "복사\n"; }
};
std::vector<Widget> widgets;
widgets.push_back(Widget(10)); // 복사 초기화
// 출력: "생성자" (복사 생략됨)패턴 3: 암시적 변환 활용
class Duration {
int seconds_;
public:
Duration(int s) : seconds_(s) {} // 암시적 변환 허용
int seconds() const { return seconds_; }
};
void wait(Duration d) {
std::cout << "대기: " << d.seconds() << "초\n";
}
int main() {
wait(5); // int → Duration (복사 초기화)
Duration d = 10; // 복사 초기화
}FAQ
Q1: 복사 초기화는 무엇인가요?
A: = 연산자를 사용하여 변수를 초기화하는 방식입니다. 암시적 변환을 허용하지만 explicit 생성자는 사용할 수 없습니다.
Q2: 직접 초기화는 무엇인가요?
A: () 또는 {}를 사용하여 변수를 초기화하는 방식입니다. explicit 생성자를 호출할 수 있습니다.
Q3: 주요 차이점은?
A: explicit 생성자 호출 여부입니다. 복사 초기화는 explicit 생성자를 호출할 수 없습니다.
Q4: 성능 차이는?
A: 현대 컴파일러는 RVO(Return Value Optimization)로 복사를 생략하므로 성능 차이가 없습니다.
Q5: 언제 사용해야 하나요?
A:
- 복사 초기화: 간단한 초기화, 가독성 우선
- 직접 초기화:
explicit생성자 필요, 명시적 의도
Q6: 복사 생성자가 없으면 어떻게 되나요?
A: 복사 초기화는 복사 생성자가 접근 가능해야 합니다 (생략되더라도). 복사 생성자가 delete되면 컴파일 에러입니다.
class NonCopyable {
public:
NonCopyable(int x) {}
NonCopyable(const NonCopyable&) = delete;
};
// NonCopyable obj = NonCopyable(10); // 에러
NonCopyable obj(10); // OKQ7: 반환값 최적화(RVO)는 항상 적용되나요?
A: C++17부터 특정 경우(prvalue)에는 필수입니다. 그 외에는 컴파일러 재량입니다.
Q8: 복사 초기화 학습 리소스는?
A:
- “Effective C++” by Scott Meyers
- “C++ Primer” by Lippman, Lajoie, Moo
- cppreference.com - Copy initialization
관련 글: 리스트 초기화, 이동 의미론, 복사·이동 생성자, RVO·NRVO.
한 줄 요약: 복사 초기화는 =로 변수를 초기화하며, 암시적 변환을 허용하지만 explicit 생성자는 사용할 수 없습니다.
관련 글: 리스트 초기화, 이동 의미론, 복사·이동 생성자, RVO·NRVO.
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ List Initialization | “리스트 초기화” 가이드
- C++ Move 시맨틱스 | “복사 vs 이동” 완벽 이해
- C++ 복사/이동 생성자 | “Rule of Five” 가이드
- C++ RVO/NRVO | “Return Value Optimization” 가이드
관련 글
- C++ Aggregate Initialization |
- C++ Aggregate Initialization 완벽 가이드 | 집합 초기화
- C++ call_once |
- C++ Default Initialization |
- C++ Dynamic Initialization |