[C++] ポインタと参照の違いと使い方

#include <iostream>
int main() {
    int number = 10; // 整数型の変数を宣言
    int* ptr = &number; // ポインタを宣言し、変数のアドレスを代入
    std::cout << "numberの値: " << number << std::endl;
    std::cout << "ptrが指す値: " << *ptr << std::endl; // ポインタを使って値を取得
    return 0;
}

numberの値: 10
ptrが指す値: 10

#include <iostream>
int main() {
    int number = 20; // 整数型の変数を宣言
    int& ref = number; // 参照を宣言し、変数を参照
    std::cout << "numberの値: " << number << std::endl;
    std::cout << "refの値: " << ref << std::endl; // 参照を使って値を取得
    ref = 30; // 参照を通じて値を変更
    std::cout << "変更後のnumberの値: " << number << std::endl;
    return 0;
}

numberの値: 20
refの値: 20
変更後のnumberの値: 30

#include <iostream>
int main() {
    int value = 42; // 整数型の変数を宣言
    int* ptr = &value; // ポインタを宣言し、変数のアドレスを代入
    std::cout << "valueのアドレス: " << ptr << std::endl;
    std::cout << "ptrが指す値: " << *ptr << std::endl; // ポインタを使って値を取得
    return 0;
}

valueのアドレス: 0x7ffee3bff6ac
ptrが指す値: 42

#include <iostream>
int main() {
    int array[3] = {10, 20, 30}; // 整数型の配列を宣言
    int* ptr = array; // 配列の先頭アドレスをポインタに代入
    std::cout << "最初の要素: " << *ptr << std::endl;
    ptr++; // ポインタを次の要素に移動
    std::cout << "次の要素: " << *ptr << std::endl;
    return 0;
}

最初の要素: 10
次の要素: 20

#include <iostream>
int main() {
    int a = 1, b = 2, c = 3; // 複数の整数型変数を宣言
    int* pointers[3] = {&a, &b, &c}; // ポインタの配列を宣言し、各変数のアドレスを代入
    for (int i = 0; i < 3; ++i) {
        std::cout << "pointers[" << i << "]が指す値: " << *pointers[i] << std::endl;
    }
    return 0;
}

pointers[0]が指す値: 1
pointers[1]が指す値: 2
pointers[2]が指す値: 3

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

動的に確保した値: 100

#include <iostream>
int main() {
    int value = 50; // 整数型の変数を宣言
    int& ref = value; // 参照を宣言し、変数を参照
    std::cout << "valueの値: " << value << std::endl;
    std::cout << "refの値: " << ref << std::endl; // 参照を使って値を取得
    ref = 100; // 参照を通じて値を変更
    std::cout << "変更後のvalueの値: " << value << std::endl;
    return 0;
}

valueの値: 50
refの値: 50
変更後のvalueの値: 100

#include <iostream>
void printValue(const int& ref) {
    std::cout << "参照された値: " << ref << std::endl;
    // ref = 200; // これはエラーになります。定数参照は変更不可
}
int main() {
    int value = 150;
    printValue(value);
    return 0;
}

参照された値: 150

#include <iostream>
void increment(int& ref) {
    ref++; // 参照を通じて値をインクリメント
}
int main() {
    int number = 5;
    increment(number); // 参照を渡す
    std::cout << "インクリメント後のnumberの値: " << number << std::endl;
    return 0;
}

インクリメント後のnumberの値: 6

#include <iostream>
void modifyWithPointer(int* ptr) {
    if (ptr != nullptr) {
        *ptr += 10; // ポインタを使って値を変更
    }
}
void modifyWithReference(int& ref) {
    ref += 20; // 参照を使って値を変更
}
int main() {
    int number = 5;
    modifyWithPointer(&number); // ポインタを渡す
    std::cout << "ポインタで変更後のnumber: " << number << std::endl;
    modifyWithReference(number); // 参照を渡す
    std::cout << "参照で変更後のnumber: " << number << std::endl;
    return 0;
}

ポインタで変更後のnumber: 15
参照で変更後のnumber: 35

#include <iostream>
class Example {
public:
    int* ptr; // ポインタメンバー
    int& ref; // 参照メンバー
    Example(int* p, int& r) : ptr(p), ref(r) {} // コンストラクタで初期化
};
int main() {
    int a = 10;
    int b = 20;
    Example ex(&a, b); // ポインタと参照を渡す
    std::cout << "ポインタが指す値: " << *ex.ptr << std::endl;
    std::cout << "参照の値: " << ex.ref << std::endl;
    return 0;
}

ポインタが指す値: 10
参照の値: 20

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

スマートポインタが指す値: 100

#include <iostream>
class Singleton {
private:
    static Singleton* instance; // 唯一のインスタンスを指すポインタ
    Singleton() {} // コンストラクタをプライベートにする
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton(); // インスタンスを動的に生成
        }
        return instance;
    }
    void showMessage() {
        std::cout << "シングルトンインスタンスです。" << std::endl;
    }
};
Singleton* Singleton::instance = nullptr; // 静的メンバの初期化
int main() {
    Singleton* singleton = Singleton::getInstance();
    singleton->showMessage();
    return 0;
}

シングルトンインスタンスです。

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

#include <iostream>
int main() {
    int a = 5;
    int b = 10;
    int& ref = a; // aを参照
    // ref = &b; // これはエラーになります。参照の再割り当ては不可
    ref = b; // これはaの値をbの値に変更する
    std::cout << "aの値: " << a << std::endl;
    return 0;
}

aの値: 10

#include <iostream>
void allocateMemory() {
    int* ptr = new int(100); // メモリを動的に確保
    // メモリを使用する
    delete ptr; // メモリを解放
}
int main() {
    allocateMemory();
    return 0;
}

#include <iostream>
void modify(int* ptr, int& ref) {
    *ptr = 20; // ポインタを使って値を変更
    ref = 30; // 参照を使って値を変更
}
int main() {
    int value = 10;
    modify(&value, value); // ポインタと参照を同じ変数に渡す
    std::cout << "valueの値: " << value << std::endl;
    return 0;
}

valueの値: 30