[C++] 構造体を代入演算子をオーバーロードしてコピーできるようにする

#include <iostream>
#include <string>
struct Person {
    std::string name;  // 名前
    int age;          // 年齢
};

int main() {
    Person person1;  // Personのインスタンスを作成
    person1.name = "山田太郎";  // 名前を設定
    person1.age = 30;           // 年齢を設定
    std::cout << "名前: " << person1.name << ", 年齢: " << person1.age << std::endl;
    return 0;
}

名前: 山田太郎, 年齢: 30

#include <iostream>
#include <cstring>  // strcpy用
struct Person {
    char* name;  // 名前(動的メモリ)
    int age;     // 年齢
    // コンストラクタ
    Person(const char* n, int a) {
        name = new char[strlen(n) + 1];  // メモリ確保
        strcpy(name, n);                  // 名前をコピー
        age = a;                          // 年齢を設定
    }
    // デストラクタ
    ~Person() {
        delete[] name;  // メモリ解放
    }
    // 代入演算子のオーバーロード
    Person& operator=(const Person& other) {
        if (this == &other) return *this;  // 自己代入のチェック
        // 既存のメモリを解放
        delete[] name;  
        // 新しいメモリを確保し、データをコピー
        name = new char[strlen(other.name) + 1];
        strcpy(name, other.name);
        age = other.age;  // 年齢をコピー
        return *this;  // 自身を返す
    }
};
int main() {
    Person person1("山田太郎", 30);  // person1を作成
    Person person2("佐藤花子", 25);   // person2を作成
    person2 = person1;  // person1をperson2に代入
    std::cout << "名前: " << person2.name << ", 年齢: " << person2.age << std::endl;
    return 0;
}

名前: 山田太郎, 年齢: 30

#include <iostream>
#include <cstring>
struct ShallowCopy {
    char* name;  // 名前(ポインタ)
    ShallowCopy(const char* n) {
        name = new char[strlen(n) + 1];
        strcpy(name, n);
    }
    // 浅いコピーのコンストラクタ
    ShallowCopy(const ShallowCopy& other) {
        name = other.name;  // アドレスをコピー
    }
    ~ShallowCopy() {
        delete[] name;  // メモリ解放
    }
};
struct DeepCopy {
    char* name;  // 名前(ポインタ)
    DeepCopy(const char* n) {
        name = new char[strlen(n) + 1];
        strcpy(name, n);
    }
    // 深いコピーのコンストラクタ
    DeepCopy(const DeepCopy& other) {
        name = new char[strlen(other.name) + 1];  // 新しいメモリを確保
        strcpy(name, other.name);                  // データをコピー
    }
    ~DeepCopy() {
        delete[] name;  // メモリ解放
    }
};
int main() {
    ShallowCopy sc1("山田太郎");
    ShallowCopy sc2 = sc1;  // 浅いコピー
    DeepCopy dc1("佐藤花子");
    DeepCopy dc2 = dc1;  // 深いコピー
    // sc1とsc2は同じメモリを指しているため、sc1を解放するとsc2も無効になる
    delete[] sc1.name;  // sc1のメモリを解放
    // dc1とdc2は独立しているため、dc1を解放してもdc2は有効
    delete[] dc1.name;  // dc1のメモリを解放
    return 0;
}

if (this == &other) return *this;  // 自己代入のチェック

delete[] name;  // 既存のメモリを解放
name = new char[strlen(other.name) + 1];  // 新しいメモリを確保

char* newName = new char[strlen(other.name) + 1];  // 新しいメモリを確保
strcpy(newName, other.name);  // データをコピー
delete[] name;  // 既存のメモリを解放
name = newName;  // 新しいメモリを設定

Person& operator=(const Person& other) {
    // 実装
}

#include <iostream>
struct DynamicArray {
    int* data;  // 動的配列
    size_t size;  // 配列のサイズ
    // コンストラクタ
    DynamicArray(size_t s) : size(s) {
        data = new int[size];  // メモリ確保
        for (size_t i = 0; i < size; ++i) {
            data[i] = i;  // 初期化
        }
    }
    // デストラクタ
    ~DynamicArray() {
        delete[] data;  // メモリ解放
    }
    // 代入演算子のオーバーロード
    DynamicArray& operator=(const DynamicArray& other) {
        if (this == &other) return *this;  // 自己代入のチェック
        delete[] data;  // 既存のメモリを解放
        size = other.size;  // サイズをコピー
        data = new int[size];  // 新しいメモリを確保
        for (size_t i = 0; i < size; ++i) {
            data[i] = other.data[i];  // データをコピー
        }
        return *this;  // 自身を返す
    }
};
int main() {
    DynamicArray arr1(5);  // サイズ5の配列を作成
    DynamicArray arr2(3);  // サイズ3の配列を作成
    arr2 = arr1;  // arr1をarr2に代入
    // arr2の内容を表示
    for (size_t i = 0; i < arr2.size; ++i) {
        std::cout << arr2.data[i] << " ";  // 0 1 2 3 4
    }
    std::cout << std::endl;
    return 0;
}

0 1 2 3 4

#include <iostream>
struct Node {
    int value;  // ノードの値
    Node* next;  // 次のノードへのポインタ
    Node(int val) : value(val), next(nullptr) {}  // コンストラクタ
};
struct LinkedList {
    Node* head;  // リストの先頭
    LinkedList() : head(nullptr) {}  // コンストラクタ
    // デストラクタ
    ~LinkedList() {
        while (head) {
            Node* temp = head;
            head = head->next;
            delete temp;  // メモリ解放
        }
    }
    // 代入演算子のオーバーロード
    LinkedList& operator=(const LinkedList& other) {
        if (this == &other) return *this;  // 自己代入のチェック
        // 既存のリストを解放
        while (head) {
            Node* temp = head;
            head = head->next;
            delete temp;  // メモリ解放
        }
        // 他のリストの内容をコピー
        Node* current = other.head;
        Node* last = nullptr;
        while (current) {
            Node* newNode = new Node(current->value);  // 新しいノードを作成
            if (!head) {
                head = newNode;  // 最初のノード
            } else {
                last->next = newNode;  // 次のノードを設定
            }
            last = newNode;  // 最後のノードを更新
            current = current->next;  // 次のノードへ
        }
        return *this;  // 自身を返す
    }
};
int main() {
    LinkedList list1;  // リスト1を作成
    list1.head = new Node(1);  // ノードを追加
    list1.head->next = new Node(2);
    list1.head->next->next = new Node(3);
    LinkedList list2;  // リスト2を作成
    list2 = list1;  // リスト1をリスト2に代入
    // リスト2の内容を表示
    Node* current = list2.head;
    while (current) {
        std::cout << current->value << " ";  // 1 2 3
        current = current->next;
    }
    std::cout << std::endl;
    return 0;
}

1 2 3

#include <iostream>
template <typename T>
class SmartPointer {
private:
    T* ptr;  // ポインタ
public:
    // コンストラクタ
    SmartPointer(T* p = nullptr) : ptr(p) {}
    // デストラクタ
    ~SmartPointer() {
        delete ptr;  // メモリ解放
    }
    // 代入演算子のオーバーロード
    SmartPointer& operator=(const SmartPointer& other) {
        if (this == &other) return *this;  // 自己代入のチェック
        delete ptr;  // 既存のメモリを解放
        ptr = new T(*other.ptr);  // 新しいメモリを確保し、データをコピー
        return *this;  // 自身を返す
    }
    // デリファレンス演算子
    T& operator*() {
        return *ptr;  // ポインタが指す値を返す
    }
};
int main() {
    SmartPointer<int> sp1(new int(10));  // スマートポインタを作成
    SmartPointer<int> sp2;  // 別のスマートポインタを作成
    sp2 = sp1;  // sp1をsp2に代入
    std::cout << *sp2 << std::endl;  // 10を出力
    return 0;
}

10