C++: コピー制御

#include <iostream>
#include <cstring>

class BadString {
private:
    char* data;
    
public:
    // コンストラクタ
    BadString(const char* s) {
        data = new char[strlen(s) + 1];
        strcpy(data, s);
    }
    
    // ❌ コピーコンストラクタ、代入演算子、デストラクタを定義しない
    // （シャローコピー）
};

int main() {
    BadString s1("Hello");
    BadString s2 = s1; // ❌ シャローコピー：s1.dataとs2.dataが同じアドレス
    
    // main終了時、s2が先に破棄（dataを解放）
    // s1が次に破棄（dataは既に解放済み）→ 二重解放エラー！
    
    return 0;
}

#include <iostream>
#include <cstring>

class MyString {
private:
    char* data;
    
public:
    // コンストラクタ
    MyString(const char* s) {
        data = new char[strlen(s) + 1];
        strcpy(data, s);
    }
    
    // コピーコンストラクタ
    MyString(const MyString& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }
    
    // コピー代入演算子
    MyString& operator=(const MyString& other) {
        if (this != &other) { // 自己代入チェック
            delete data; // 古いメモリを解放
            data = new char[strlen(other.data) + 1];
            strcpy(data, other.data);
        }
        return *this;
    }
    
    // デストラクタ
    ~MyString() {
        delete data;
    }
};

int main() {
    MyString s1("Hello");
    MyString s2("World");
    
    s2 = s1; // ✅ コピー代入演算子呼び出し
    
    return 0;
}

#include <iostream>
#include <cstring>

class MyString {
private:
    char* data;
    
public:
    // ムーブコンストラクタ（C++11）
    MyString(MyString&& other) noexcept {
        data = other.data; // リソースを盗む
        other.data = nullptr; // 元のオブジェクトを空にする
    }
    
    // ムーブ代入演算子（C++11）
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete data; // 古いメモリを解放
            data = other.data; // リソースを盗む
            other.data = nullptr; // 元のオブジェクトを空にする
        }
        return *this;
    }
};

int main() {
    MyString s1("Hello");
    MyString s2 = std::move(s1); // ✅ ムーブコンストラクタ呼び出し
    // s1.dataはnullptr、s2.dataがリソースを持つ
    
    return 0;
}

#include <iostream>
#include <string>

class Student {
private:
    std::string name;
    int age;
    
public:
    // コピーコンストラクタ、コピー代入演算子、デストラクタ
    Student(const Student& other) = default;
    Student& operator=(const Student& other) = default;
    ~Student() = default;
};

int main() {
    Student s1;
    Student s2 = s1; // ✅ デフォルトコピーコンストラクタ呼び出し
    
    return 0;
}

#include <iostream>

class Singleton {
private:
    Singleton() {} // プライベートコンストラクタ
    
public:
    // コピーを禁止
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }
};

int main() {
    Singleton& s = Singleton::getInstance();
    // Singleton s2 = s; // ❌ コンパイルエラー：コピーコンストラクタが削除
    
    return 0;
}

#include <iostream>
#include <cstring>

class MyString {
private:
    char* data;
    int length;
    
public:
    // コンストラクタ
    MyString(const char* s = "") {
        length = strlen(s);
        data = new char[length + 1];
        strcpy(data, s);
    }
    
    // コピーコンストラクタ
    MyString(const MyString& other) {
        length = other.length;
        data = new char[length + 1];
        strcpy(data, other.data);
    }
    
    // ムーブコンストラクタ
    MyString(MyString&& other) noexcept {
        data = other.data;
        length = other.length;
        other.data = nullptr;
        other.length = 0;
    }
    
    // コピー代入演算子
    MyString& operator=(const MyString& other) {
        if (this != &other) {
            delete data;
            length = other.length;
            data = new char[length + 1];
            strcpy(data, other.data);
        }
        return *this;
    }
    
    // ムーブ代入演算子
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete data;
            data = other.data;
            length = other.length;
            other.data = nullptr;
            other.length = 0;
        }
        return *this;
    }
    
    // デストラクタ
    ~MyString() {
        delete data;
    }
    
    // ユーティリティ関数
    void print() const {
        if (data) std::cout << data;
    }
    
    int size() const {
        return length;
    }
};

int main() {
    MyString s1("Hello");
    MyString s2 = s1; // コピーコンストラクタ呼び出し
    
    s1.print(); // Hello
    std::cout << std::endl;
    
    s2.print(); // Hello
    std::cout << std::endl;
    
    return 0;
}

#include <iostream>
#include <string>

class UniqueResource {
private:
    std::string name;
    int resourceId;

public:
    UniqueResource(const std::string& n, int id) 
        : name(n), resourceId(id) {}

    // コピーを禁止
    UniqueResource(const UniqueResource&) = delete;
    UniqueResource& operator=(const UniqueResource&) = delete;

    // ムーブは許可
    UniqueResource(UniqueResource&& other) noexcept
        : name(std::move(other.name)), resourceId(other.resourceId) {
        other.resourceId = -1;
    }

    void print() const {
        std::cout << name << " (ID: " << resourceId << ")" << std::endl;
    }
};

int main() {
    UniqueResource r1("Database", 101);
    r1.print();

    UniqueResource r2 = std::move(r1);  // ムーブは許可
    r2.print();

    // UniqueResource r3 = r2;  // エラー：コピーは削除

    return 0;
}