move 의미론과 rvalue 참조

타입&& 변수이름 = rvalue_표현식;

#include <utility>
#include <iostream>

void printValue(int& x) { // Lvalue 참조 (x는 Lvalue여야 함)
    std::cout << "Lvalue reference: " << x << std::endl;
}

void printValue(int&& x) { // Rvalue 참조 (x는 Rvalue여야 함)
    std::cout << "Rvalue reference: " << x << std::endl;
}

int main() {
    int a = 10; // a는 lvalue
    printValue(a); // Lvalue reference 호출

    printValue(10); // Rvalue reference 호출
    printValue(a + 5); // (a + 5)는 rvalue, Rvalue reference 호출

    int b = 20;
    // int& ref_b = b + 1; // 컴파일 오류: b+1은 rvalue
    int&& ref_b_rvalue = b + 1; // Rvalue 참조는 rvalue에 바인딩 가능
    std::cout << "ref_b_rvalue: " << ref_b_rvalue << std::endl; // 출력: 21

    // ref_b_rvalue는 이제 Lvalue로 취급됩니다! (나중에 설명)
    printValue(ref_b_rvalue); // Lvalue reference 호출
    printValue(std::move(ref_b_rvalue)); // std::move 사용 시 Rvalue reference 호출

    return 0;
}

#include <iostream>
#include <cstddef>
#include <utility>
#include <vector>
class MyVector {
private:
    int* _data;
    std::size_t _size;
    std::size_t _capacity;

public:
    // 일반 생성자
    MyVector(std::size_t size) : _data(new int[size]{}), _size(size), _capacity(size) {
        std::cout << "Constructor: Allocated " << _size * sizeof(int) << " bytes.\n";
    }

    // 소멸자
    ~MyVector() {
        if (_data) {
            std::cout << "Destructor: Deallocating " << _size * sizeof(int) << " bytes.\n";
            delete[] _data;
        }
    }

    // 복사 생성자 (Deep Copy)
    MyVector(const MyVector& other) : _size(other._size), _capacity(other._capacity) {
        _data = new int[_capacity];
        for (std::size_t i = 0; i < _size; ++i) {
            _data[i] = other._data[i];
        }
        std::cout << "Copy Constructor: Copied " << _size * sizeof(int) << " bytes.\n";
    }

    // 복사 대입 연산자 (Deep Copy)
    MyVector& operator=(const MyVector& other) {
        if (this != &other) {
            int* next = new int[other._capacity];
            for (std::size_t i = 0; i < other._size; ++i) {
                next[i] = other._data[i];
            }
            delete[] _data;
            _data = next;
            _size = other._size;
            _capacity = other._capacity;
        }
        std::cout << "Copy Assignment: Copied " << _size * sizeof(int) << " bytes.\n";
        return *this;
    }

    // *********** 이동 생성자 (Move Constructor) ***********
    MyVector(MyVector&& other) noexcept
        : _data(other._data), _size(other._size), _capacity(other._capacity) {
        // 원본 객체의 자원 포인터를 nullptr로 설정하여 이중 해제 방지
        other._data = nullptr;
        other._size = 0;
        other._capacity = 0;
        std::cout << "Move Constructor: Moved " << _size * sizeof(int) << " bytes.\n";
    }

    // *********** 이동 대입 연산자 (Move Assignment Operator) ***********
    MyVector& operator=(MyVector&& other) noexcept {
        if (this != &other) {
            if (_data) delete[] _data; // 기존 자원 해제 (RAII)

            _data = other._data;
            _size = other._size;
            _capacity = other._capacity;

            other._data = nullptr; // 원본 객체 자원 무효화
            other._size = 0;
            other._capacity = 0;
        }
        std::cout << "Move Assignment: Moved " << _size * sizeof(int) << " bytes.\n";
        return *this;
    }

    // 편의를 위한 함수
    void print_info() const {
        std::cout << "MyVector Info: size=" << _size << ", capacity=" << _capacity
                  << ", data_ptr=" << (void*)_data << std::endl;
    }
};

// MyVector 객체를 반환하는 함수 (RVO/NRVO가 적용될 수 있음)
MyVector createVector(std::size_t size) {
    return MyVector(size);
}

int main() {
    std::cout << "--- Scenario 1: Copy vs Move ---" << std::endl;
    MyVector vec1(10); // Constructor
    vec1.print_info();

    std::cout << "\nAttempting copy (Copy Constructor or Copy Assignment)\n";
    MyVector vec2 = vec1; // Copy Constructor 호출 (복사 발생)
    vec2.print_info();
    vec1.print_info(); // 원본은 그대로 유지

    std::cout << "\nAttempting move (Move Constructor or Move Assignment)\n";
    MyVector vec3 = std::move(vec1); // Move Constructor 호출 (이동 발생)
    vec3.print_info();
    vec1.print_info(); // vec1은 자원을 잃었음을 확인 (nullptr)

    std::cout << "\n--- Scenario 2: Function Return Value (RVO/NRVO vs Move) ---" << std::endl;
    // C++ 컴파일러는 일반적으로 RVO/NRVO(Return Value Optimization/Named Return Value Optimization)를 수행하여
    // 불필요한 복사/이동을 피하려고 시도합니다.
    // 따라서 아래 코드에서는 이동 생성자가 호출되지 않을 수도 있습니다.
    // 이를 명확히 보려면 컴파일러 최적화 옵션을 끄거나 (권장하지 않음),
    // std::vector와 같은 컨테이너의 push_back 등에서 이동을 관찰하는 것이 좋습니다.

    MyVector vec4(1); // Constructor
    std::cout << "\nAssigning return value from function:\n";
    vec4 = createVector(20); // createVector에서 MyVector(20) 생성 -> (RVO/NRVO) -> vec4로 이동 대입
                             // C++17 이후 반환 임시 객체를 직접 생성한 뒤 기존 vec4에 이동 대입합니다.

    std::cout << "\n--- Scenario 3: std::vector::push_back with move ---" << std::endl;
    std::vector<MyVector> vec_of_vectors;
    vec_of_vectors.reserve(2); // 재할당으로 인한 복사/이동 방지

    vec_of_vectors.push_back(MyVector(5)); // 임시 객체 (rvalue)이므로 이동 생성자 호출 (C++11 이후)
    vec_of_vectors.push_back(std::move(vec_of_vectors[0])); // vec_of_vectors[0]의 자원을 이동.
                                                             // vec_of_vectors[0]는 이제 비어있는 상태
                                                             // reserve(2)로 재할당이 없으며 첫 원소는 이 클래스의 빈 상태로 남습니다.
    vec_of_vectors[0].print_info();
    vec_of_vectors[1].print_info();

    std::cout << "End of main." << std::endl;
    return 0;
} // 모든 MyVector 객체의 소멸자가 호출됨

MyVector vec1(10);
MyVector vec3 = std::move(vec1); // vec1을 rvalue로 간주하여 이동 생성자 호출

#include <iostream>
#include <utility> // std::forward, std::move

void process(int& value) { std::cout << "Processing Lvalue: " << value << std::endl; }
void process(int&& value) { std::cout << "Processing Rvalue: " << value << std::endl; }

template<typename T>
void wrapper(T&& arg) { // arg는 Universal Reference
    std::cout << "Wrapper received: ";
    process(std::forward<T>(arg)); // arg를 원래의 값 범주로 전달
}

int main() {
    int lval = 10;
    wrapper(lval); // lval은 Lvalue이므로 process(int&) 호출
    wrapper(20);   // 20은 Rvalue이므로 process(int&&) 호출

    wrapper(std::move(lval)); // lval을 Rvalue로 캐스팅하여 전달, process(int&&) 호출

    return 0;
}

#include <iostream>
#include <utility>

void route(int&) { std::cout << "lvalue\n"; }
void route(int&&) { std::cout << "rvalue\n"; }
void route(const int&) { std::cout << "const lvalue\n"; }

template<class T> void plain(T&& arg) { route(arg); }
template<class T> void forwarded(T&& arg) { route(std::forward<T>(arg)); }
template<class T> void consumed(T&& arg) { route(std::move(arg)); }

int main() {
    int n = 7;
    const int fixed = 8;
    plain(20);
    forwarded(20);
    forwarded(n);
    consumed(n);
    forwarded(fixed);
    std::cout << n << '\n';
}