[C++] クラスの関数にstaticを付ける意味やメリットを解説

#include <iostream>
#include <cmath>
class MathUtils {
public:
    static double square(double value) {
        return value * value; // 値の二乗を計算
    }
};
int main() {
    double result = MathUtils::square(5.0); // インスタンスを生成せずに呼び出し
    std::cout << "5の二乗は: " << result << std::endl;
    return 0;
}

5の二乗は: 25

#include <iostream>
class Singleton {
private:
    static Singleton* instance; // 唯一のインスタンス
    Singleton() {} // コンストラクタをプライベートに
public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton(); // インスタンスを生成
        }
        return instance;
    }
};
Singleton* Singleton::instance = nullptr; // インスタンスの初期化
int main() {
    Singleton* singleton = Singleton::getInstance(); // インスタンスを取得
    std::cout << "シングルトンインスタンスのアドレス: " << singleton << std::endl;
    return 0;
}

シングルトンインスタンスのアドレス: 0x55f8c1e0b0

#include <iostream>
class Product {
public:
    virtual void use() = 0; // 使用するためのインターフェース
};
class ConcreteProduct : public Product {
public:
    void use() override {
        std::cout << "ConcreteProductを使用しています。" << std::endl;
    }
};
class Factory {
public:
    static Product* createProduct() {
        return new ConcreteProduct(); // ConcreteProductのインスタンスを生成
    }
};
int main() {
    Product* product = Factory::createProduct(); // ファクトリメソッドを使用
    product->use();
    delete product; // メモリの解放
    return 0;
}

ConcreteProductを使用しています。

#include <iostream>
class IDGenerator {
private:
    static int idCounter; // IDカウンタ
public:
    static int getNextID() {
        return ++idCounter; // 次のIDを返す
    }
};
int IDGenerator::idCounter = 0; // カウンタの初期化
int main() {
    std::cout << "生成されたID: " << IDGenerator::getNextID() << std::endl; // IDを生成
    std::cout << "生成されたID: " << IDGenerator::getNextID() << std::endl; // 次のIDを生成
    return 0;
}

生成されたID: 1
生成されたID: 2

#include <iostream>
class Config {
private:
    static int setting; // 設定値
public:
    static void initialize(int value) {
        setting = value; // 設定値を初期化
    }
    static void showSetting() {
        std::cout << "設定値: " << setting << std::endl;
    }
};
int Config::setting = 0; // 初期化
int main() {
    Config::initialize(10); // 設定値を初期化
    Config::showSetting(); // 設定値を表示
    return 0;
}

設定値: 10

#include <iostream>
template <typename T>
class Calculator {
public:
    static T add(T a, T b) {
        return a + b; // 加算処理
    }
};
int main() {
    std::cout << "整数の加算: " << Calculator<int>::add(3, 4) << std::endl; // 整数の加算
    std::cout << "浮動小数点数の加算: " << Calculator<double>::add(2.5, 3.5) << std::endl; // 浮動小数点数の加算
    return 0;
}

整数の加算: 7
浮動小数点数の加算: 6

#include <iostream>
#include <thread>
#include <mutex>
class ThreadSafeCounter {
private:
    static int count; // カウンタ
    static std::mutex mtx; // ミューテックス
public:
    static void increment() {
        std::lock_guard<std::mutex> lock(mtx); // ロックを取得
        ++count; // カウンタをインクリメント
    }
    static int getCount() {
        return count; // カウンタの値を取得
    }
};
int ThreadSafeCounter::count = 0; // 初期化
std::mutex ThreadSafeCounter::mtx; // ミューテックスの初期化
void threadFunction() {
    for (int i = 0; i < 1000; ++i) {
        ThreadSafeCounter::increment(); // カウンタをインクリメント
    }
}
int main() {
    std::thread t1(threadFunction); // スレッド1
    std::thread t2(threadFunction); // スレッド2
    t1.join(); // スレッド1の終了を待つ
    t2.join(); // スレッド2の終了を待つ
    std::cout << "最終カウンタの値: " << ThreadSafeCounter::getCount() << std::endl; // カウンタの値を表示
    return 0;
}

最終カウンタの値: 2000

#include <iostream>
namespace MyNamespace {
    class MyClass {
    public:
        static void display() {
            std::cout << "MyClassのstaticメンバ関数です。" << std::endl;
        }
    }
}
namespace AnotherNamespace {
    void display() {
        std::cout << "AnotherNamespaceの関数です。" << std::endl;
    }
}
int main() {
    MyNamespace::MyClass::display(); // MyClassのstaticメンバ関数を呼び出し
    AnotherNamespace::display(); // 名前空間の関数を呼び出し
    return 0;
}

MyClassのstaticメンバ関数です。
AnotherNamespaceの関数です。