C++ 이동 의미론 완벽 가이드 | rvalue 참조·std::move
들어가며: 벡터를 반환하면 복사가 폭증한다
”큰 벡터를 반환할 때마다 프로그램이 멈춰요”
이동 의미론(move semantics)은 C++11에서 추가된 핵심 기능이다. 예전 C++이나 레거시 코드만 보다 오면 “복사만 있는 줄 알았는데, 이동이 뭐지?”라고 느낄 수 있다. 비유하면 “이사할 때 가구를 통째로 들고 가는 것(이동)“과 “가구를 하나씩 복제해서 새 집에 놓는 것(복사)“의 차이다. 더 이상 쓰지 않는 객체는 복제할 필요 없이 소유권만 넘기면 되므로 이동이 훨씬 빠르다. 이 글을 읽으면
- lvalue와 rvalue의 차이를 명확히 알 수 있습니다.
- rvalue 참조(
T&&),std::move,std::forward를 올바르게 사용할 수 있습니다. - 자주 하는 실수와 해결법을 익힐 수 있습니다.
- 프로덕션에서 바로 적용할 수 있는 패턴을 배울 수 있습니다.
1. 문제 시나리오
시나리오 1: “벡터를 반환하면 복사가 너무 많아요”
"100만 개 원소 벡터를 함수에서 반환하면 프로그램이 몇 초 멈춰요."
"return vec 할 때마다 전체 메모리가 복사되는 것 같아요."상황: C++03에서는 return vec 시 복사 생성자가 호출되어 내부 버퍼 전체가 새 벡터로 복사됩니다. 100만 개 int면 4MB가 복사되고, main에서 받을 때 한 번 더 복사될 수 있어 최대 8MB 복사가 발생합니다.
해결 포인트: C++11에서는 return vec 시 자동으로 이동 생성자가 선택되거나 RVO가 적용됩니다. 복사 없이 포인터만 넘깁니다.
시나리오 2: “JSON 파싱 결과 전달 시 메모리 급증”
"대용량 JSON을 파싱한 nlohmann::json 객체를 여러 함수에 전달할 때 메모리가 부족해요."
"복사만 사용하면 10MB JSON이 3번 복사되면서 30MB가 됩니다."상황: nlohmann::json 객체는 내부적으로 동적 데이터를 가집니다. 복사만 사용하면 메모리 사용량이 급증합니다.
해결 포인트: std::move로 이동하면 포인터만 넘기므로 메모리 효율이 좋아집니다.
시나리오 3: “스레드 풀 작업 큐에 넣을 때 복사가 발생해요”
"std::function이나 std::packaged_task를 큐에 넣을 때 내부 캡처된 객체까지 복사돼요."
"캡처된 큰 벡터·맵이 매번 복제됩니다."상황: std::packaged_task를 큐에 넣을 때 복사하면 캡처된 큰 객체까지 복사됩니다.
해결 포인트: std::move로 이동하면 캡처된 객체를 복제하지 않고 큐로 넘길 수 있습니다.
시나리오 4: “네트워크 버퍼 전달 시 할당·복사 과다”
"수신한 std::vector<uint8_t> 버퍼를 파싱 함수로 넘길 때, 패킷 크기만큼 메모리 할당과 복사가 발생해요."상황: processBuffer(buffer)처럼 값으로 넘기면 복사가 발생합니다. 1MB 패킷이면 1MB 할당 + 1MB 복사입니다.
해결 포인트: processBuffer(std::move(buffer))로 넘기면 O(1)에 전달할 수 있습니다.
시나리오 5: “빌더 패턴에서 객체 조립 시 복사 과다”
"빌더가 여러 단계에서 std::string, std::vector를 누적한 뒤 최종 객체를 반환할 때, 각 단계마다 복사가 발생해요."상황: setName(name), addTag(tag) 등에서 매번 복사가 발생합니다.
해결 포인트: name_ = std::move(name)처럼 이동으로 받으면 복사를 줄일 수 있습니다.
복사 vs 이동 시각화
flowchart LR
subgraph copy[복사]
C1[원본] --> C2[데이터 복제]
C2 --> C3[대상]
C1 -.->|유지| C1
end
subgraph move[이동]
M1[원본] --> M2[포인터/핸들만 이전]
M2 --> M3[대상]
M1 -.->|빈 상태| M1
end
2. lvalue와 rvalue
기본 개념
lvalue는 “이름이 있는 변수” 또는 “주소를 취할 수 있는 식”입니다. rvalue는 “임시 값” 또는 “이동해도 되는 값”입니다.
#include <iostream>
int main() {
int x = 10; // x는 lvalue (이름 있음, 주소 있음)
int y = 20; // y는 lvalue
int z = x + y; // x + y는 rvalue (임시 값, 주소 없음)
int* p = &x; // ✅ OK: lvalue의 주소
// int* q = &(x + y); // ❌ 에러: rvalue의 주소 불가
std::cout << z << " " << *p << "\n";
return 0;
}실행 결과:
30 10lvalue vs rvalue 요약:
| 구분 | lvalue | rvalue |
|---|---|---|
| 예시 | 변수, *ptr, arr[i] | 42, x + y, func() 반환값 |
| 주소 | 취할 수 있음 | 취할 수 없음 |
| 대입 | 왼에 올 수 있음 | 오른쪽에만 |
왜 구분하나요?
이동은 “이 값은 곧 버려질 거므로, 복사하지 말고 가져가도 돼”라고 컴파일러에게 알려 주는 것입니다. 그 구분 기준이 lvalue/rvalue입니다. lvalue는 “위치가 정해진 값”, rvalue는 “이동해도 되는 임시”입니다.
함수 반환값
함수 반환값은 대부분 rvalue입니다(임시 객체이기 때문).
int getValue() {
return 42;
}
int& getRef() {
static int x = 10;
return x;
}
int main() {
int a = getValue(); // getValue()는 rvalue
int& b = getRef(); // getRef()는 lvalue
// getValue() = 100; // ❌ 에러: rvalue에 대입 불가
getRef() = 100; // ✅ OK: lvalue
}3. rvalue 참조와 std::move
rvalue 참조 기본 문법
일반 참조(T&)는 lvalue에만 붙일 수 있습니다. rvalue 참조(T&&) 는 “임시 값이나 곧 파괴될 값”에만 붙일 수 있게 만든 타입입니다.
int x = 10;
int& lref = x; // lvalue 참조
// int& lref2 = 42; // ❌ 에러: rvalue를 lvalue 참조로
int&& rref = 42; // ✅ rvalue 참조
// int&& rref2 = x; // ❌ 에러: lvalue를 rvalue 참조로코드 설명
int& lref = x;: 일반 참조는 이름 있는 변수(lvalue)에만 붙일 수 있습니다.int&& rref = 42;: rvalue 참조(&&)는 임시 값(rvalue)을 받을 수 있습니다.
const lvalue 참조
const T&는 예전부터 “임시 값도 받을 수 있는 참조”로 많이 썼습니다. 다만 const이기 때문에 수정·이동이 불가능합니다.
const int& ref1 = 10; // ✅ OK: const lvalue 참조는 rvalue 받을 수 있음
const int& ref2 = x; // ✅ OK: lvalue도 받을 수 있음
// ref1 = 20; // ❌ 에러: 수정 불가std::move: lvalue를 rvalue로 캐스팅
#include <string>
#include <utility>
#include <iostream>
int main() {
std::string str1 = "Hello";
std::string str2 = std::move(str1); // str1의 내용을 str2로 이동
std::cout << "str1: " << str1 << "\n"; // "" (비어있음)
std::cout << "str2: " << str2 << "\n"; // "Hello"
}주의: std::move는 실제로 이동하지 않습니다. lvalue를 rvalue로 캐스팅만 할 뿐입니다. 실제 “이동”은 이동 생성자나 이동 대입 연산자가 그 rvalue를 받을 때 일어납니다.
오버로딩: lvalue vs rvalue
void process(int& x) {
std::cout << "lvalue: " << x << "\n";
}
void process(int&& x) {
std::cout << "rvalue: " << x << "\n";
}
int main() {
int a = 10;
process(a); // lvalue: 10
process(20); // rvalue: 20
}코드 설명
process(int& x): lvalue를 받는 버전.process(int&& x): rvalue를 받는 버전.process(a):a는 lvalue이므로 첫 번째 함수가 호출됩니다.process(20):20은 rvalue이므로 두 번째 함수가 호출됩니다.
unique_ptr 이동
#include <memory>
#include <iostream>
int main() {
std::unique_ptr<int> ptr1 = std::make_unique<int>(42);
// std::unique_ptr<int> ptr2 = ptr1; // ❌ 에러: 복사 불가
std::unique_ptr<int> ptr2 = std::move(ptr1); // ✅ 이동
if (!ptr1) {
std::cout << "ptr1 is null\n";
}
std::cout << "*ptr2 = " << *ptr2 << "\n"; // 42
}실행 결과:
ptr1 is null
*ptr2 = 424. 이동 생성자와 이동 대입
복사 vs 이동 생성자
#include <iostream>
#include <algorithm>
#include <utility>
class Buffer {
int* data;
size_t size;
public:
size_t getSize() const { return size; }
Buffer(size_t s) : size(s), data(new int[s]) {
std::cout << "Constructor\n";
}
// 복사 생성자 (느림)
Buffer(const Buffer& other) : size(other.size), data(new int[other.size]) {
std::copy(other.data, other.data + size, data);
std::cout << "Copy constructor\n";
}
// 이동 생성자 (빠름)
Buffer(Buffer&& other) noexcept
: size(other.size), data(other.data) {
other.data = nullptr;
other.size = 0;
std::cout << "Move constructor\n";
}
~Buffer() {
delete[] data;
}
};
int main() {
Buffer b1(1000);
Buffer b2 = b1; // Copy constructor (복사)
Buffer b3 = std::move(b1); // Move constructor (이동)
}실행 결과:
Constructor
Copy constructor
Move constructor코드 상세 설명: 복사 생성자 (느림):
data(new int[other.size]): 새로운 메모리를 할당합니다.std::copy(...): 원본의 모든 데이터를 새 메모리로 복사합니다.- 결과: 원본과 복사본이 각자 독립적인 메모리를 가집니다. 이동 생성자 (빠름):
data(other.data): 원본의 포인터만 복사합니다. 메모리 할당 없음!other.data = nullptr: 핵심! 원본의 포인터를 nullptr로 설정합니다.other.size = 0: 원본의 크기도 0으로 설정합니다.- 결과: 포인터만 옮기므로 매우 빠름 (O(1)). 원본은 빈 상태가 됩니다.
왜
other.data = nullptr가 필수인가?: - 이동 후에도
other의 소멸자는 호출됩니다. - 소멸자에서
delete[] data를 실행하는데, nullptr로 설정하지 않으면 같은 메모리를 두 번 해제하는 버그가 발생합니다. delete[] nullptr는 안전하게 아무 일도 하지 않습니다.noexcept의 중요성:std::vector는 재할당 시 이동 생성자가noexcept이면 이동을 사용하며, 아니면 복사를 사용합니다.- 이동 중 예외가 발생하면 일부만 옮겨진 상태가 되어 복구가 어렵기 때문입니다.
이동 대입 연산자
class Buffer {
int* data;
size_t size;
public:
Buffer& operator=(Buffer&& other) noexcept {
if (this != &other) {
delete[] data;
data = other.data;
size = other.size;
other.data = nullptr;
other.size = 0;
std::cout << "Move assignment\n";
}
return *this;
}
};코드 상세 설명:
- 자기 대입 검사 (
if (this != &other)):a = std::move(a);같은 자기 대입을 방지합니다. - 기존 리소스 해제 (
delete[] data): 이동 대입은 이미 존재하는 객체에 대입하는 것이므로, 기존 메모리를 먼저 해제해야 합니다. - 리소스 이동:
data = other.data,size = other.size로 원본의 리소스를 가져옵니다. - 원본 무효화:
other.data = nullptr로 원본이 소멸될 때 이미 이동한 메모리를 해제하지 않도록 합니다.
Rule of Five
동적 메모리, 파일 핸들 등 스스로 관리하는 리소스가 있는 클래스에서는 다음 다섯 가지를 함께 고려합니다.
class Resource {
public:
~Resource();
Resource(const Resource& other);
Resource& operator=(const Resource& other);
Resource(Resource&& other) noexcept;
Resource& operator=(Resource&& other) noexcept;
};5. 완전한 이동 의미론 예제
예제 1: Rule of Five 완전 구현
#include <iostream>
#include <algorithm>
#include <utility>
class ManagedBuffer {
int* data_;
size_t size_;
public:
explicit ManagedBuffer(size_t size) : size_(size), data_(new int[size]) {
std::fill(data_, data_ + size_, 0);
std::cout << "Constructor(" << size_ << ")\n";
}
ManagedBuffer(const ManagedBuffer& other) : size_(other.size_), data_(new int[other.size_]) {
std::copy(other.data_, other.data_ + size_, data_);
std::cout << "Copy constructor\n";
}
ManagedBuffer(ManagedBuffer&& other) noexcept
: data_(other.data_), size_(other.size_) {
other.data_ = nullptr;
other.size_ = 0;
std::cout << "Move constructor\n";
}
ManagedBuffer& operator=(const ManagedBuffer& other) {
if (this != &other) {
delete[] data_;
size_ = other.size_;
data_ = new int[size_];
std::copy(other.data_, other.data_ + size_, data_);
std::cout << "Copy assignment\n";
}
return *this;
}
ManagedBuffer& operator=(ManagedBuffer&& other) noexcept {
if (this != &other) {
delete[] data_;
data_ = other.data_;
size_ = other.size_;
other.data_ = nullptr;
other.size_ = 0;
std::cout << "Move assignment\n";
}
return *this;
}
~ManagedBuffer() {
delete[] data_;
std::cout << "Destructor\n";
}
};
int main() {
ManagedBuffer a(100);
ManagedBuffer b = std::move(a); // Move constructor
ManagedBuffer c(50);
c = std::move(b); // Move assignment
}실행 결과:
Constructor(100)
Move constructor
Constructor(50)
Move assignment
Destructor
Destructor
Destructor예제 2: 빌더 패턴에서 이동 활용
#include <string>
#include <vector>
#include <utility>
class ConfigBuilder {
std::string name_;
std::vector<std::string> tags_;
std::vector<int> values_;
public:
ConfigBuilder& setName(std::string name) {
name_ = std::move(name); // 호출자가 넘긴 임시/이동 가능 값 활용
return *this;
}
ConfigBuilder& addTag(std::string tag) {
tags_.push_back(std::move(tag));
return *this;
}
ConfigBuilder& addValue(int value) {
values_.push_back(value);
return *this;
}
struct Config {
std::string name;
std::vector<std::string> tags;
std::vector<int> values;
};
Config build() {
return Config{
std::move(name_),
std::move(tags_),
std::move(values_)
};
}
};
int main() {
ConfigBuilder builder;
builder.setName("my-service")
.addTag("production")
.addTag("v1")
.addValue(42)
.addValue(100);
auto config = builder.build(); // 모든 멤버가 이동으로 전달
}예제 3: 팩토리 함수와 이동
#include <memory>
#include <vector>
#include <string>
std::unique_ptr<std::vector<int>> createFilteredVector(
const std::vector<int>& source, int threshold) {
auto result = std::make_unique<std::vector<int>>();
for (int x : source) {
if (x > threshold) result->push_back(x);
}
return result; // RVO 또는 이동
}
std::vector<std::string> loadLines(const std::string& path) {
std::vector<std::string> lines;
// 파일에서 읽어 lines에 추가...
return lines; // std::move 불필요, 컴파일러가 최적화
}
int main() {
std::vector<int> data = {1, 5, 10, 15, 20};
auto filtered = createFilteredVector(data, 8); // 이동
auto lines = loadLines("config.txt"); // RVO 또는 이동
}예제 4: 반환값 최적화 (RVO 권장)
// ✅ RVO (Return Value Optimization)
std::vector<int> createVector() {
std::vector<int> vec(1000);
return vec; // 이동 (또는 RVO)
}
// ❌ std::move 불필요
std::vector<int> createVector2() {
std::vector<int> vec(1000);
return std::move(vec); // 불필요! RVO 방해
}왜 return std::move(vec);가 나쁜가?:
return vec;만 쓰면 컴파일러가 RVO를 적용할 수 있습니다.return std::move(vec);를 쓰면 RVO 조건을 깨뜨려 무조건 이동 1번 발생합니다.- 결론: 지역 변수를 반환할 때는
std::move없이 그냥return vec;만 쓰세요.
6. Perfect Forwarding
문제: 래퍼에서 인자 복사
template <typename Func, typename Arg>
void logAndCall(Func func, Arg arg) { // ❌ arg가 복사됨
std::cout << "Calling function\n";
func(arg);
}
void process(std::string str) {
std::cout << "Processing: " << str << "\n";
}
int main() {
std::string text = "Hello";
logAndCall(process, text); // text가 2번 복사됨!
}해결: 유니버설 참조와 std::forward
#include <iostream>
#include <string>
#include <utility>
void process(const std::string& s) { std::cout << "lvalue: " << s << "\n"; }
void process(std::string&& s) { std::cout << "rvalue: " << s << "\n"; }
template <typename Func, typename Arg>
void logAndCall(Func func, Arg&& arg) {
std::cout << "Calling function\n";
func(std::forward<Arg>(arg));
}
int main() {
std::string text = "Hello";
logAndCall(process, text); // lvalue 전달
logAndCall(process, std::string("Hi")); // rvalue 전달
return 0;
}실행 결과:
Calling function
lvalue: Hello
Calling function
rvalue: Hi유니버설 참조 (T&&)
T&&가 “유니버설 참조”가 되는 것은 타입 T가 그 자리에서 추론될 때만입니다.
// 유니버설 참조 (타입 추론 발생)
template <typename T>
void func1(T&& arg); // ✅ 유니버설 참조
// rvalue 참조 (타입 고정)
void func2(int&& arg); // ❌ rvalue 참조만
template <typename T>
void func3(std::vector<T>&& arg); // ❌ rvalue 참조만std::move vs std::forward
// std::move: 항상 rvalue로
std::string str = "Hello";
process(std::move(str)); // 항상 rvalue
// std::forward: 조건부 (원래 타입 유지)
template <typename T>
void func(T&& arg) {
process(std::forward<T>(arg)); // lvalue면 lvalue, rvalue면 rvalue
}Perfect Forwarding 흐름도
flowchart LR
subgraph caller[호출자]
A1["lvalue 전달"]
A2["rvalue 전달"]
end
subgraph wrapper[래퍼 T&&]
B1["T = int&"]
B2["T = int"]
end
subgraph forward[std forward]
C1["lvalue로 전달"]
C2["rvalue로 전달"]
end
subgraph target[대상 함수]
D1["lvalue 오버로드"]
D2["rvalue 오버로드"]
end
A1 --> B1 --> C1 --> D1
A2 --> B2 --> C2 --> D2
rvalue 참조 매개변수에서 std::move 누락
핵심 규칙: rvalue 참조 타입(T&&)의 매개변수는 이름이 있으므로 lvalue입니다. 실제로 이동하려면 std::move로 다시 rvalue로 캐스팅해야 합니다.
class Wrapper {
std::vector<int> data;
public:
// ❌ vec는 이름이 있으므로 lvalue → 복사 발생!
Wrapper(std::vector<int>&& vec) : data(vec) {}
// ✅ std::move로 rvalue로 캐스팅하여 이동
Wrapper(std::vector<int>&& vec) : data(std::move(vec)) {}
};7. 자주 발생하는 에러와 해결법
에러 1: 이동 후 원본 사용 (Use-After-Move)
증상: 이동한 객체를 다시 사용하면 빈 값, 크래시, 또는 정의되지 않은 동작(UB) 발생.
원인: std::move 후 원본이 “유효하지만 unspecified” 상태인데 사용.
// ❌ 잘못된 코드
std::vector<int> vec = {1, 2, 3};
std::vector<int> other = std::move(vec);
vec.push_back(4); // 위험: vec는 비어 있거나 불안정한 상태해결법:
// ✅ 올바른 코드
std::vector<int> vec = {1, 2, 3};
std::vector<int> other = std::move(vec);
// vec 사용 금지. 필요하면 새로 할당:
vec = {1, 2, 3, 4}; // 또는 vec.clear(); vec.push_back(4);정적 분석 도구: Clang-Tidy의 bugprone-use-after-move 체크로 검출 가능.
에러 2: return std::move(vec)로 RVO 방해
증상: 반환값 최적화가 적용되지 않아 불필요한 이동 1회 발생.
원인: 지역 변수를 반환할 때 std::move를 붙이면 RVO 조건이 깨짐.
// ❌ 잘못된 코드
std::vector<int> create() {
std::vector<int> vec(1000);
return std::move(vec); // RVO 방해!
}해결법:
// ✅ 올바른 코드
std::vector<int> create() {
std::vector<int> vec(1000);
return vec; // RVO 또는 이동, 컴파일러가 최적화
}에러 3: rvalue 참조 매개변수에서 std::move 누락
증상: 이동을 의도했는데 복사가 발생.
원인: T&& 매개변수는 이름이 있으므로 lvalue. std::move로 다시 rvalue로 캐스팅해야 함.
// ❌ 잘못된 코드
class Wrapper {
std::vector<int> data;
public:
Wrapper(std::vector<int>&& vec) : data(vec) {} // 복사 발생!
};해결법:
// ✅ 올바른 코드
class Wrapper {
std::vector<int> data;
public:
Wrapper(std::vector<int>&& vec) : data(std::move(vec)) {}
};에러 4: 이동 생성자에서 noexcept 누락
증상: std::vector 재할당 시 이동 대신 복사가 사용되어 성능 저하.
원인: std::vector는 재할당 시 이동 생성자가 noexcept일 때만 이동 사용.
// ❌ 잘못된 코드
class MyClass {
public:
MyClass(MyClass&& other) { // noexcept 없음
// ...
}
};
// std::vector<MyClass> 재할당 시 복사 사용 → 느림해결법:
// ✅ 올바른 코드
class MyClass {
public:
MyClass(MyClass&& other) noexcept {
// ...
}
};에러 5: std::move를 const 객체에 적용
const std::string str = "Hello";
std::string other = std::move(str); // ❌ 복사! (const이므로 이동 불가)
std::string str = "Hello";
std::string other = std::move(str); // ✅ 이동에러 6: std::move를 기본 타입에 사용
int y = std::move(x); // ❌ 불필요: int는 복사 비용 거의 없음
int y = x; // ✅ 기본 타입은 그냥 복사에러 7: 자기 대입 검사 누락 (이동 대입)
증상: a = std::move(a); 시 자기 리소스를 해제한 뒤 다시 가져오려 하면 문제.
원인: 이동 대입 연산자에서 this != &other 검사 누락.
// ❌ 잘못된 코드
Buffer& operator=(Buffer&& other) noexcept {
delete[] data; // 이게 자기 자신이면 data 해제됨
data = other.data; // other.data도 이미 해제됨
other.data = nullptr;
return *this;
}해결법:
// ✅ 올바른 코드
Buffer& operator=(Buffer&& other) noexcept {
if (this != &other) {
delete[] data;
data = other.data;
other.data = nullptr;
}
return *this;
}에러 8: const rvalue 참조
void process(const std::string&& str); // ❌ const이므로 이동 불가
void process(std::string&& str); // ✅ 이동 가능8. 모범 사례와 선택 가이드
API 설계 시 인자 선택
// ✅ 값으로 받고 이동: 호출자가 복사/이동 선택
void process(std::string data) {
storage_.push_back(std::move(data));
}
// ✅ rvalue만 받을 때: 이동만 허용
void takeOwnership(std::unique_ptr<Resource> ptr) {
resource_ = std::move(ptr);
}
// ✅ const 참조: 복사만, 이동 불가
void readOnly(const std::string& s) {
// s는 수정/이동 불가
}선택 가이드:
| 상황 | 권장 | 예시 |
|---|---|---|
| 호출자가 소유권을 넘기고 싶을 때 | T 또는 T&& | void process(std::string data) |
| 읽기만 할 때 | const T& | void read(const std::string& s) |
| 소유권 이전만 허용 | std::unique_ptr<T> 또는 T&& | void take(std::unique_ptr<Widget> p) |
패턴 1: 벡터에 추가
std::vector<std::string> names;
std::string name = "Alice";
// ❌ 복사
names.push_back(name);
// ✅ 이동
names.push_back(std::move(name));
// ✅ 더 나은 방법: emplace_back
names.emplace_back("Bob");패턴 2: 반환값 최적화
- 지역 변수 반환:
return vec;(std::move 불필요) - 복합 타입:
return {a, std::move(b)};(멤버별 이동) - 조건부 반환:
return condition ? a : b;(둘 다 같은 타입이면 RVO 가능) -
unique_ptr반환:return ptr;(이동 또는 RVO)
패턴 3: 이동 가능한 타입 설계
- 이동 생성자:
T(T&&) noexcept - 이동 대입:
T& operator=(T&&) noexcept - 이동 후 원본:
other.ptr = nullptr등으로 무효화 -
noexcept지정 (vector 등 STL 호환) - 자기 대입 검사 (이동 대입)
9. 프로덕션 패턴
패턴 1: Pimpl + 이동
#include <memory>
class Widget {
struct Impl;
std::unique_ptr<Impl> pImpl;
public:
Widget();
Widget(Widget&&) noexcept = default;
Widget& operator=(Widget&&) noexcept = default;
Widget(const Widget&) = delete;
Widget& operator=(const Widget&) = delete;
};패턴 2: 작업 큐에 이동으로 전달
#include <queue>
#include <mutex>
#include <future>
#include <functional>
#include <utility>
class TaskQueue {
std::queue<std::function<void()>> queue_;
std::mutex mutex_;
public:
template<typename F>
void submit(F&& f) {
std::lock_guard<std::mutex> lock(mutex_);
queue_.push(std::forward<F>(f)); // Perfect forwarding
}
void submit(std::packaged_task<int()> task) {
std::lock_guard<std::mutex> lock(mutex_);
queue_.push([t = std::move(task)]() mutable { t(); }); // 이동 필수
}
};패턴 3: 팩토리 함수 (Perfect Forwarding)
template <typename T, typename... Args>
std::unique_ptr<T> myMakeUnique(Args&&... args) {
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
struct Widget {
Widget(std::string name, int id);
};
auto w = myMakeUnique<Widget>(getTemporaryString(), 42); // 이동패턴 4: emplace 스타일 API
vec.push_back(Widget(1, "a")); // 임시 객체 생성 → 이동
vec.emplace_back(1, "a"); // 복사/이동 없이 직접 생성10. 성능 비교와 체크리스트
벤치마크: vector 복사 vs 이동
// 10K 문자열 벡터: 복사 vs 이동
std::vector<std::string> vec1(count, std::string(1000, 'x'));
std::vector<std::string> vec2 = vec1; // 복사: O(n)
std::vector<std::string> vec3 = std::move(vec1); // 이동: O(1)예상 결과: 복사 550ms, 이동 0.010.5ms. 이동이 10~100배 이상 빠른 경우가 많습니다.
성능 비교 요약 표
| 연산 | 복사 비용 | 이동 비용 | 비고 |
|---|---|---|---|
| vector 대입 (10K 문자열) | O(n) 메모리 복사 | O(1) 포인터 교환 | 이동이 10~100배 빠름 |
| swap (1MB 벡터) | 3MB 복사 | 포인터 3개 교환 | 이동이 수백 배 빠름 |
| push_back (10만 회) | 매번 복사 | 매번 이동 | emplace_back이 가장 빠름 |
| 함수 반환 (vector) | 복사 또는 RVO | 이동 또는 RVO | return vec; 권장 |
구현 체크리스트
- 이동 생성자·이동 대입에
noexcept지정 - rvalue 참조 매개변수에서
std::move로 멤버 초기화 - 이동 대입 시
this != &other자기 대입 검사 - 지역 변수 반환 시
return vec;(std::move 사용 금지) - 이동 후 원본 사용 금지
- Clang-Tidy
bugprone-use-after-move검사 활용
정리
핵심 요약
| 항목 | 설명 |
|---|---|
| lvalue | 이름 있는 변수 |
| rvalue | 임시 값 |
| rvalue 참조 | T&& |
| std::move | lvalue를 rvalue로 캐스팅 |
| std::forward | 원래 타입(lvalue/rvalue) 유지하여 전달 |
| 이동 생성자 | T(T&& other) noexcept |
| 이동 대입 | T& operator=(T&& other) noexcept |
| noexcept | 필수 (vector 최적화) |
핵심 원칙
- 큰 객체는 이동 활용
- 이동 후 객체 사용 금지
- noexcept 지정 필수
- 반환값에 std::move 불필요 (RVO)
- unique_ptr은 항상 이동
- 래퍼 함수·팩토리는
T&&+std::forward로 Perfect Forwarding
자주 묻는 질문 (FAQ)
Q. 이 내용을 실무에서 언제 쓰나요?
A. 대용량 컨테이너 반환, 팩토리 함수, 스레드 풀 작업 큐, 네트워크 버퍼 전달, 빌더 패턴 등에서 이동 의미론을 활용하면 메모리와 CPU 사용량을 크게 줄일 수 있습니다.
Q. std::move와 std::forward의 차이는?
A. std::move는 항상 rvalue로 캐스팅합니다. std::forward는 원래 타입(lvalue/rvalue)을 유지하여 전달합니다.
Q. 선행으로 읽으면 좋은 글은?
A. 메모리 기초, RAII, 스마트 포인터를 먼저 읽으면 이동 의미론의 배경을 이해하기 쉽습니다.
Q. 더 깊이 공부하려면?
A. Perfect Forwarding, cppreference, “Effective Modern C++” Item 18-25를 참고하세요.
참고: cppreference - Move semantics, C++ Core Guidelines 한 줄 요약: rvalue 참조·std::move·std::forward로 불필요한 복사를 제거하고 성능을 최적화할 수 있습니다. 다음 글: [C++ 실전 가이드 #19-2] Perfect Forwarding과 std::forward 이전 글: [C++ 실전 가이드 #18-1] 스마트 포인터 기초
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ Perfect Forwarding 완벽 가이드 | 유니버설 참조·std::forward
- C++ 스마트 포인터 기초 완벽 가이드 | unique_ptr·shared_ptr
- C++ 캐시 최적화 | 메모리 접근 패턴 바꿔서 성능 10배 향상시키기
- C++ 가변 인자 템플릿 | Variadic Templates와 Fold Expression