从零开始学C++之动态创建对象 (一)

回顾前面的文章，实现了一个简单工厂模式来创建不同类对象，但由于c++没有类似new "Circle"之类的语法，导致CreateShape 函

数中需要不断地ifelse地去判断，如果有多个不同类对象需要创建，显然这是很费神的，下面通过宏定义注册的方法来实现动态创

建对象。

Shape.h:

#ifndef _SHAPE_H_
#define _SHAPE_H_

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

class Circle : public Shape
{
public:
void Draw();
~Circle();
};

class Square : public Shape
{
public:
void Draw();
~Square();
};

class Rectangle : public Shape
{
public:
void Draw();
~Rectangle();
};

#endif // _SHAPE_H_

Shape.cpp:

#include "Shape.h"
#include "DynBase.h"
#include
using namespace std;

void Circle::Draw()
{
cout << "Circle::Draw() ..." << endl;
}
Circle::~Circle()
{
cout << "~Circle ..." << endl;
}

void Square::Draw()
{
cout << "Square::Draw() ..." << endl;
}
Square::~Square()
{
cout << "~Square ..." << endl;
}

void Rectangle::Draw()
{
cout << "Rectangle::Draw() ..." << endl;
}

Rectangle::~Rectangle()
{
cout << "~Rectangle ..." << endl;
}

REGISTER_CLASS(Circle);
REGISTER_CLASS(Square);
REGISTER_CLASS(Rectangle);

DynBase.h:

#ifndef _DYN_BASE_H_
#define _DYN_BASE_H_

#include

typedef void *(*CREATE_FUNC)();

class DynObjectFactory
{
public:
static void *CreateObject(const string &name)
{
map::const_iterator it;
it = mapCls_.find(name);
if (it == mapCls_.end())
return 0;
else
return it->second(); //func();

}

static void Register(const string &name, CREATE_FUNC func)
{
mapCls_[name] = func;
}
private:
static map mapCls_;
};

// g++
// __attribute ((weak))
__declspec(selectany) map DynObjectFactory::mapCls_;
//头文件被包含多次，也只定义一次mapCls_;

class Register
{
public:
Register(const string &name, CREATE_FUNC func)
{
DynObjectFactory::Register(name, func);
}
};

#define REGISTER_CLASS(class_name) \
class class_name##Register { \
public: \
static void* NewInstance() \
{ \
return new class_name; \
} \
private: \
static Register reg_; \
}; \
Register class_name##Register::reg_(#class_name, class_name##Register::NewInstance)
//CircleRegister

#endif // _DYN_BASE_H_

DynTest.cpp:

#include "Shape.h"
#include "DynBase.h"
#include
#include
#include
using namespace std;

void DrawAllShapes(const vector &v)
{
vector::const_iterator it;
for (it = v.begin(); it != v.end(); ++it)
{
(*it)->Draw();
}
}

void DeleteAllShapes(const vector &v)
{
vector::const_iterator it;
for (it = v.begin(); it != v.end(); ++it)
{
delete(*it);
}
}

int main(void)
{
vector v;

Shape *ps;
ps = static_cast(DynObjectFactory::CreateObject("Circle"));
v.push_back(ps);
ps = static_cast(DynObjectFactory::CreateObject("Square"));
v.push_back(ps);
ps = static_cast(DynObjectFactory::CreateObject("Rectangle"));
v.push_back(ps);

DrawAllShapes(v);
DeleteAllShapes(v);

return 0;
}

在DynBase.h 中#define了一个宏定义REGISTER_CLASS(class_name)，且在Shape.cpp 中调用宏定义，拿REGISTER_CLASS(Circle);

来说，程序编译预处理阶段会被替换成：

class CircleRegister {
public:

static void* NewInstance()

{

return newCircle;

}

private:

static Register reg_;

};
Register CircleRegister::reg_("Circle",CircleRegister::NewInstance);

也即定义了一个新类，且由于含有static 成员，则在main函数执行前先执行初始化，调用Register类构造函数，在构造函数中调用

DynObjectFactory::Register(name, func); 即调用DynObjectFactory 类的静态成员函数，在Register函数中通过map容器完成了

字符串与函数指针配对的注册，如mapCls_[name] = func;

进入main函数，调用DynObjectFactory: