类的静态注册

 

/************************************************************************/
/* class.h                                                              */
/************************************************************************/
#include "stdio.h"

/************************************************************************/
/* A's Declare                                                          */
/************************************************************************/
class Base;
struct A
{
    A(Base *pBase);
};

/************************************************************************/
/* Mng's Declare                                                        */
/************************************************************************/
class Mng
{
public:
    static void regiInst(Base *pBase);
    static Base *getInst(int i);
private:
    static Base *m_InsList[2];
};

/************************************************************************/
/* Base's Declare                                                       */
/************************************************************************/
class Base
{
public:
    Base();
    virtual ~Base();
    virtual void print();
};

/************************************************************************/
/* Derived's Declare                                                    */
/************************************************************************/
class Derived : Base
{
public:
    Derived();
    virtual ~Derived();
    virtual void print();
private:
    static A m_regiDerived;
};

 

 

/************************************************************************/
/* main.cpp                                                             */
/************************************************************************/
#include "stdio.h"
#include "class.h"

/************************************************************************/
/* Mng's Imp                                                            */
/************************************************************************/
Base *Mng::m_InsList[2] = { NULL };

void Mng::regiInst(Base *pBase)
{
    printf("regiInstance before main\n");
    for (int i = 0; i < 2; i++)
    {
        if(NULL == m_InsList[i])
        {
            m_InsList[i] = pBase;
        }
    }
}

Base *Mng::getInst(int i)
{
    if(i > 2)
    {
        return NULL;
    }
    return m_InsList[i];    
}

/************************************************************************/
/* A's Imp                                                              */
/************************************************************************/
A::A(Base *pBase)
{
    printf("struct regi before main \n");
    Mng::regiInst(pBase);
}

/************************************************************************/
/* Base's Imp                                                           */
/************************************************************************/
Base::Base()
{
    printf("Base's Cons\n");
}

Base::~Base()
{

}

void Base::print()
{
    printf("Base's print func\n");
}

/************************************************************************/
/* Derived's Imp                                                        */
/************************************************************************/
A Derived::m_regiDerived(new Derived());

Derived::Derived()
{
    printf("Derived's Cons\n");
}

Derived::~Derived()
{

}

void Derived::print()
{
    printf("Derived's print func\n");
}

/************************************************************************/
/* main                                                                 */
/************************************************************************/
void main()
{
    //静态注册子类实例
    printf("static regi in main\n");
    Base *p = Mng::getInst(0);
    p->print();
}

 

 

#include <stdio.h>

#define MAX_INSTANCE_NUM     10
/************************************************************************/
/* Base                                                                 */
/************************************************************************/
class Base
{
public:
    Base() {}
    virtual ~Base() {}
    virtual void Print() {};
};

/************************************************************************/
/* Class Manager                                                        */
/************************************************************************/
class ClassMng
{
public:
    ClassMng();
    virtual ~ClassMng();
    static Base *getInstance(int index)
    {
        if(index > MAX_INSTANCE_NUM)
        {
            return NULL;
        }
        return m_InstanceList[index];
    }
    static void regiInstance(Base *pBase)
    {
        for (int i = 0; i < MAX_INSTANCE_NUM; i++)
        {
            if(NULL == m_InstanceList[i])
            {
                m_InstanceList[i] = pBase;
                break;
            }
        }
    }
    static void destroy()
    {
        for (int i = 0; i < MAX_INSTANCE_NUM; i++)
        {
            if (NULL != m_InstanceList[i])
            {
                delete m_InstanceList[i];
                m_InstanceList[i] = NULL;
            }
        }
    }
private:
    static Base *m_InstanceList[MAX_INSTANCE_NUM];
};
Base *ClassMng::m_InstanceList[MAX_INSTANCE_NUM] = { NULL };

/************************************************************************/
/* struct register                                                      */
/************************************************************************/
class Register
{
public:
    Register(Base *pBase)
    {
        ClassMng::regiInstance(pBase);
    }
};

/************************************************************************/
/* Derived: to be managed                                               */
/************************************************************************/
class Derived : public Base
{
public:
    Derived() {};
    virtual ~Derived() {};
    void Print() { printf("obj of Derived 0x%p print!\n", this); }
private:
    static Register m_registerDerived;
};
Register Derived::m_registerDerived(new Derived);

/************************************************************************/
/* Client                                                               */
/************************************************************************/
void main()
{
    Base *p = ClassMng::getInstance(0);
    p->Print();
}