C++: ムーブセマンティクス

std::vector<int> createVector() {
    std::vector<int> v = {1, 2, 3, 4, 5};
    return v; // ムーブセマンティクスにより最適化
}

std::vector<int> dest = createVector(); // コピーではなくムーブ！

#include <iostream>

void process(int& x) {
    std::cout << "左辺値参照：" << x << std::endl;
}

void process(int&& x) {
    std::cout << "右辺値参照：" << x << std::endl;
}

int main() {
    int a = 10;
    process(a);       // process(int&) を呼び出し
    process(20);      // process(int&&) を呼び出し
    
    return 0;
}

#include <iostream>
#include <vector>
#include <utility>

int main() {
    std::vector<int> v1 = {1, 2, 3};
    std::vector<int> v2 = std::move(v1); // ムーブ、v1の「中身」がv2へ移動
    
    std::cout << "v2のサイズ：" << v2.size() << std::endl; // 3
    std::cout << "v1のサイズ：" << v1.size() << std::endl; // 0（v1は空になる）
    
    return 0;
}

#include <iostream>
#include <cstring>

class String {
private:
    char* data;
    size_t length;

public:
    // 通常のコンストラクタ
    String(const char* str) {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);
        std::cout << "構築：" << data << std::endl;
    }
    
    // コピーコンストラクタ（ディープコピー）
    String(const String& other) {
        length = other.length;
        data = new char[length + 1];
        strcpy(data, other.data);
        std::cout << "コピー構築：" << data << std::endl;
    }
    
    // ムーブコンストラクタ（ムーブ）
    String(String&& other) noexcept {
        data = other.data;       // ポインタを横取り
        length = other.length;
        other.data = nullptr;    // 元のオブジェクトを空にする（二重解放防止）
        other.length = 0;
        std::cout << "ムーブ構築..." << std::endl;
    }
    
    // デストラクタ
    ~String() {
        delete data;
    }
};

int main() {
    String s1("Hello");
    String s2 = std::move(s1); // ムーブコンストラクタを呼び出し
    
    return 0;
}

class Person {
    std::string name;    // stringはムーブ対応済み
    std::vector<int> scores; // vectorもムーブ対応済み
    // 五大関数の定義不要！
};

#include <iostream>
#include <utility>

void process(int& x) {
    std::cout << "左辺値参照..." << std::endl;
}

void process(int&& x) {
    std::cout << "右辺値参照..." << std::endl;
}

template<typename T>
void wrapper(T&& arg) {
    process(std::forward<T>(arg)); // 完全転送
}

int main() {
    int x = 10;
    wrapper(x);  // 左辺値として転送
    wrapper(20); // 右辺値として転送
    
    return 0;
}

#include <iostream>
#include <vector>
#include <chrono>

int main() {
    std::vector<std::vector<int>> v;
    
    // コピーの場合
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 10000; i++) {
        std::vector<int> temp(1000, 1);
        v.push_back(temp); // コピー！
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto copy_time = std::chrono::duration<double>(end - start).count();
    
    v.clear();
    
    // ムーブの場合
    start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 10000; i++) {
        std::vector<int> temp(1000, 1);
        v.push_back(std::move(temp)); // ムーブ！
    }
    end = std::chrono::high_resolution_clock::now();
    auto move_time = std::chrono::duration<double>(end - start).count();
    
    std::cout << "コピー時間：" << copy_time << " 秒" << std::endl;
    std::cout << "ムーブ時間：" << move_time << " 秒" << std::endl;
    
    return 0;
}

#include <iostream>
#include <utility>

class Resource {
private:
    int* data;
    size_t size;

public:
    Resource(size_t n) : size(n), data(new int[n]) {
        std::cout << n << " 要素を確保しました" << std::endl;
    }
    
    // ムーブコンストラクタ
    Resource(Resource&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
        std::cout << "リソースをムーブしました" << std::endl;
    }
    
    // コピーコンストラクタを削除
    Resource(const Resource&) = delete;
    Resource& operator=(const Resource&) = delete;
    
    ~Resource() {
        if (data) {
            delete[] data;
            std::cout << size << " 要素を解放しました" << std::endl;
        }
    }
};

int main() {
    Resource r1(100);
    Resource r2 = std::move(r1);
    
    return 0;
}