핵심 요약
복사 생성자와 이동 생성자의 차이는 “무엇을 넘기는가”에 있습니다. 복사 생성자(T(const T&))는 원본을 그대로 둔 채 내용을 전부 복제하고, 이동 생성자(T(T&&))는 원본의 자원(힙 포인터 등)을 넘겨받아 원본을 valid-but-unspecified 상태로 남깁니다. 이름 있는 lvalue는 복사가, 임시 객체나 std::move로 캐스팅한 rvalue는 이동이 선택되며, 사용자 선언 소멸자가 있으면 이동 생성자가 암시적으로 만들어지지 않는다는 점이 흔한 함정입니다.
C++ 면접과 실무 코드 리뷰에서 복사 생성자와 이동 생성자 중 어느 쪽이 호출되는지, 또 왜 소멸자만 추가했는데 코드가 느려지는지는 자주 등장하는 주제입니다. 이 글에서는 최소 예제 코드로 복사/이동의 차이, 호출 시점, Rule of 0/3/5까지 정리합니다.
복사 생성자 vs 이동 생성자 차이: 무엇을 복제하고 무엇을 넘기나?
한 줄 답: 복사는 원본을 그대로 두고 내용을 복제하며(T(const T&)), 이동은 원본의 자원(힙 포인터·파일 핸들 등)을 넘겨받고 원본은 “유효하지만 값은 정해지지 않은 상태”로 남깁니다(T(T&&)).
-
cppreference 근거에 따르면 이동 생성자는 다른 객체의 자원을 “넘겨받고”, 인자로 받은 객체를 valid-but-unspecified(유효하지만 값은 정해지지 않은) 상태로 남겨둡니다. std::string이나 std::vector처럼 흔히 빈 상태로 남는 타입도 있고, std::unique_ptr처럼 표준이 명확하게 빈 상태(널)가 되도록 보장하는 타입도 있습니다. (출처: Copy constructors, Move constructors)
-
복사와 이동을 표로 비교하면 다음과 같습니다.
| 구분 | 시그니처 | 원본 상태 | 비용 | 대표 상황 |
|---|---|---|---|---|
| 복사 생성자 | T(const T&) | 그대로 유지 | 내용을 전부 복제 | 원본을 계속 사용해야 할 때 |
| 이동 생성자 | T(T&&) | valid-but-unspecified | 자원 포인터만 이전(저비용) | 임시 객체·std::move한 rvalue를 넘길 때 |
![복사는 객체 a와 b가 각자 힙 버퍼 [A B C]를 가져 버퍼가 2개가 되고 원본이 유지되며, 이동은 객체 b가 원래 힙 버퍼를 넘겨받고 객체 a는 ptr = nullptr인 빈 상태로 남아 버퍼가 1개인 비교 도식](/_astro/copy-vs-move-buffers-ko.j-MKOQBg_ZRRh1V.webp)
- 최소 예제로 힙 버퍼를 직접 들고 있는
Buffer클래스를 봅니다. 복사 생성자는 새 버퍼를 만들어 내용을memcpy로 복제하고, 이동 생성자는 포인터만 넘겨받은 뒤 원본 포인터를nullptr로 비웁니다.
#include <cstddef>
#include <cstring>
#include <iostream>
class Buffer {
public:
explicit Buffer(std::size_t n) : size_(n), data_(new char[n]{}) {}
// 복사 생성자: 새 힙 버퍼를 만들고 내용을 복제합니다
Buffer(const Buffer& other) : size_(other.size_), data_(new char[other.size_]) {
std::memcpy(data_, other.data_, size_);
std::cout << "copy ctor\n";
}
// 이동 생성자: 포인터만 넘겨받고 원본은 빈 상태로 둡니다
Buffer(Buffer&& other) noexcept : size_(other.size_), data_(other.data_) {
other.size_ = 0;
other.data_ = nullptr;
std::cout << "move ctor\n";
}
~Buffer() { delete[] data_; }
std::size_t size() const { return size_; }
bool empty() const { return data_ == nullptr; }
private:
std::size_t size_;
char* data_;
};
int main() {
Buffer a(1024);
Buffer b = a; // lvalue → 복사
std::cout << "a.size=" << a.size() << " b.size=" << b.size() << '\n';
Buffer c = std::move(a); // xvalue → 이동
std::cout << "a.empty=" << a.empty() << " c.size=" << c.size() << '\n';
}
실행 결과:
copy ctor
a.size=1024 b.size=1024
move ctor
a.empty=1 c.size=1024
언제 어느 쪽이 호출되나? (값 반환·임시 객체·std::move)
한 줄 답: 같은 타입의 rvalue(xvalue/prvalue)는 이동, lvalue(이름 있는 객체)는 복사가 호출되며, 이동 생성자가 없으면 const& 복사 생성자가 rvalue도 받아 복사로 대체(fallback)됩니다.
-
같은 타입끼리는 오버로드 해석 규칙에 따라 호출이 갈립니다. 이름이 있는 lvalue는 복사 생성자가, rvalue(임시 객체인 prvalue, std::move로 캐스팅한 xvalue)는 이동 생성자가 선택됩니다. 다만 이동 생성자가 없다면
const T&복사 생성자가 rvalue도 받아줄 수 있어 복사로 대체(fallback)됩니다. -
아래 코드는 일곱 가지 상황에서 어떤 생성자가 호출되는지 보여줍니다.
#include <iostream>
#include <utility>
struct Tracer {
Tracer() { std::cout << " default\n"; }
Tracer(const Tracer&) { std::cout << " copy\n"; }
Tracer(Tracer&&) noexcept { std::cout << " move\n"; }
};
Tracer make_prvalue() { return Tracer{}; } // 임시 객체를 그대로 반환
Tracer make_named() { Tracer t; return t; } // 이름 있는 지역 변수 반환
Tracer pick(bool f) { // 반환 대상이 두 개 → NRVO 어려움
Tracer x, y;
if (f) return x;
return y;
}
void take(Tracer) {} // 값으로 받는 매개변수
int main() {
Tracer a;
std::cout << "1) Tracer b = a;\n";
Tracer b = a;
std::cout << "2) Tracer c = std::move(a);\n";
Tracer c = std::move(a);
std::cout << "3) Tracer d = make_prvalue();\n";
Tracer d = make_prvalue();
std::cout << "4) Tracer e = make_named();\n";
Tracer e = make_named();
std::cout << "5) Tracer f = pick(true);\n";
Tracer f = pick(true);
std::cout << "6) const Tracer g; Tracer h = std::move(g);\n";
const Tracer g;
Tracer h = std::move(g);
std::cout << "7) take(b); take(Tracer{});\n";
take(b);
take(Tracer{});
(void)c; (void)d; (void)e; (void)f; (void)h; // 미사용 경고 방지
}
실행 결과:
default
1) Tracer b = a;
copy
2) Tracer c = std::move(a);
move
3) Tracer d = make_prvalue();
default
4) Tracer e = make_named();
default
5) Tracer f = pick(true);
default
default
move
6) const Tracer g; Tracer h = std::move(g);
default
copy
7) take(b); take(Tracer{});
copy
default
- 3번(임시 객체 반환, prvalue): 복사도 이동도 호출되지 않습니다. C++17부터 보장되는 복사 생략 덕분입니다. (참고: copy elision)
- 4번(이름 있는 지역 변수 반환): 출력에 move가 보이지 않는 것은 NRVO(Named Return Value Optimization)가 적용되었기 때문이며, NRVO는 표준이 보장하지 않는 최적화입니다.
-fno-elide-constructors로 컴파일하면 이 경우 move가 출력됩니다. - 5번(반환 후보가 두 개인 pick): NRVO를 적용하기 어려운 상황이라 암시적 이동(implicit move on return)이 적용되어 move가 출력됩니다.
- 6번(const 객체 + std::move):
const Tracer&&는 이동 생성자의Tracer&&에 바인딩되지 못하고const Tracer&에 바인딩되므로 copy가 출력됩니다.
- std::move는 자원을 실제로 옮기는 함수가 아니라 rvalue reference로의 캐스트일 뿐입니다. 자세한 설명은 C++ std::move, 복사를 줄이는 이유를 참고 바랍니다.
Rule of 0/3/5란? 직접 정의해야 할 때는?
한 줄 답: 자원 관리를 멤버에 맡기면 아무것도 쓰지 않아도 되고(Rule of 0), 소멸자·복사·이동 중 하나라도 직접 쓰면 나머지도 함께 검토해야 합니다(Rule of 3/5).
-
Rule of 0(0의 법칙)은 소멸자·복사/이동 생성자·복사/이동 대입 연산자를 하나도 직접 작성하지 않는 설계를 말합니다. std::string, std::vector, std::unique_ptr처럼 자원 관리를 이미 올바르게 해주는 멤버만 두면, 컴파일러가 생성해주는 특수 멤버 함수만으로 충분합니다.
-
Rule of 3(3의 법칙)은 소멸자·복사 생성자·복사 대입 연산자 중 하나라도 직접 정의했다면 나머지 둘도 함께 검토해야 한다는 규칙이고, Rule of 5(5의 법칙)는 여기에 이동 생성자와 이동 대입 연산자까지 포함합니다. 이동 생성자를 직접 선언하면 암시적 복사 생성자는 deleted 상태가 되므로, 복사도 필요하면 명시적으로 정의해야 합니다.
-
사용자가 소멸자, 복사 생성자, 복사 대입 연산자, 이동 대입 연산자 중 하나라도 직접 선언하면, 컴파일러는 이동 생성자를 암시적으로 선언해주지 않습니다. 이 상태에서 std::move를 호출해도 이동 생성자가 없으므로 복사 생성자로 대체됩니다. 이동이 꼭 필요하다면 이동 생성자를
= default로 명시해야 합니다.
#include <iostream>
#include <string>
#include <type_traits>
#include <utility>
struct Member {
Member() = default;
Member(const Member&) { std::cout << " Member copy\n"; }
Member(Member&&) noexcept { std::cout << " Member move\n"; }
};
struct RuleOfZero { // 특수 멤버 함수를 하나도 선언하지 않음
std::string name;
Member m;
};
struct DtorOnly { // 소멸자만 선언 → 암시적 이동 생성자가 만들어지지 않음
std::string name;
Member m;
~DtorOnly() {}
};
int main() {
std::cout << "RuleOfZero b = std::move(a);\n";
RuleOfZero a;
RuleOfZero b = std::move(a);
std::cout << "DtorOnly d = std::move(c);\n";
DtorOnly c;
DtorOnly d = std::move(c);
std::cout << std::boolalpha
<< "RuleOfZero nothrow move: "
<< std::is_nothrow_move_constructible_v<RuleOfZero> << '\n'
<< "DtorOnly nothrow move: "
<< std::is_nothrow_move_constructible_v<DtorOnly> << '\n';
}
실행 결과:
RuleOfZero b = std::move(a);
Member move
DtorOnly d = std::move(c);
Member copy
RuleOfZero nothrow move: true
DtorOnly nothrow move: false

- std::vector가 재할당될 때는 기존 원소를 새 메모리로 옮기면서
std::move_if_noexcept를 사용해, 이동 생성자가 예외를 던지지 않는다고 보장된 경우에만 이동을 쓰고 그렇지 않으면(복사 가능한 타입이라면) 안전을 위해 복사를 선택합니다. 그래서 이동 생성자를 작성할 때는noexcept를 붙이는 것이 좋습니다. (참고로 재할당이 일어나면 기존 반복자는 모두 무효화됩니다.)
#include <iostream>
#include <vector>
int copies = 0, moves = 0;
struct NoexceptMove {
NoexceptMove() = default;
NoexceptMove(const NoexceptMove&) { ++copies; }
NoexceptMove(NoexceptMove&&) noexcept { ++moves; }
};
struct ThrowingMove {
ThrowingMove() = default;
ThrowingMove(const ThrowingMove&) { ++copies; }
ThrowingMove(ThrowingMove&&) { ++moves; } // noexcept 없음
};
template <typename T>
void grow(const char* name) {
copies = moves = 0;
std::vector<T> v;
v.reserve(4);
for (int i = 0; i < 4; ++i) v.emplace_back(); // 용량 4를 채움
v.emplace_back(); // 5번째 → 재할당, 기존 4개 옮김
std::cout << name << ": copies=" << copies << " moves=" << moves << '\n';
}
int main() {
grow<NoexceptMove>("noexcept move");
grow<ThrowingMove>("throwing move");
}
실행 결과:
noexcept move: copies=0 moves=4
throwing move: copies=4 moves=0
[면접용 2문장] 복사 생성자는 원본 상태를 유지하기 위해 전체 데이터를 복제(
T(const T&))하며, 이동 생성자는 자원의 소유권만 넘겨받아 내용 복제를 피합니다(T(T&&)). 이동 생성자를 작성할 때는 vector 재할당 시 복사로 대체되지 않도록noexcept를 붙이고, 가급적 Rule of 0에 따라 컴파일러 자동 생성에 맡기는 것이 좋습니다.
이해했는지 Q&A로 확인해 볼까요?
Q1. 소멸자만 추가했더니 왜 코드가 느려졌습니까(복사가 발생합니까)?
A1. 사용자 선언 소멸자가 있으면 컴파일러가 암시적 이동 생성자를 만들어주지 않으므로, std::move를 사용해도 이동 대신 복사 생성자가 호출되기 때문입니다.
Q2. std::move에 const 객체를 전달하면 어떻게 됩니까?
A2. const T&&는 이동 생성자의 T&& 인자에 바인딩되지 못하고 const T&에 바인딩되므로, 이동 대신 복사 생성자가 호출됩니다.
Q3. 이동된 후의 원본 객체를 재사용해도 됩니까?
A3. 원본 객체는 유효하지만 값이 정해지지 않은(valid-but-unspecified) 상태가 되므로, 새로운 값을 대입하거나 소멸시키는 것은 안전하지만 현재 값을 읽는 것은 피해야 합니다.
더 많은 C++ 면접 질문은 C++ 기술면접 질문 10가지에서 확인할 수 있습니다.