디자인 패턴과 프로그래밍 패러다임

class Singleton {
private:
    Singleton() {}
    Singleton(const Singleton& ref) {}
    ~Singleton() {}

    Singleton& operator=(const Singleton& ref) {}
public:
    static Singleton* getInstance() { 
        // 지역 static 객체로 만들 경우 전역으로 만든 객체와 달리
        // 해당 함수를 처음 호출하는 시점에서 초기화와 동시에 생성
        static Singleton ins;
        return &ins;
    }
};
int main() {
    Singleton* a = Singleton::getInstance();
    Singleton* b = Singleton::getInstance();
    if( a == b ) cout << "true" << endl;
    return 0;
}

#include <iostream>
#include <string>

class Pizza {
public:
    void getType() {
        cout<<"type : "<<pizzaType<<endl;
    }
public:
    string pizzaType = "";
};

class CheesePizza : public Pizza {
public:
    CheesePizza() {
        pizzaType = "cheese";
    }
};

class PepperoniPizza : public Pizza  {
public:
    PepperoniPizza() {
        pizzaType = "Pepperoni";
    }
};

class PizzaFactory
{
public:
    Pizza* createPizza(string type) {
        Pizza* pizza;
        if(!type.compare("cheese")) pizza = new CheesePizza;
        if(!type.compare("pepperoni")) pizza = new PepperoniPizza;
        return pizza;
    }
};

int main()
{
    PizzaFactory factory;
    Pizza* cheesePizza = factory.createPizza("cheese");
    Pizza* pepperoni = factory.createPizza("pepperoni");
    cheesePizza->getType();
    pepperoni->getType();

	return 0;
}

#include <iostream>
#include <algorithm>
#include <list>

class PaymentStrategy {
public:
    virtual void pay(int amount) = 0;
};

class KAKAOCardStrategy : public PaymentStrategy {
private:
    std::string name;
    std::string cardNumber;
    std::string cvv;
    std::string dateOfExpiry;

public:
    KAKAOCardStrategy(std::string nm, std::string ccNum, std::string cvv, std::string expiryDate) {
        this->name = nm;
        this->cardNumber = ccNum;
        this->cvv = cvv;
        this->dateOfExpiry = expiryDate;
    }

    void pay(int amount) {
        std::cout << amount << " paid using KAKAOCard." << std::endl;
    }
};

class LUNACardStrategy : public PaymentStrategy {
private:
    std::string emailId;
    std::string password;

public:
    LUNACardStrategy(std::string email, std::string pwd) {
        this->emailId = email;
        this->password = pwd;
    }

    void pay(int amount) {
        std::cout << amount << " paid using LUNACard." << std::endl;
    }
};

class Item {
private:
    std::string name;
    int price;

public:
    Item(std::string name, int cost) {
        this->name = name;
        this->price = cost;
    }

    std::string getName() {
        return name;
    }

    int getPrice() {
        return price;
    }
};

class ShoppingCart {
private:
    std::list<Item> items;

public:
    ShoppingCart() {
        this->items = std::list<Item>();
    }

    void addItem(Item item) {
        this->items.push_back(item);
    }

    int calculateTotal() {
        int sum = 0;
        for (Item item : items) {
            sum += item.getPrice();
        }
        return sum;
    }

    void pay(PaymentStrategy* paymentMethod) {
        int amount = calculateTotal();
        paymentMethod->pay(amount);
    }
};

int main() {
    ShoppingCart cart = ShoppingCart();

    Item A = Item("kundolA", 100);
    Item B = Item("kundolB", 300);

    cart.addItem(A);
    cart.addItem(B);

    // pay by LUNACard
    cart.pay(new LUNACardStrategy("kundol@example.com", "pukubababo"));
    // pay by KAKAOBank
    cart.pay(new KAKAOCardStrategy("Ju hongchul", "123456789", "123", "12/01"));

    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>

class Observer;

class Subject {
public:
    virtual void registerObserver(Observer* obj) = 0;
    virtual void unregisterObserver(Observer* obj) = 0;
    virtual void notifyObservers() = 0;
    virtual std::string getUpdate(Observer* obj) = 0;
};

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

class Topic : public Subject {
private:
    std::vector<Observer*> observers;
    std::string message;

public:
    Topic() {
        this->observers = std::vector<Observer*>();
        this->message = "";
    }

    void registerObserver(Observer* obj) {
        if (std::find(observers.begin(), observers.end(), obj) == observers.end()) {
            observers.push_back(obj);
        }
    }

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

    void notifyObservers() {
        std::for_each(observers.begin(), observers.end(), [](Observer* observer) { observer->update(); });
    }

    std::string getUpdate(Observer* obj) {
        return this->message;
    }

    void postMessage(std::string msg) {
        std::cout << "Message sended to Topic: " << msg << std::endl;
        this->message = msg;
        notifyObservers();
    }
};

class TopicSubscriber : public Observer {
private:
    std::string name;
    Subject* topic;

public:
    TopicSubscriber(std::string name, Subject* topic) {
        this->name = name;
        this->topic = topic;
    }

    void update() {
        std::string msg = topic->getUpdate(this);
        std::cout << name << ":: got message >> " << msg << std::endl;
    }
};

int main() {
    Topic topic = Topic();
    Observer* a = new TopicSubscriber("a", &topic);
    Observer* b = new TopicSubscriber("b", &topic);
    Observer* c = new TopicSubscriber("c", &topic);
    topic.registerObserver(a);
    topic.registerObserver(b);
    topic.registerObserver(c);

    topic.postMessage("amumu is op champion!!");

    return 0;
}