C++对象动态生成(Dynamic Create)的简单实现

http://blog.csdn.net/torytin/article/details/7557698

以前一直是C++的coder，最近由于到了另一家公司，因此开始写Java项目，相信C++的程序员都会对java语言原生支持的动态生成很是羡慕，但是C++不支持反射(reflection)，也就无法根据类名动态创建对象，MFC的做法是继承CObject并用DECLARE_DYNCREATE宏来实现，MFC这么实现是由于一些系统遗留问题，感觉用起来不是那么的friendly。今天下午坐着无聊，仿造java的结构构思了下C++的动态生成实现方法。
基本想法:
1.java的所有类都默认继承自Object类，在C++中我们也需要这么一个公用的基类。
2.java中每个类都有对应的一个Class类，用来动态创建类对象，我们也定义一个Class类
3.java中可以用Class.forName(String className)来获得相应的Class类，我们的Class类也应该支持这种方式
4.java中用Class.newInstance()动态生成类的实例，其实Class类在这里就相当于一个Factory,我们也提供这种方式
基本上，只要实现了上述4个条件，类的动态创建就跟java的方式差不多了，具体代码如下：
核心代码：
Class.h

[cpp] view
plain copy

/*

* C++对象动态创建(Dynamic Create)简单实现

*使用方法：对每一个需要动态创建的类，继承自Object类，并调用Class::Register<Class>(className)注册一下即可

* Created on: 2012-5-11

* Author: torytin

*/

#ifndef CLASS_H_

#define CLASS_H_

#include <map>

#include <string>

using namespace std;

/**

* Object类，需要动态生成的类都必须继承该类

* 目前该类无任何功能，只是一个标记

* @author torytin

*/

class Class;

class Object {

public:

//用来保存创建的Class类

static const Class *const theClass;

};

/**

* 对象工厂模板类，该类用来生成具体的对象

* @author torytin

*

*/

template<class T> class ObjectFactory {

public:

static Object *create() {

return new T();

}

;

};

/**

* Class类，用来存储类信息

* 为了可以把具体的类型对用户隐藏，Class类没有设成模板类

* 因为C++的模板类对象持有的时候必须指定具体的类名，如果设定为模板类

* 使用的时候只能是Class<类名> *pClass，而不能是Class *pClass。

* 用户还是需要知道具体类名，就失去了动态创建的意义，但为了达到动态创建的目的，

* Class类的Register是一个template函数，具体的类型信息，需要用户在注册类的时候提供

* @author torytin

*

*/

class Class {

private:

//创建对象的函数指针定义

Object *(*factory)(void);

//用来存储当前注册的所有可动态创建的Class

static map<string, Class*> classMap;

//类的名称

string name;

//Class类不允许外部初始化

Class() {

}

public:

/***

* Class类注册函数，该注册函数是template函数。

* 用户需要提供T的具体类型和类的唯一标识符（一般为类名），比如生成Example类的Class：

* Class::Register<Example>("Example");

* 参数：

* T:具体的类

* className:注册的名字（一般为类名，也可以为任意字符）

*/

template<class T> static Class * Register(string className) {

if (classMap.count(className)==0) {

Class *cls = new Class();

cls->factory = &ObjectFactory<T>::create; //函数指针赋值，根据T的类型赋值相应的创建函数

cls->name = className; //类名的唯一标识符

classMap[className] = cls; //在这里注册该class类

}

return classMap[className];

}

;

//根据类的名字获得类对应的Class

static Class *forName(string className);

//生成类的实例

Object *newInstance() const;

//获得类名

string getName() const;

virtual ~Class();

};

#endif /* CLASS_H_ */

Class.cpp

[cpp] view
plain copy

/*

* Class.cpp

*

* Created on: 2012-5-11

* Author: torytin

*/

#include "Class.h"

map<string, Class*> Class::classMap=map<string, Class*>();

string Class::getName() const{

return name;

}

Class *Class::forName(string className) {

if (classMap.count(className) != 0) {

return classMap[className];

}

return NULL;

}

Object *Class::newInstance() const {

return factory();

}

Class::~Class() {

}

//注册Object类信息，在这里，我们把返回的Class类存放在theClass中，方便后续使用

const Class *const Object::theClass = Class::Register<Object>("Object");

用户类：这里为了演示的需要定义了两个用户类
Example.h

[cpp] view
plain copy

/*

* C++动态创建类示例

* 对象必须继承Object类，并且必须有一个无参的构造函数

* 定义对象后需要调用Class::Register函数注册当前类，可以把生成的Class保存在static变量中供后续使用

* Created on: 2012-5-11

* Author: torytin

*/

#ifndef EXAMPLE_H_

#define EXAMPLE_H_

#include "Class.h"

class Example: public Object{

public:

//用来保存创建的Class类，这里保存只是为了方便使用，不是强制要求

static const Class * theClass;

Example();

virtual ~Example();

};

#endif /* EXAMPLE_H_ */

Example.cpp

[cpp] view
plain copy

/*

* Example.cpp

*

* Created on: 2012-5-11

* Author: torytin

*/

#include <iostream>

#include "Example.h"

Example::Example() {

std::cout<<"Example is initialized"<<endl;

}

Example::~Example() {

}

//注册Example类信息，在这里，我们把返回的Class类存放在theClass中，方便后续使用

const Class * Example::theClass = Class::Register<Example>("Example");

Example1.h

[cpp] view
plain copy

/*

* Example1.h

*

* Created on: 2012-5-13

* Author: torytin

*/

#ifndef EXAMPLE1_H_

#define EXAMPLE1_H_

#include "Class.h"

class Example1: public Object {

public:

static const Class * theClass;

Example1();

virtual ~Example1();

};

#endif /* EXAMPLE1_H_ */

Example1.cpp

[cpp] view
plain copy

/*

* Example1.cpp

*

* Created on: 2012-5-13

* Author: torytin

*/

#include <iostream>

#include "Example1.h"

Example1::Example1() {

std::cout<<"Example1 is initialized";

}

Example1::~Example1() {

// TODO Auto-generated destructor stub

}

//注册Example1类

const Class * Example1::theClass = Class::Register<Example1>("Example1");

How to Use:

[cpp] view
plain copy

//============================================================================

// Name : dynamic.cpp

// Author : torytin

// Version :

// Copyright :

// Description :Object dynamic create in C++, Ansi-style

//============================================================================

#include <iostream>

#include "Example.h"

using namespace std;

void createExample(Class *cls){

if(cls==Example::theClass){

cout<<"it's a Example Class"<<endl;

cls->newInstance();

}else{

cout<<"it's not a Example Class"<<endl;

}

}

int main() {

createExample(Class::forName("Example"));

createExample(Class::forName("Example1"));

return 0;

}

output

[cpp] view
plain copy

it's a Example Class

Example is initialized

it's not a Example Class

这样c++就就基本实现了java的动态生成机制，相比java来说，我们继承Object的同时还需要调用Class::Register函数注册一下，上面对于Class对象的示例代码中是直接比较指针地址，用户也可以重写Class对象的operator==来根据Class的name是否相等进行比较。另外一个缺陷是无法判断一个类是否是一个类的子类实例，比如我再写一个类SubExample继承Example，但目前是无法判断一个SubExample是否是一个Example的，如果需要做到这点，可以保存整个类的继承关系图，就是Class初始化的时候再加一个父类型参数，然后把整个继承关系保存下来。可以参见完善版本：C++对象动态生成(Dynamic
Create)的完善版本

-------------------------------------------------------------我是分割线--------------------------------------------------------------

对于zhouguidi 提出的模板类的动态创建问题，可能不只一个网友会遇到，这里贴出一些可能的实现思路和代码。由于C++模板类的实现机理是一个类定义应用于多个类，只有当用户指定具体的类型之后，类定义才真正完整，也就是说一个模板类可以生成无穷个类。对于动态创建模板类对象来说，我们不可能把这些无穷个类都进行注册，因此有以下两种解决方案：
1.穷举法：对于所有用到的模板类，在程序开始的某一段代码里面进行穷举注册
Class::Register<TemplateExample<int>>("TemplateExample<int>");

Class::Register<TemplateExample<float>>("TemplateExample<float>");
Class::Register<TemplateExample<double>>("TemplateExample<double>");
……
然后后续代码就可以通过Class::forName("TemplateExample<int>")等来获得对应模板类的Class对象，这种方法比较容易理解，也比较通用，不管类型参数是基本类型还是自定义类型都可以使用，但代码有点冗余繁琐。
2.自动注册：该方法的好处是不需要再写很多重复的Register语句，但需要对模板类的类型参数有一定的约定，因此只能应用于模板类的类型参数是自定义类型的情况，具体见代码
TemplateExample.h

[cpp] view
plain copy

/*

* TemplateExample.h

*

* Created on: 2012-11-27

* Author: Torytin

*/

#ifndef TEMPLATEEXAMPLE_H_

#define TEMPLATEEXAMPLE_H_

#include "Class.h"

template <class T> class TemplateExample: public Object {

public:

//用来保存创建的Class类，这里保存只是为了方便使用，不是强制要求

static const Class * theClass;

TemplateExample();

virtual ~TemplateExample();

};

#endif /* TEMPLATEEXAMPLE_H_ */

TemplateExample.cpp

[cpp] view
plain copy

/*

* TemplateExample.cpp

*

* Created on: 2012-11-27

* Author: Torytin

*/

#include <iostream>

#include "TemplateExample.h"

template <class T> TemplateExample<T>::TemplateExample() {

std::cout<<theClass->getName()+" is initialized"<<endl;

}

template <class T> TemplateExample<T>::~TemplateExample() {

// TODO Auto-generated destructor stub

}

//注册该模板类信息，在这里，要求模板参数T也是属于可以动态创建的对象，且有一个theClass的静态变量指向该类的Class对象

//也可以对T只要求实现某一个方法获得一个可以表述该类名字的唯一字符串，比如要求T实现T::getClassName()

template <class T> const Class * TemplateExample<T>::theClass = Class::Register<TemplateExample<T> >("TemplateExample<"+T::theClass->getName()+">");

How to Use:

[cpp] view
plain copy

//============================================================================

// Name : templateTest.cpp

// Author : torytin

// Version :

// Copyright :

// Description :template Object dynamic create in C++, Ansi-style

//============================================================================

#include <iostream>

#include "Example.h"

#include "Example1.h"

//注意这里是引入模板类的实现文件，因为对于模板类，使用前是需要知道类的完整定义的

#include "TemplateExample.cpp"

using namespace std;

void createTemplateExample(const Class *cls){

if(cls==TemplateExample<Example>::theClass){

cout<<"it's a TemplateExample<Example> Class,instance it"<<endl;

cls->newInstance();

}else{

cout<<"it's not a TemplateExample<Example> Class"<<endl;

}

}

int main() {

//这里可以成功的通过类名字获得类的Class对象，前提是代码中必须出现过TemplateExample<Example1>（出现位置无所谓）

createTemplateExample(Class::forName("TemplateExample<Example1>"));

//代码中必须出现过TemplateExample<Example1>，这里只是让它出现那么一下

new TemplateExample<Example1>();

//这里可以直接用Class::forName方法获得TemplateExample<Example>的类对象，是因为createTemplateExample函数代码中出现过该类

createTemplateExample(Class::forName("TemplateExample<Example>"));

return 0;

}

output

[cpp] view
plain copy

TemplateExample is initialized

it's not a TemplateExample<Example> Class

it's a TemplateExample<Example> Class,instance it

TemplateExample is initialized

今天重新跑了下该示例程序，发现还存在一个似乎跟编译器相关的问题，如果整个代码中都没有引用到某个类的theClass变量，那么该变量是不会初始化的，也就是Class::Register函数不会被调用，该类也就没有注册。因此我在TemplateExample的初始化函数中用了一下theClass->getName()来输出类的名字，以确保会初始化该变量，我用的是elipse的g++编译器（按我原来的理解，既然类生产了，必然会初始化类的静态成员，但实际不是，只有真正代码中使用到过才会初始化该静态成员变量，这应该是g++编译器的一个优化，不知道别的编译器会不会也做同样的处理）