[C++] 複数クラス間で変数の値を保持する方法

#include <iostream>
using namespace std;
class MyClass {
public:
    static int sharedValue; // 静的メンバ変数の宣言
};
int MyClass::sharedValue = 0; // 静的メンバ変数の定義
int main() {
    cout << "初期値: " << MyClass::sharedValue << endl; // 初期値を表示
    return 0;
}

初期値: 0

#include <iostream>
using namespace std;
class ClassA {
   public:
    static int sharedValue; // 静的メンバ変数の宣言
};
class ClassB {
   public:
    void setValue(int value) {
        ClassA::sharedValue = value; // ClassAの静的メンバ変数にアクセス
    }
};
int ClassA::sharedValue = 0; // 静的メンバ変数の定義
int main() {
    ClassB objB;
    objB.setValue(10);                                         // 値を設定
    cout << "ClassAの共有値: " << ClassA::sharedValue << endl; // 共有値を表示
    return 0;
}

ClassAの共有値: 10

#include <iostream>
using namespace std;
class MyClass {
public:
    static int sharedValue; // 静的メンバ変数の宣言
};
int MyClass::sharedValue = 5; // 静的メンバ変数の初期化
int main() {
    cout << "共有値: " << MyClass::sharedValue << endl; // 共有値を表示
    return 0;
}

共有値: 5

#include <iostream>
using namespace std;
int globalValue = 0; // グローバル変数の宣言
void updateValue(int value) {
    globalValue = value; // グローバル変数の使用
}
int main() {
    cout << "初期値: " << globalValue << endl; // 初期値を表示
    updateValue(20); // 値を更新
    cout << "更新後の値: " << globalValue << endl; // 更新後の値を表示
    return 0;
}

初期値: 0
更新後の値: 20

#include <iostream>
using namespace std;
int globalValue = 10; // グローバル変数の宣言
void displayValue() {
    int globalValue = 5; // ローカル変数の宣言
    cout << "ローカル変数の値: " << globalValue << endl; // ローカル変数を表示
}
int main() {
    displayValue(); // ローカル変数を表示
    cout << "グローバル変数の値: " << globalValue << endl; // グローバル変数を表示
    return 0;
}

ローカル変数の値: 5
グローバル変数の値: 10

#include <iostream>
using namespace std;
class Singleton {
private:
    static Singleton* instance; // インスタンスを保持するポインタ
    int value; // 共有する値
    // プライベートコンストラクタ
    Singleton() : value(0) {}
public:
    // インスタンスを取得する静的メンバ関数
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton(); // インスタンスが存在しない場合に生成
        }
        return instance;
    }
    void setValue(int val) {
        value = val; // 値を設定
    }
    int getValue() {
        return value; // 値を取得
    }
};
Singleton* Singleton::instance = nullptr; // インスタンスの初期化
int main() {
    Singleton* singleton = Singleton::getInstance(); // シングルトンインスタンスを取得
    singleton->setValue(42); // 値を設定
    cout << "シングルトンの値: " << singleton->getValue() << endl; // 値を表示
    return 0;
}

シングルトンの値: 42

#include <iostream>
#include <mutex> // ミューテックスを使用
using namespace std;
class ThreadSafeSingleton {
private:
    static ThreadSafeSingleton* instance; // インスタンスを保持するポインタ
    static mutex mtx; // ミューテックス
    int value; // 共有する値
    // プライベートコンストラクタ
    ThreadSafeSingleton() : value(0) {}
public:
    // インスタンスを取得する静的メンバ関数
    static ThreadSafeSingleton* getInstance() {
        if (instance == nullptr) {
            lock_guard<mutex> lock(mtx); // ミューテックスでロック
            if (instance == nullptr) {
                instance = new ThreadSafeSingleton(); // インスタンスが存在しない場合に生成
            }
        }
        return instance;
    }
    void setValue(int val) {
        value = val; // 値を設定
    }
    int getValue() {
        return value; // 値を取得
    }
};
ThreadSafeSingleton* ThreadSafeSingleton::instance = nullptr; // インスタンスの初期化
mutex ThreadSafeSingleton::mtx; // ミューテックスの初期化
int main() {
    ThreadSafeSingleton* singleton = ThreadSafeSingleton::getInstance(); // スレッドセーフなシングルトンインスタンスを取得
    singleton->setValue(100); // 値を設定
    cout << "スレッドセーフなシングルトンの値: " << singleton->getValue() << endl; // 値を表示
    return 0;
}

スレッドセーフなシングルトンの値: 100

#include <iostream>
using namespace std;
class Dependency {
public:
    void doSomething() {
        cout << "依存関係のメソッドが呼ばれました。" << endl;
    }
};
class Client {
private:
    Dependency* dependency; // 依存関係を保持
public:
    // コンストラクタで依存関係を注入
    Client(Dependency* dep) : dependency(dep) {}
    void performAction() {
        dependency->doSomething(); // 依存関係のメソッドを呼び出す
    }
};
int main() {
    Dependency dep; // 依存関係のインスタンスを生成
    Client client(&dep); // 依存関係を注入
    client.performAction(); // アクションを実行
    return 0;
}

依存関係のメソッドが呼ばれました。

#include <iostream>
using namespace std;
class Config {
public:
    int settingValue; // 設定値
    Config(int value) : settingValue(value) {} // コンストラクタで設定値を初期化
};
class Service {
private:
    Config* config; // 設定値を保持
public:
    // コンストラクタで設定値を注入
    Service(Config* cfg) : config(cfg) {}
    void displaySetting() {
        cout << "設定値: " << config->settingValue << endl; // 設定値を表示
    }
};
int main() {
    Config config(100); // 設定値を持つインスタンスを生成
    Service service(&config); // 設定値を注入
    service.displaySetting(); // 設定値を表示
    return 0;
}

設定値: 100

#include <iostream>
using namespace std;
class Data {
public:
    int value; // 共有する値
    Data(int val) : value(val) {} // コンストラクタで初期化
};
class Processor {
private:
    Data* data; // Dataクラスのポインタ
public:
    // コンストラクタでポインタを受け取る
    Processor(Data* d) : data(d) {}
    void process() {
        data->value += 10; // 値を更新
    }
};
int main() {
    Data data(5); // Dataクラスのインスタンスを生成
    Processor processor(&data); // ポインタを渡す
    processor.process(); // 値を処理
    cout << "更新後の値: " << data.value << endl; // 更新後の値を表示
    return 0;
}

更新後の値: 15

#include <iostream>
#include <memory> // スマートポインタを使用
using namespace std;
class Data {
public:
    int value; // 共有する値
    Data(int val) : value(val) {} // コンストラクタで初期化
};
class Processor {
private:
    shared_ptr<Data> data; // shared_ptrを使用
public:
    // コンストラクタでshared_ptrを受け取る
    Processor(shared_ptr<Data> d) : data(d) {}
    void process() {
        data->value += 10; // 値を更新
    }
};
int main() {
    shared_ptr<Data> data = make_shared<Data>(5); // shared_ptrを生成
    Processor processor(data); // shared_ptrを渡す
    processor.process(); // 値を処理
    cout << "更新後の値: " << data->value << endl; // 更新後の値を表示
    return 0;
}

更新後の値: 15

#include <iostream>
using namespace std;
class Config {
public:
    static int settingValue; // 静的メンバ変数の宣言
};
int Config::settingValue = 42; // 静的メンバ変数の定義
class ModuleA {
public:
    void displaySetting() {
        cout << "ModuleAの設定値: " << Config::settingValue << endl; // 設定値を表示
    }
};
class ModuleB {
public:
    void updateSetting(int value) {
        Config::settingValue = value; // 設定値を更新
    }
};
int main() {
    ModuleA moduleA;
    ModuleB moduleB;
    moduleA.displaySetting(); // 初期設定値を表示
    moduleB.updateSetting(100); // 設定値を更新
    moduleA.displaySetting(); // 更新後の設定値を表示
    return 0;
}

ModuleAの設定値: 42
ModuleAの設定値: 100

#include <iostream>
using namespace std;
class Settings {
private:
    static Settings* instance; // インスタンスを保持するポインタ
    int settingValue; // 設定値
    // プライベートコンストラクタ
    Settings() : settingValue(0) {}
public:
    // インスタンスを取得する静的メンバ関数
    static Settings* getInstance() {
        if (instance == nullptr) {
            instance = new Settings(); // インスタンスが存在しない場合に生成
        }
        return instance;
    }
    void setValue(int value) {
        settingValue = value; // 設定値を更新
    }
    int getValue() {
        return settingValue; // 設定値を取得
    }
};
Settings* Settings::instance = nullptr; // インスタンスの初期化
class ModuleC {
public:
    void displaySetting() {
        cout << "ModuleCの設定値: " << Settings::getInstance()->getValue() << endl; // 設定値を表示
    }
};
int main() {
    Settings::getInstance()->setValue(50); // 設定値を設定
    ModuleC moduleC;
    moduleC.displaySetting(); // 設定値を表示
    return 0;
}

ModuleCの設定値: 50

#include <iostream>
using namespace std;
class Config {
public:
    int settingValue; // 設定値
    Config(int value) : settingValue(value) {} // コンストラクタで初期化
};
class Service {
private:
    Config* config; // 設定値を保持
public:
    // コンストラクタで設定値を注入
    Service(Config* cfg) : config(cfg) {}
    void displaySetting() {
        cout << "Serviceの設定値: " << config->settingValue << endl; // 設定値を表示
    }
};
int main() {
    Config config(75); // 設定値を持つインスタンスを生成
    Service service(&config); // 設定値を注入
    service.displaySetting(); // 設定値を表示
    return 0;
}

Serviceの設定値: 75

#include <iostream>
using namespace std;
int globalSettingValue = 10; // グローバル変数の宣言
class ModuleD {
public:
    void displaySetting() {
        cout << "ModuleDの設定値: " << globalSettingValue << endl; // 設定値を表示
    }
};
class ModuleE {
public:
    void updateSetting(int value) {
        globalSettingValue = value; // 設定値を更新
    }
};
int main() {
    ModuleD moduleD;
    ModuleE moduleE;
    moduleD.displaySetting(); // 初期設定値を表示
    moduleE.updateSetting(30); // 設定値を更新
    moduleD.displaySetting(); // 更新後の設定値を表示
    return 0;
}

ModuleDの設定値: 10
ModuleDの設定値: 30

#include <iostream>
using namespace std;
class GameState {
private:
    static GameState* instance; // インスタンスを保持するポインタ
    int score; // プレイヤーのスコア
    // プライベートコンストラクタ
    GameState() : score(0) {}
public:
    // インスタンスを取得する静的メンバ関数
    static GameState* getInstance() {
        if (instance == nullptr) {
            instance = new GameState(); // インスタンスが存在しない場合に生成
        }
        return instance;
    }
    void addScore(int points) {
        score += points; // スコアを加算
    }
    int getScore() {
        return score; // スコアを取得
    }
};
GameState* GameState::instance = nullptr; // インスタンスの初期化
int main() {
    GameState::getInstance()->addScore(10); // スコアを加算
    cout << "現在のスコア: " << GameState::getInstance()->getScore() << endl; // スコアを表示
    return 0;
}

現在のスコア: 10

#include <iostream>
using namespace std;
class Health {
public:
    int healthPoints; // ヘルスポイント
    Health(int hp) : healthPoints(hp) {} // コンストラクタで初期化
};
class Player {
private:
    Health* health; // Healthオブジェクトへのポインタ
public:
    Player(Health* hp) : health(hp) {} // コンストラクタでポインタを受け取る
    void takeDamage(int damage) {
        health->healthPoints -= damage; // ダメージを受ける
    }
};
class Enemy {
private:
    Health* health; // Healthオブジェクトへのポインタ
public:
    Enemy(Health* hp) : health(hp) {} // コンストラクタでポインタを受け取る
    void attack(Player& player) {
        player.takeDamage(5); // プレイヤーに攻撃
    }
};
int main() {
    Health sharedHealth(100); // 共有するヘルスオブジェクトを生成
    Player player(&sharedHealth); // プレイヤーを生成
    Enemy enemy(&sharedHealth); // 敵を生成
    enemy.attack(player); // 敵がプレイヤーを攻撃
    cout << "プレイヤーのヘルスポイント: " << sharedHealth.healthPoints << endl; // ヘルスポイントを表示
    return 0;
}

プレイヤーのヘルスポイント: 95

#include <iostream>
using namespace std;
int screenWidth = 800; // グローバル変数で画面幅を管理
int screenHeight = 600; // グローバル変数で画面高さを管理
class Game {
public:
    void displaySettings() {
        cout << "画面サイズ: " << screenWidth << "x" << screenHeight << endl; // 設定を表示
    }
};
int main() {
    Game game;
    game.displaySettings(); // ゲーム設定を表示
    return 0;
}

画面サイズ: 800x600

#include <iostream>
using namespace std;
class InputManager {
public:
    void processInput() {
        cout << "入力を処理しています..." << endl; // 入力処理
    }
};
class AudioManager {
public:
    void playSound() {
        cout << "サウンドを再生しています..." << endl; // サウンド再生
    }
};
class Game {
private:
    InputManager* inputManager; // InputManagerへのポインタ
    AudioManager* audioManager; // AudioManagerへのポインタ
public:
    // コンストラクタで依存性を注入
    Game(InputManager* im, AudioManager* am) : inputManager(im), audioManager(am) {}
    void run() {
        inputManager->processInput(); // 入力を処理
        audioManager->playSound(); // サウンドを再生
    }
};
int main() {
    InputManager inputManager; // InputManagerのインスタンスを生成
    AudioManager audioManager; // AudioManagerのインスタンスを生成
    Game game(&inputManager, &audioManager); // 依存性を注入
    game.run(); // ゲームを実行
    return 0;
}

入力を処理しています...
サウンドを再生しています...