[C++] namespaceでプライベートな要素を定義する方法

#include <iostream>
// 無名namespaceの定義
namespace {
    void privateFunction() {
        std::cout << "これはプライベートな関数です。" << std::endl;
    }
}
int main() {
    privateFunction(); // 無名namespace内の関数を呼び出し
    return 0;
}

これはプライベートな関数です。

#include <iostream>
// staticキーワードを使ったプライベート関数
static void staticFunction() {
    std::cout << "これはstaticキーワードを使ったプライベートな関数です。" << std::endl;
}
int main() {
    staticFunction(); // static関数を呼び出し
    return 0;
}

これはstaticキーワードを使ったプライベートな関数です。

#include <iostream>
namespace {
    // プライベートなユーティリティ関数
    void helperFunction() {
        std::cout << "これはプライベートなユーティリティ関数です。" << std::endl;
    }
}
int main() {
    helperFunction(); // プライベートなユーティリティ関数を呼び出し
    return 0;
}

これはプライベートなユーティリティ関数です。

#include <iostream>
namespace {
    // プライベートなクラス
    class PrivateClass {
    public:
        void showMessage() {
            std::cout << "これはプライベートなクラスです。" << std::endl;
        }
    };
}
int main() {
    PrivateClass obj;
    obj.showMessage(); // プライベートなクラスのメソッドを呼び出し
    return 0;
}

これはプライベートなクラスです。

#include <iostream>
namespace {
    // プライベートな定数
    const int privateConstant = 42;
}
int main() {
    std::cout << "プライベートな定数の値: " << privateConstant << std::endl;
    return 0;
}

プライベートな定数の値: 42

#include <iostream>
namespace SingletonNamespace {
    class Singleton {
    private:
        static Singleton* instance;
        Singleton() {} // コンストラクタをプライベートに
    public:
        static Singleton* getInstance() {
            if (!instance) {
                instance = new Singleton();
            }
            return instance;
        }
        void showMessage() {
            std::cout << "シングルトンインスタンスです。" << std::endl;
        }
    };
    // シングルトンインスタンスの初期化
    Singleton* Singleton::instance = nullptr;
}
int main() {
    SingletonNamespace::Singleton* singleton = SingletonNamespace::Singleton::getInstance();
    singleton->showMessage(); // シングルトンインスタンスのメソッドを呼び出し
    return 0;
}

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

#include <iostream>
namespace FacadeNamespace {
    class SubsystemA {
    public:
        void operationA() {
            std::cout << "SubsystemAの操作" << std::endl;
        }
    };
    class SubsystemB {
    public:
        void operationB() {
            std::cout << "SubsystemBの操作" << std::endl;
        }
    };
    class Facade {
    private:
        SubsystemA subsystemA;
        SubsystemB subsystemB;
    public:
        void operation() {
            subsystemA.operationA();
            subsystemB.operationB();
        }
    };
}
int main() {
    FacadeNamespace::Facade facade;
    facade.operation(); // ファサードを通じて操作を実行
    return 0;
}

SubsystemAの操作
SubsystemBの操作

#include <iostream>
namespace ModuleNamespace {
    void function1() {
        std::cout << "モジュールの関数1" << std::endl;
    }
    void function2() {
        std::cout << "モジュールの関数2" << std::endl;
    }
}
int main() {
    ModuleNamespace::function1(); // モジュールの関数を呼び出し
    ModuleNamespace::function2();
    return 0;
}

モジュールの関数1
モジュールの関数2