[C++] ポインタのコピーとメモリ管理の注意点

#include <iostream>
int main() {
    int value = 10; // 変数valueを定義し、10を代入
    int* ptr1 = &value; // ptr1はvalueのアドレスを指す
    int* ptr2 = ptr1; // ptr2にptr1のアドレスをコピー
    std::cout << "ptr1が指す値: " << *ptr1 << std::endl; // ptr1が指す値を出力
    std::cout << "ptr2が指す値: " << *ptr2 << std::endl; // ptr2が指す値を出力
    return 0;
}

ptr1が指す値: 10
ptr2が指す値: 10

#include <cstring> // strcpyを使用するために必要
#include <iostream>
class ShallowCopy {
   public:
    char* data;
    ShallowCopy(const char* str) {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }
    ~ShallowCopy() {
        delete[] data;
    }
};
class DeepCopy {
   public:
    char* data;
    DeepCopy(const char* str) {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }
    DeepCopy(const DeepCopy& other) {
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }
    ~DeepCopy() {
        delete[] data;
    }
};
int main() {
    ShallowCopy shallow1("Hello");
    ShallowCopy shallow2 = shallow1; // シャローコピー
    DeepCopy deep1("World");
    DeepCopy deep2 = deep1; // ディープコピー

    // dataの変更
    shallow1.data[0] = '#';
    deep1.data[0] = '$';

    std::cout << "ShallowCopy: " << shallow1.data << ", " << shallow2.data
              << std::endl;
    std::cout << "DeepCopy: " << deep1.data << ", " << deep2.data << std::endl;
    return 0;
}

ShallowCopy: #ello, #ello
DeepCopy: $orld, World

#include <cstring>
#include <iostream>
class MyClass {
   public:
    char* data;
    MyClass(const char* str) {
        data = new char[strlen(str) + 1];
        strcpy(data, str);
    }
    MyClass(const MyClass& other) { // コピーコンストラクタ
        data = new char[strlen(other.data) + 1];
        strcpy(data, other.data);
    }
    MyClass& operator=(const MyClass& other) { // 代入演算子のオーバーロード
        if (this != &other) {
            delete[] data;
            data = new char[strlen(other.data) + 1];
            strcpy(data, other.data);
        }
        return *this;
    }
    ~MyClass() {
        delete[] data;
    }
};
int main() {
    MyClass obj1("Hello");
    MyClass obj2 = obj1; // コピーコンストラクタを使用
    MyClass obj3("World");
    obj3 = obj1; // 代入演算子を使用

    // dataメンバの変更
    obj1.data[0] = '#';
    obj2.data[1] = '$';
    obj3.data[2] = '%';

    std::cout << "obj1: " << obj1.data << std::endl;
    std::cout << "obj2: " << obj2.data << std::endl;
    std::cout << "obj3: " << obj3.data << std::endl;
    return 0;
}

obj1: #ello
obj2: H$llo
obj3: He%lo

#include <iostream>
int main() {
    int* ptr = new int; // int型のメモリを動的に確保
    *ptr = 42; // 確保したメモリに値を代入
    std::cout << "動的に確保した値: " << *ptr << std::endl; // 値を出力
    delete ptr; // メモリを解放
    return 0;
}

動的に確保した値: 42

#include <iostream>
int main() {
    int* array = new int[5]; // int型の配列を動的に確保
    for (int i = 0; i < 5; ++i) {
        array[i] = i * 10; // 配列に値を代入
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << "array[" << i << "]: " << array[i] << std::endl; // 配列の値を出力
    }
    delete[] array; // 配列のメモリを解放
    return 0;
}

array[0]: 0
array[1]: 10
array[2]: 20
array[3]: 30
array[4]: 40

#include <iostream>
#include <memory> // スマートポインタを使用するために必要
int main() {
    std::unique_ptr<int> uniquePtr(new int(100)); // unique_ptrを使用してメモリを確保
    std::cout << "uniquePtrが指す値: " << *uniquePtr << std::endl; // 値を出力
    std::shared_ptr<int> sharedPtr1 = std::make_shared<int>(200); // shared_ptrを使用してメモリを確保
    std::shared_ptr<int> sharedPtr2 = sharedPtr1; // 所有権を共有
    std::cout << "sharedPtr1が指す値: " << *sharedPtr1 << std::endl; // 値を出力
    std::cout << "sharedPtr2が指す値: " << *sharedPtr2 << std::endl; // 値を出力
    return 0;
}

uniquePtrが指す値: 100
sharedPtr1が指す値: 200
sharedPtr2が指す値: 200

#include <iostream>
int main() {
    int* ptr = new int(10); // メモリを動的に確保
    delete ptr; // メモリを解放
    // ptrはダングリングポインタとなる
    // std::cout << *ptr << std::endl; // これを実行すると未定義の動作
    return 0;
}

#include <iostream>
int main() {
    int* ptr = new int(20); // メモリを動的に確保
    delete ptr; // メモリを解放
    // delete ptr; // これを実行すると二重解放の問題が発生
    return 0;
}

#include <iostream>
#include <memory> // スマートポインタを使用するために必要
void useSmartPointer() {
    std::unique_ptr<int> ptr(new int(30)); // unique_ptrを使用してメモリを確保
    std::cout << "unique_ptrが指す値: " << *ptr << std::endl; // 値を出力
    // スコープを抜けると自動的にメモリが解放される
}
int main() {
    useSmartPointer();
    return 0;
}

unique_ptrが指す値: 30

#include <iostream>
// ノードを表す構造体
struct Node {
    int data; // データ部分
    Node* next; // 次のノードへのポインタ
};
// リストの要素を出力する関数
void printList(Node* head) {
    Node* current = head;
    while (current != nullptr) {
        std::cout << current->data << " -> ";
        current = current->next;
    }
    std::cout << "nullptr" << std::endl;
}
int main() {
    Node* head = new Node{1, nullptr}; // 最初のノードを作成
    head->next = new Node{2, nullptr}; // 2番目のノードを作成
    head->next->next = new Node{3, nullptr}; // 3番目のノードを作成
    printList(head); // リストを出力
    // メモリの解放
    while (head != nullptr) {
        Node* temp = head;
        head = head->next;
        delete temp;
    }
    return 0;
}

1 -> 2 -> 3 -> nullptr

#include <iostream>
// 関数ポインタを引数に取る関数
void executeCallback(void (*callback)(int), int value) {
    callback(value); // コールバック関数を呼び出す
}
// コールバック関数
void printValue(int value) {
    std::cout << "Value: " << value << std::endl;
}
int main() {
    executeCallback(printValue, 42); // コールバック関数を渡して実行
    return 0;
}

Value: 42

#include <iostream>
#include <memory> // スマートポインタを使用するために必要
class SharedObject {
public:
    int value;
    SharedObject(int val) : value(val) {}
};
int main() {
    std::shared_ptr<SharedObject> sharedPtr1 = std::make_shared<SharedObject>(100); // shared_ptrを作成
    std::shared_ptr<SharedObject> sharedPtr2 = sharedPtr1; // 所有権を共有
    std::cout << "sharedPtr1の値: " << sharedPtr1->value << std::endl;
    std::cout << "sharedPtr2の値: " << sharedPtr2->value << std::endl;
    return 0;
}

sharedPtr1の値: 100
sharedPtr2の値: 100

#include <iostream>
#include <vector>
// ベクトルの要素を出力する関数
void printVector(const std::vector<int>* vec) {
    for (int val : *vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;
}
int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5}; // ベクトルを作成
    printVector(&numbers); // ポインタを渡して出力
    return 0;
}

1 2 3 4 5