C++で学ぶメタプログラミングとデザインパターンの実装方法

#include <iostream>

// メタ関数：階乗を計算する
template<int N>
struct Factorial {
    static const int value = N * Factorial<N - 1>::value;
};

// 特殊化：基底条件
template<>
struct Factorial<0> {
    static const int value = 1;
};

int main() {
    std::cout << "Factorial of 5: " << Factorial<5>::value << std::endl;
    return 0;
}

template<typename T>
class MyClass {
public:
    T value;
    MyClass(T val) : value(val) {}
    T getValue() const { return value; }
};

template<int N>
struct Fibonacci {
    static const int value = Fibonacci<N-1>::value + Fibonacci<N-2>::value;
};

template<>
struct Fibonacci<0> {
    static const int value = 0;
};

template<>
struct Fibonacci<1> {
    static const int value = 1;
};

template<typename T>
struct IsPointer {
    static const bool value = false;
};

template<typename T>
struct IsPointer<T*> {
    static const bool value = true;
};

class Singleton {
private:
    static Singleton* instance;

    // コンストラクタを非公開にすることで外部からのインスタンス化を防ぐ
    Singleton() {}

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    void doSomething() {
        // 任意の操作
    }
};

// インスタンスの初期化
Singleton* Singleton::instance = nullptr;

class Product {
public:
    virtual void use() = 0;
};

class ConcreteProductA : public Product {
public:
    void use() override {
        // 製品Aの使用方法
    }
};

class ConcreteProductB : public Product {
public:
    void use() override {
        // 製品Bの使用方法
    }
};

class Creator {
public:
    virtual Product* factoryMethod() = 0;

    void someOperation() {
        Product* product = factoryMethod();
        product->use();
    }
};

class ConcreteCreatorA : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProductA();
    }
};

class ConcreteCreatorB : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProductB();
    }
};

#include <iostream>
#include <vector>

class Observer {
public:
    virtual void update(int state) = 0;
};

class ConcreteObserver : public Observer {
private:
    int observerState;
public:
    void update(int state) override {
        observerState = state;
        std::cout << "Observer state updated to " << observerState << std::endl;
    }
};

class Subject {
private:
    std::vector<Observer*> observers;
    int state;
public:
    void attach(Observer* observer) {
        observers.push_back(observer);
    }

    void setState(int newState) {
        state = newState;
        notifyAllObservers();
    }

    void notifyAllObservers() {
        for (Observer* observer : observers) {
            observer->update(state);
        }
    }
};

int main() {
    Subject subject;
    ConcreteObserver observer1, observer2;

    subject.attach(&observer1);
    subject.attach(&observer2);

    subject.setState(5);
    subject.setState(10);

    return 0;
}

template <typename T>
class Singleton {
public:
    static T& getInstance() {
        static T instance;
        return instance;
    }

protected:
    Singleton() {}
    ~Singleton() {}

private:
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
};

class MyClass {
public:
    void doSomething() {
        // 任意の操作
    }
};

int main() {
    MyClass& instance = Singleton<MyClass>::getInstance();
    instance.doSomething();
    return 0;
}

template <typename T>
class Factory {
public:
    static T* create() {
        return new T();
    }
};

class ProductA {
public:
    void use() {
        // 製品Aの使用方法
    }
};

class ProductB {
public:
    void use() {
        // 製品Bの使用方法
    }
};

int main() {
    ProductA* productA = Factory<ProductA>::create();
    productA->use();
    delete productA;

    ProductB* productB = Factory<ProductB>::create();
    productB->use();
    delete productB;

    return 0;
}

#include <iostream>
#include <vector>

template <typename T>
class Observer {
public:
    virtual void update(T state) = 0;
};

template <typename T>
class Subject {
private:
    std::vector<Observer<T>*> observers;
    T state;
public:
    void attach(Observer<T>* observer) {
        observers.push_back(observer);
    }

    void setState(T newState) {
        state = newState;
        notifyAllObservers();
    }

    void notifyAllObservers() {
        for (Observer<T>* observer : observers) {
            observer->update(state);
        }
    }
};

class ConcreteObserver : public Observer<int> {
private:
    int observerState;
public:
    void update(int state) override {
        observerState = state;
        std::cout << "Observer state updated to " << observerState << std::endl;
    }
};

int main() {
    Subject<int> subject;
    ConcreteObserver observer1, observer2;

    subject.attach(&observer1);
    subject.attach(&observer2);

    subject.setState(5);
    subject.setState(10);

    return 0;
}

template<int N>
struct Fibonacci {
    static const int value = Fibonacci<N - 1>::value + Fibonacci<N - 2>::value;
};

template<>
struct Fibonacci<0> {
    static const int value = 0;
};

template<>
struct Fibonacci<1> {
    static const int value = 1;
};

int main() {
    constexpr int fib10 = Fibonacci<10>::value;
    std::cout << "Fibonacci of 10: " << fib10 << std::endl;
    return 0;
}

template<typename... Ts>
struct Typelist {};

template<typename List>
struct Length;

template<typename... Ts>
struct Length<Typelist<Ts...>> {
    static const size_t value = sizeof...(Ts);
};

using MyTypes = Typelist<int, double, char>;

int main() {
    std::cout << "Length of MyTypes: " << Length<MyTypes>::value << std::endl;
    return 0;
}

#include <type_traits>
#include <iostream>

template<typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
foo(T value) {
    return value + 1;
}

template<typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
foo(T value) {
    return value + 0.1;
}

int main() {
    std::cout << "foo(10): " << foo(10) << std::endl;       // int
    std::cout << "foo(10.5): " << foo(10.5) << std::endl;   // double
    return 0;
}

template<int A, int B>
struct GCD {
    static const int value = GCD<B, A % B>::value;
};

template<int A>
struct GCD<A, 0> {
    static const int value = A;
};

int main() {
    std::cout << "GCD of 48 and 18: " << GCD<48, 18>::value << std::endl;
    return 0;
}

class Logger {
private:
    static Logger* instance;
    Logger() {}

public:
    static Logger* getInstance() {
        if (instance == nullptr) {
            instance = new Logger();
        }
        return instance;
    }

    void log(const std::string& message) {
        // ログメッセージをファイルに書き込む
    }
};

class Shape {
public:
    virtual void draw() = 0;
};

class Circle : public Shape {
public:
    void draw() override {
        // 円を描画する
    }
};

class Square : public Shape {
public:
    void draw() override {
        // 四角形を描画する
    }
};

class Triangle : public Shape {
public:
    void draw() override {
        // 三角形を描画する
    }
};

class ShapeFactory {
public:
    virtual Shape* createShape() = 0;
};

class CircleFactory : public ShapeFactory {
public:
    Shape* createShape() override {
        return new Circle();
    }
};

class SquareFactory : public ShapeFactory {
public:
    Shape* createShape() override {
        return new Square();
    }
};

class TriangleFactory : public ShapeFactory {
public:
    Shape* createShape() override {
        return new Triangle();
    }
};

class Observer {
public:
    virtual void update(float temperature, float humidity, float pressure) = 0;
};

class WeatherData {
private:
    std::vector<Observer*> observers;
    float temperature;
    float humidity;
    float pressure;

public:
    void registerObserver(Observer* observer) {
        observers.push_back(observer);
    }

    void removeObserver(Observer* observer) {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void notifyObservers() {
        for (Observer* observer : observers) {
            observer->update(temperature, humidity, pressure);
        }
    }

    void setMeasurements(float temperature, float humidity, float pressure) {
        this->temperature = temperature;
        this->humidity = humidity;
        this->pressure = pressure;
        notifyObservers();
    }
};

class CurrentConditionsDisplay : public Observer {
public:
    void update(float temperature, float humidity, float pressure) override {
        // 現在の気象状態を表示する
    }
};

class StatisticsDisplay : public Observer {
public:
    void update(float temperature, float humidity, float pressure) override {
        // 統計情報を表示する
    }
};

class ForecastDisplay : public Observer {
public:
    void update(float temperature, float humidity, float pressure) override {
        // 予報を表示する
    }
};