cocos2dx常见的设计模式

1. 观察者模式：定义了对象间的一种一对多的组合关系，以便一个对象的状态发生变化时，所有依赖于它的对象都得到通知并自动刷新。

事件机制

--注册事件
local eventDispatcher = cc.Director:getInstance():getEventDispatcher()
local customer = cc.EventListenerCustom:create("MY_CUSTOM_EVENT",
                            function ( )
                                gt.log("======EventListenerCustom======")
                            end)
eventDispatcher:addEventListenerWithFixedPriority(customer, 1)
--派发事件
eventDispatcher:dispatchCustomEvent("MY_CUSTOM_EVENT")

2. 单例模式:简单易用，限制一个类只有一个实例，可以减少创建多个对象可能会引起的内存问题的风险，包括内存泄漏、内存占用问题

CCDirector ,CCTextureCache, CCSpriteFrameCache, CCAnimationCache, CCUserDefault, CCNotificationCenter， CCShaderCache， CCScriptEngineManager， CCFileUtils， SimleAudioEngie

3.简单工厂模式、工厂模式、抽象工厂模式

AbstractProduct.hpp

#ifndef AbstractProduct_hpp
#define AbstractProduct_hpp

#include <stdio.h>

class AbstractProduct{
public:
    AbstractProduct();
    virtual ~AbstractProduct();

    virtual void operation() = 0;
};

//productA
class ProductA:public AbstractProduct{
public:
    ProductA();
    virtual ~ProductA();

    void operation();
};

//productB
class ProductB:public AbstractProduct{
public:
    ProductB();
    virtual ~ProductB();
    
    void operation();
    
};
#endif /* AbstractProduct_hpp */

AbstractProduct.cpp

#include "AbstractProduct.hpp"
#include <iostream>

AbstractProduct::AbstractProduct(){
}
AbstractProduct::~AbstractProduct(){
}

//A
ProductA::ProductA(){
}
ProductA::~ProductA(){
}

void ProductA::operation(){
    std::cout<<"ProductA operation"<<std::endl;
}

//B
ProductB::ProductB(){
}
ProductB::~ProductB(){
}
void ProductB::operation(){
    std::cout<<"ProductB operation"<<std::endl;
}

工厂模式实现：
AbstructFactory.hpp

#ifndef AbstructFactory_hpp
#define AbstructFactory_hpp

#include <stdio.h>
#include "AbstractProduct.hpp"

class AbstructFactory{
public:
    AbstructFactory();
    virtual ~AbstructFactory();
    virtual AbstractProduct* createProduct() = 0;
};

class FactoryA:public AbstructFactory{
public:
    FactoryA();
    virtual ~FactoryA();
    AbstractProduct* createProduct();
    
};

class FactoryB:public AbstructFactory{
public:
    FactoryB();
    virtual ~FactoryB();
    AbstractProduct* createProduct();
    
};
#endif /* AbstructFactory_hpp */

AbstructFactory.cpp

#include "AbstructFactory.hpp"

AbstructFactory::AbstructFactory(){
}
AbstructFactory::~AbstructFactory(){
}

FactoryA::FactoryA(){
}

FactoryA::~FactoryA(){
}

AbstractProduct* FactoryA::createProduct(){
    AbstractProduct* temp = new ProductA();
    return  temp;
}

FactoryB::FactoryB(){
}

FactoryB::~FactoryB(){
}

AbstractProduct* FactoryB::createProduct(){
    AbstractProduct* temp = new ProductB();
    return temp;
}

简单工厂模式：
SimpleFactory.hpp

#ifndef SimpleFactory_hpp
#define SimpleFactory_hpp

#include <stdio.h>
#include "AbstractProduct.hpp"

class SimpleFactory{
public:
    enum ProductType {
        p_productA,
        p_productB
    };
    
    SimpleFactory();
    virtual ~SimpleFactory();
    AbstractProduct* createProduct(int pType);
};
#endif /* SimpleFactory_hpp */

SimpleFactory.cpp

#include "SimpleFactory.hpp"

SimpleFactory::SimpleFactory(){
}

SimpleFactory::~SimpleFactory(){
}

AbstractProduct* SimpleFactory::createProduct(int pType){
    AbstractProduct* p = nullptr;
    switch (pType) {
        case SimpleFactory::p_productA:
            p = new ProductA();
            break;
        case SimpleFactory::p_productB:
            p = new ProductB();
            break;
            
        default:
            break;
    }
    return  p;
}

main.cpp

#include <iostream>
#include "SimpleFactory.hpp"
#include "AbstructFactory.hpp"

int main(int argc, const char * argv[]) {
    // insert code here...
    std::cout << "Hello, World!\n";
#pragma 简单工厂模式test
    std::cout<<"=================简单工厂模式=====================\n";
    SimpleFactory s_Factory = SimpleFactory();
    AbstractProduct* p_a = s_Factory.createProduct(SimpleFactory::p_productA);
    p_a->operation();
    
    AbstractProduct* p_b =s_Factory.createProduct(SimpleFactory::p_productB);
    p_b->operation();
    
#pragma 工厂模式
    std::cout<<"\n=================工厂模式=====================\n";
    FactoryA a_factory = FactoryA();
    AbstractProduct* f_p_a = a_factory.createProduct();
    f_p_a->operation();
    
    FactoryB b_factory = FactoryB();
    AbstractProduct* f_p_b = b_factory.createProduct();
    f_p_b->operation();
    
    
    
    return 0;
}

4.代理模式