1. Lvalue란?

Lvalue는 "메모리의 특정 주소를 가진 값"을 의미합니다.

• 특징:
  • 이름이 있는 값.
  • 메모리 위치에 저장되며, 변경 가능(mutable).
  • &(주소 연산자)로 해당 값을 참조할 수 있음.

int a = 10;    // a는 lvalue
a = 20;        // lvalue에 값 할당
int* p = &a;   // lvalue의 주소를 참조 가능

2. Rvalue란?

Rvalue는 "임시로 생성된 값" 또는 "메모리 주소가 없는 값"을 의미합니다.

• 특징:
  • 보통 임시 값(temporary value)로 표현.
  • 메모리에 저장되지 않으므로 이름이 없음.
  • 변경 불가능(immutable).

int b = 10 + 20;   // 10 + 20은 rvalue
int c = b * 2;     // b * 2는 rvalue

3. Lvalue와 Rvalue의 구분

Lvalue

• 특정 메모리 주소를 참조.
• 수정 가능.
• 이름을 가짐.

Rvalue

• 임시적으로 생성된 값.
• 수정 불가능.
• 메모리 주소를 가지지 않음.

int x = 10;      // x는 lvalue, 10은 rvalue
x = 20;          // x는 lvalue, 20은 rvalue
int* p = &x;     // x는 lvalue, 주소를 가질 수 있음
// int* q = &(x + 1); // ERROR: (x + 1)은 rvalue, 주소를 가질 수 없음

이동 시맨틱(Move Semantics)

이동 시맨틱은 C++에서 객체의 소유권을 이전하고, 불필요한 복사를 줄여 성능을 최적화하는 중요한 기능입니다. 이 개념은 **rvalue 참조(T&&)**와 함께 C++11에서 도입되었습니다

복사와 이동의 차이

복사(Copy)

• 데이터를 복제합니다.
• 원본과 복사본이 독립적인 자원을 가집니다.
• 비용이 비쌉니다(예: 동적 메모리의 복사).

이동(Move)

• 데이터를 복제하지 않고 소유권을 이전합니다.
• 원본 객체의 자원을 대상 객체로 이전한 후, 원본은 비워지거나 초기화됩니다.
• 비용이 저렴합니다(포인터 이동만 수행).

#include <iostream>
#include <utility>
#include <string>

int main() {
    std::string str = "hello";
    std::string movedStr = std::move(str); // str을 rvalue로 변환 후 이동

    std::cout << "Moved string: " << movedStr << '\n'; // "hello"
    std::cout << "Original string: " << str << '\n';   // (비어 있음)

    return 0;
}

출력결과

Moved string: hello
Original string:

std::move

template <typename T>
constexpr typename std::remove_reference<T>::type&& simple_move(T&& t) noexcept {
    return static_cast<typename std::remove_reference<T>::type&&>(t);
}

remove_reference<T>::type&& 

객체의 참조를 제거하여 기본타입을 추출

T&&->T

T&->T

static_cast<typename remove_reference<T>::type&&>(t)

객체를 rvalue 참조(T&&)로 변환합니다.

lvalue ->rvalue

rvalue->rvalue

변환

보편적 참조(Universal Reference)

보편적 참조는 C++11에서 템플릿 타입 유추와 함께 등장한 개념으로, lvalue 참조와 rvalue 참조를 모두 받아들일 수 있는 참조를 의미합니다.

보편적 참조는 "타입 추론의 맥락에서만" 동작하며, 이를 통해 완벽한 전달(perfect forwarding)을 구현할 수 있습니다.

#include <utility>
#include <iostream>

struct Data {
    Data& operator=(const Data& other) {
        std::cout << "Copy assignment" << std::endl;
        return *this;
    }

    Data& operator=(Data&& other) {
        std::cout << "Move assignment" << std::endl;
        return *this;
    }
};

class Container {
public:
    template <typename T>
    void Put(T&& data) {
        data_ = std::forward<T>(data);
    }

private:
    Data data_{};
};

int main() {
    Container container{};
    Data data{};
    container.Put(data);
    container.Put(Data{});
}

출력결과

Copy assignment
Move assignment

std::forward의 정의

template <typename T>
T&& forward(typename std::remove_reference<T>::type& value) noexcept {
    return static_cast<T&&>(value);
}

만약 T가 Type&이면 → T&&는 Type&.

만약 T가 Type이면 → T&&는 Type&&.

lvalue/rvalue 특성을 유지하며 반환

• int& && → int&: rvalue reference와 lvalue reference가 중첩되면, lvalue reference가 우선됩니다.
• int&& && → int&&: rvalue reference끼리 중첩되면, 그대로 유지됩니다.

#include <iostream>
#include <type_traits>
#include <utility>

template <class T>
T& forward(std::remove_reference_t<T>& t) {
    return static_cast<T&>(t);
}

template <class T>
T&& forward(std::remove_reference_t<T>&& t) {
    return static_cast<T&&>(t);
}

void Print(int&) {
    std::cout << "lvalue" << std::endl;
}

void Print(int&&) {
    std::cout << "rvalue" << std::endl;
}

template <class SomeType>
void DoSmth(SomeType&& value) {
    Print(forward<SomeType>(value));
}

int main() {
    int number;
    DoSmth(number);           // DoSmth(int&)
    DoSmth(42);               // DoSmth(int&&)
    DoSmth(std::move(number)); // DoSmth(int&&)
}​

출력

lvalue
lvalue
lvalue

template <class T>
T& forward(std::remove_reference_t<T>& t) {
    return static_cast<T&>(t);
}

template <class T>
T&& forward(std::remove_reference_t<T>&& t) {
    return static_cast<T&&>(t);
}

Print(forward<SomeType>(value));

forward (value) lvalue라 항상 처음 lvalue forward만 실행된다

#include <iostream>
#include <type_traits>
#include <utility>

template <class T>
T&& forward(std::remove_reference_t<T>& t) noexcept {
    return static_cast<T&&>(t);
}

void Print(int&) {
    std::cout << "lvalue" << std::endl;
}

void Print(int&&) {
    std::cout << "rvalue" << std::endl;
}

template <class SomeType>
void DoSmth(SomeType&& value) {
    Print(forward<SomeType>(value));
}

int main() {
    int number;
    DoSmth(number);           // lvalue 전달
    DoSmth(42);               // rvalue 전달
    DoSmth(std::move(number)); // rvalue 전달
}

출력

lvalue
rvalue
rvalue

lvalue rvalue 값을 보존한체 출력한다

매게변수를 lvalue로 설정하는 이유

(std::remove_reference_t<T>& t) 즉

C++에서 rvalue reference(&&)도 함수의 매개변수로 전달되면 lvalue로 취급되기 때문입니다.

리턴 타입을 통해 원래 특성(lvalue/rvalue)을 유지

T&&와 참조 붕괴 규칙

• 반환 타입을 T&&로 설정하고, 내부적으로 static_cast<T&&>(value)를 사용하면 원래 특성을 복원할 수 있습니다.
• 참조 붕괴 규칙에 따라:
  • T = Type → T&& = Type&& → rvalue.
  • T = Type& → T&& = Type& → lvalue.

template <class T>
T&& forward(std::remove_reference_t<T>& t) noexcept {
    return static_cast<T&&>(t);
}