C++ 값 카테고리 | "lvalue/rvalue/xvalue" 완벽 정리

· 12분 읽기 · 수정 고급 튜토리얼
C++ 값 카테고리 | "lvalue/rvalue/xvalue" 완벽 정리

이 글의 핵심

C++ 값 카테고리에 대한 실전 가이드입니다. 개념부터 실무 활용까지 예제와 함께 상세히 설명합니다.

값 카테고리 분류

표현식
├─ glvalue (일반화된 lvalue)
│  ├─ lvalue
│  └─ xvalue
└─ rvalue
   ├─ prvalue (순수 rvalue)
   └─ xvalue

lvalue

정의: 이름이 있고, 주소를 가질 수 있는 표현식

int x = 10;        // x는 lvalue
int* ptr = &x;     // OK: lvalue의 주소

int& ref = x;      // OK: lvalue 참조
// int& ref2 = 10; // 에러: rvalue를 lvalue 참조에 바인딩 불가

lvalue 예시:

  • 변수 이름: x, y
  • 배열 원소: arr[0]
  • 문자열 리터럴: "hello"
  • 함수 이름: func
  • lvalue 참조 반환: ++x

prvalue (순수 rvalue)

정의: 임시값, 주소를 가질 수 없음

int x = 42;        // 42는 prvalue
int y = x + 5;     // x+5는 prvalue

// int* ptr = &42; // 에러: prvalue의 주소

prvalue 예시:

  • 리터럴: 42, 3.14, true
  • 산술 연산: a + b, a * b
  • 논리 연산: a && b, !a
  • 함수 호출 (값 반환): func()
  • 람다 표현식: {}

xvalue (만료되는 값)

정의: 리소스를 이동할 수 있는 값

vector<int> v = {1, 2, 3};

// move(v)는 xvalue
vector<int> v2 = move(v);  // v의 리소스 이동

// 함수 rvalue 참조 반환
vector<int>&& getVector() {
    static vector<int> v = {1, 2, 3};
    return move(v);
}

auto&& x = getVector();  // xvalue

xvalue 예시:

  • move(x)
  • rvalue 참조 반환 함수
  • 임시 객체의 멤버: Widget().member

참조 바인딩

int x = 10;

// lvalue 참조
int& lr = x;           // OK
// int& lr2 = 10;      // 에러

// const lvalue 참조 (모두 바인딩 가능)
const int& clr = x;    // OK: lvalue
const int& clr2 = 10;  // OK: rvalue

// rvalue 참조
// int&& rr = x;       // 에러: lvalue
int&& rr = 10;         // OK: rvalue
int&& rr2 = move(x);   // OK: xvalue

실전 예시

예시 1: 오버로딩

void process(int& x) {
    cout << "lvalue: " << x << endl;
}

void process(int&& x) {
    cout << "rvalue: " << x << endl;
}

int main() {
    int x = 10;
    
    process(x);      // lvalue 버전
    process(20);     // rvalue 버전
    process(move(x)); // rvalue 버전
}

예시 2: 반환값 최적화

vector<int> createVector() {
    vector<int> v = {1, 2, 3};
    return v;  // prvalue (RVO 가능)
}

vector<int> createVector2() {
    vector<int> v = {1, 2, 3};
    return move(v);  // xvalue (RVO 방해!)
}

int main() {
    auto v1 = createVector();   // RVO (최적)
    auto v2 = createVector2();  // move (덜 최적)
}

예시 3: 완벽 전달

template<typename T>
void wrapper(T&& arg) {
    // T가 lvalue 참조면: arg는 lvalue
    // T가 값 타입이면: arg는 rvalue
    
    if constexpr (is_lvalue_reference_v<T>) {
        cout << "lvalue 전달" << endl;
    } else {
        cout << "rvalue 전달" << endl;
    }
    
    process(forward<T>(arg));
}

int main() {
    int x = 10;
    wrapper(x);      // lvalue
    wrapper(20);     // rvalue
}

예시 4: 값 카테고리 판별

#include <type_traits>

template<typename T>
void printCategory(T&& x) {
    if constexpr (is_lvalue_reference_v<T>) {
        cout << "lvalue" << endl;
    } else {
        cout << "rvalue" << endl;
    }
}

int main() {
    int x = 10;
    
    printCategory(x);       // lvalue
    printCategory(10);      // rvalue
    printCategory(move(x)); // rvalue
}

decltype과 값 카테고리

int x = 10;

decltype(x)       // int (lvalue)
decltype((x))     // int& (lvalue)
decltype(10)      // int (prvalue)
decltype(move(x)) // int&& (xvalue)

자주 발생하는 문제

문제 1: move 오해

// ❌ move가 실제로 이동하지 않음
int x = 10;
int y = move(x);  // 복사됨! (int는 이동 의미 없음)

// ✅ 이동 가능한 타입
vector<int> v1 = {1, 2, 3};
vector<int> v2 = move(v1);  // 이동됨

문제 2: 불필요한 move

// ❌ RVO 방해
vector<int> createVector() {
    vector<int> v = {1, 2, 3};
    return move(v);  // 불필요!
}

// ✅ RVO 허용
vector<int> createVector() {
    vector<int> v = {1, 2, 3};
    return v;  // RVO 발생
}

문제 3: 문자열 리터럴

// 문자열 리터럴은 lvalue!
const char* str = "hello";  // OK

// 배열도 lvalue
int arr[] = {1, 2, 3};
int* ptr = arr;  // OK

값 카테고리 변환

int x = 10;

// lvalue → xvalue
move(x)

// prvalue → xvalue
// (임시 객체 구체화)

// xvalue → prvalue
// (불가능)

실무 가이드라인

1. 함수 매개변수

// 복사 필요 없으면 const lvalue 참조
void read(const Widget& w);

// 소유권 이전이면 값 또는 rvalue 참조
void take(Widget w);
void take(Widget&& w);

// 완벽 전달이면 유니버설 참조
template<typename T>
void forward(T&& arg);

2. 함수 반환

// 값 반환 (RVO)
Widget createWidget() {
    Widget w;
    return w;  // move 쓰지 말 것!
}

// 참조 반환 (주의)
Widget& getWidget() {
    static Widget w;
    return w;  // static만 반환
}

3. move 사용

// move는 마지막에만
void process(Widget w) {
    use(w);           // 여러 번 사용
    store(move(w));   // 마지막에 이동
}

FAQ

Q1: 값 카테고리를 왜 알아야 하나요?

A:

  • move 시맨틱스 이해
  • 완벽 전달 이해
  • 오버로딩 해결 이해
  • 성능 최적화

Q2: glvalue vs rvalue?

A:

  • glvalue: 정체성이 있음 (주소 가능)
  • rvalue: 이동 가능

Q3: xvalue는 언제 생기나요?

A:

  • move() 호출
  • rvalue 참조 반환
  • 임시 객체의 멤버 접근

Q4: 값 카테고리는 타입인가요?

A: 아니요. 표현식의 속성입니다. 같은 변수도 문맥에 따라 다른 카테고리가 될 수 있습니다.

Q5: 실무에서 자주 사용하나요?

A: 직접적으로는 드물지만, move 시맨틱스와 완벽 전달을 이해하는 데 필수입니다.

Q6: 값 카테고리 학습 리소스는?

A:

  • cppreference.com
  • “Effective Modern C++” (Scott Meyers)
  • CppCon 발표: “Back to Basics: Move Semantics”

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

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

  • C++ Rvalue vs Lvalue | “값 범주” 가이드
  • C++ 완벽 전달 | “Perfect Forwarding” 가이드
  • C++ Move 시맨틱스 | “복사 vs 이동” 완벽 이해

관련 글

  • C++ Rvalue vs Lvalue |
  • C++ 참조(Reference) 완벽 가이드 | lvalue·rvalue
  • C++ Move Semantics | std::move로 불필요한 복사 제거하고 성능 최적화
  • C++ Move 시맨틱스 |
  • C++ 완벽 전달 |