cocos2dx主循环的委托模式学习

在cocos2dx的主函数中有如下代码：

AppDelegate app;
Application::getInstance()->run();

        Application::getInstance()得到的对象是app，为什么呢?具体是怎么做到的？请看下面的代码例子。

        delegate.h

#ifndef _DELEGATE_H_
#define _DELEGATE_H_

//抽象类，定义一个接口
class BaseInterface
{
public:
    BaseInterface(){}
    virtual ~BaseInterface(){}
    virtual void dance() = 0;   //具体要实现的函数
    virtual void cry() = 0;     //具体要实现的函数
};

class Application : public BaseInterface 
{
private:
    //保存子类的实例
    static Application *instance;  

public:
    Application();
    virtual ~Application();
    
    //得到实例
    static Application* getInstance();
    
    //这两个函数具体的实现交给需要委托的子类
    virtual void dance();
    virtual void cry();
    
    //这是本类（委托）才需要执行的函数
    void run();
};

//这才是任务真正实现的类，但它的调用是由Application来调用的
class AppDelegate : public Application
{
public:
    AppDelegate();
    virtual ~AppDelegate();
    
    //需要具体实现
    virtual void dance();
    virtual void cry();
};

#endif //_DELEGATE_H_

        在这个delegate.h头文件里，抽象类BaseInterface是一个接口，virtual void dance()和virtual void cry()是子类具体要实现的函数，定义成纯虚函数。

        类Application是一个代理(委托)类，继承类BaseInterface，类中定义一个静态本类的指针，通过getInstance()获得实例。run()是要执行的函数，dance()和cry()再此函数中执行。

        类Appdelegate才是真正实现dance()和cry()的类，它继承自委托类Application。

        delegate.cpp

#include <iostream>
#include "delegate.h"
#include "assert.h"

Application::Application()
{
    //这一句是核心，this指向子类的对象
    instance = this; 
}

Application:: ~Application(){}

Application* Application::getInstance()
{
    assert(instance);
    return instance;
}
void Application::dance()
{
    //不需要具体实现
    std::cout<< "Application is dancing" <<std::endl;
}

void Application::cry()
{
    //不需要具体实现
    std::cout<< "Application is crying" <<std::endl;
}

//初始化静态成员instance = NULL
Application* Application::instance = NULL;

//此处真正执行子类的dance()和cry()
void Application::run()
{
    instance->dance();
    instance->cry();
}

AppDelegate::AppDelegate(){}
AppDelegate::~AppDelegate(){}

//具体实现
void AppDelegate::dance()
{
    std::cout<< "delegate is dancing" <<std::endl;
}

void AppDelegate::cry()
{
    std::cout<< "delegate is crying" <<std::endl;
}

        在Application的构造函数中instance = this，这一句是核心所在。

        测试cpp，testdelegate.cpp

#include "delegate.h"

int main()
{
    AppDelegate app;
    Application::getInstance()->run();
    
    return 0;
}

        AppDelegate app，它先调用BaseInterface的构造函数，再调用Application的构造函数，最后调用自己的构造函数。

        可以在Application和AppDelegate的构造函数里写一句printf("this : %p\n", this)，会发现输出结果是一样的，说明

instace = =this， 此处的this就是指向app对象。

        Linux下的编译运行

        编译：g++ -o test testdelegate.cpp delegate.cpp

        运行：./test

        输出：delegate is dancing

                  delegate is crying

        其实这地方我还是有点含糊，为什么在Application的构造函数里的*this居然会是子类的对象，大家可以在下面留言交流一下。或许以后随着我知识的积累，这个问题会迎刃而解。