VC &&&&最新内容
VC &&&&随机内容c++能不能实现在程序运行是动态创建一个类_c++吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：266,181贴子：
c++能不能实现在程序运行是动态创建一个类收藏
是创建一个编译时没有的类 不是实例化一个对象
一次新的奇迹玩法？你想成为霸服大魔王吗？
不可以 但可以考虑通过脚本语言完成此功能(如lus)
c++不是动态语言吧 objective-c是
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或&&& 和网上大多数实现一样，这里也是采用工厂方法来实现对象的动态创建。大致原理为，创建一个单例工厂类，其中维护一个map(类名-&对象创建函数)。创建对象时，传入类名，然后根据此类名查询出创建函数，最后创建对象。
&&& 采用这种方式，有一个关键问题，便是在工厂中注册类名。我们的办法是针对于每一个类(Class)，定义一个注册类(ClassReg)，在注册类(ClassReg)的构造函数中注册此类(Class)，然后再定义一个注册类的全局对象，在该全局对象初始化时，便会执行注册代码完成注册。
&&& 看到到这里懒人不乐意了，难道我们每写一个类，还要写一个相应的注册类？于是有人提出了使用宏来替换相应的代码，这样便大大减少了重复代码量。
&&& 采用宏当然可以，但是只能满足部分懒人。还有一部分人更懒，他们连使用这个宏完成注册都不想干，是呀，每写完一个类，还要在类后面使用宏来注册，这样确实还是比较麻烦。而且这样代码不够美观，也不便于维护，同时采用宏来转换类名，遇到命名空间，嵌套类，会非常麻烦，我们必须在注册的时候，把名字写全，比如REG_CLASS(MyNameSpace::MyClass::MyStruct)。
&&& 那么有没有更好的方法呢？当然有，我们可以用类模板来实现这种功能。设想这种方式，若我们要定义一个类MyClass，并且想让此类支持动态创建，那么我们只需这样定义即可class MyClass : public DynamicCreate&MyClass&{};。这样是不是清晰多了？下面请看代码:
&&& DynamicFactory.h文件
#ifndef __DYNAMIC_FACTORY_H__
#define __DYNAMIC_FACTORY_H__
#ifdef __GNUC__
#include &cxxabi.h&
#include &assert.h&
#include &string.h&
#include &stdlib.h&
#include &map&
#include &string&
#include &typeinfo&
// 动态对象基类
class DynamicObject
DynamicObject() {}
virtual ~DynamicObject() {}
// 动态对象创建工厂
class DynamicFactory
typedef DynamicObject* (*CreateFunction)();
static DynamicFactory & Instance()
static DynamicF
// 解析类型名称（转换为 A::B::C 的形式）
static std::string ReadTypeName(const char * name)
// 这里省略，具体代码在最后给出
bool Regist(const char * name, CreateFunction func)
if (!func)
std::string type_name = ReadTypeName(name);
return _create_function_map.insert(std::make_pair(type_name, func)).
DynamicObject * Create(const std::string & type_name)
if (type_name.empty())
return NULL;
std::map&std::string, CreateFunction&::iterator it = _create_function_map.find(type_name);
if (it == _create_function_map.end())
return NULL;
return it-&second();
template&typename T&
T * Create(const std::string & type_name)
DynamicObject * obj = Create(type_name);
return NULL;
T * real_obj = dynamic_cast&T*&(obj);
if (!real_obj)
return NULL;
return real_
std::map&std::string, CreateFunction& _create_function_
// 动态对象创建器
template&typename T&
class DynamicCreate : public DynamicObject
static DynamicObject * CreateObject()
return new T();
struct Registor
Registor()
if (!DynamicFactory::Instance().Regist(typeid(T).name(), CreateObject))
assert(false);
inline void do_nothing()const { }
static Registor s_
DynamicCreate()
s_registor.do_nothing();
virtual ~DynamicCreate()
s_registor.do_nothing();
template &typename T&
typename DynamicCreate&T&::Registor DynamicCreate&T&::s_
& & 代码不多，就不做解释了。
&&& 测试代码mian.cpp
#include &stdio.h&
#include &DynamicFactory.h&
class Test1 : public DynamicCreate&Test1&
// 注意：使用gcc，一定要显示申明构造函数，否则不会执行注册代码
Test1() {}
namespace OK {
struct Test2 : public DynamicCreate&Test2&
Test2() {}
class Test3 : public DynamicCreate&Test3&
Test3() {}
struct Test4 : public DynamicCreate&Test4&
Test4() {}
using namespace OK;
//测试代码
int main()
Test1 * p1 = DynamicFactory::Instance().Create&Test1&(&Test1&);
printf(&Create Test1 %s\n&, (p1 ? &success& : &failure&));
OK::Test2 * p2 = DynamicFactory::Instance().Create&OK::Test2&(&OK::Test2&);
printf(&Create OK::Test2 %s\n&, (p2 ? &success& : &failure&));
OK::Test2::Test3 * p3 = DynamicFactory::Instance().Create&OK::Test2::Test3&(&OK::Test2::Test3&);
printf(&Create OK::Test2::Test3 %s\n&, (p3 ? &success& : &failure&));
OK::Test4 * p4 = DynamicFactory::Instance().Create&OK::Test4&(&OK::Test4&);
printf(&Create OK::Test4 %s\n&, (p4 ? &success& : &failure&));
[programmer@localhost test]$ ./test
Create Test1 success
Create OK::Test2 success
Create OK::Test2::Test3 success
Create OK::Test4 success
& 下面给出上面省略的 ReadTypeName函数代码
// 解析类型名称（转换为 A::B::C 的形式）
// GCC 的type_info::name()输出的名称很猥琐，这里只做简单的解析，只支持自定义的结构体（非模板），类（非模板）、枚举、联合
static std::string ReadTypeName(const char * name)
#ifndef __GNUC__
const char * p = strstr(name, & &);
size_t prev_len = (size_t)(p - name);
if (memcmp(name, &class&, prev_len) == 0 ||
memcmp(name, &struct&, prev_len) == 0 ||
memcmp(name, &enum&, prev_len) == 0 ||
memcmp(name, &union&, prev_len) == 0)
return std::string(p);
return std::string(name);
char * real_name = abi::__cxa_demangle(name, nullptr, nullptr, nullptr);
    
std::string real_name_string(real_name);
    
free(real_name);
    
return real_name_
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：734次
排名：千里之外按照类型名称动态创建对象
按照类型名称动态创建对象
按照类型名称动态创建对象提交者：eastvc 发布日期： 10:22:27原文出处：1 引言　　我的一个实际项目中，由于希望通过一致的接口控制各种型号的设备，并且可以方便的随时扩充，以便将来支持更多的型号。因此，必须在运行时指定设备的型号。　　为了使应用程序可以透明的控制各种型号的设备，所以建立了一个简单的继承体系，设计一个协议类(Protocol Class)作为设备的控制接口，并且为每个型号的设备设计了一个具体的类，从协议类派生并且实现了抽象的公共接口。　　因此，我需要一种手段，根据设备的型号在运行时动态的创建设备类实例。否则，如果在编译时硬编码(Hard Code)设备配置，将失去实用性和灵活性。　　最终的结果是，需要这样一种技术，可以实现　　Motor* motor=ClassByName(&IM9001&);　　类似的功能。2 设计和实现　　现有的关键类的代码片断如下：　　class IntelligentMotor & { & public: & IntelligentMotor(const std::string& port_name); & virtual bool Start()=0; & virtual bool Stop()=0; & virtual ~IntelligentMotor(); & }; class IM9001 : public IntelligentMotor & { & public: & IM9001(const std::string& port_name); & virtual bool Start(); & virtual bool Stop(); & virtual ~IM9001(); & private: & // ... & }; class IM9002 : public IntelligentMotor & { & public: & IM9002(const std::string& port_name); & virtual bool Start(); & virtual bool Stop(); & virtual ~IM9002(); & private: & // ... & }; // more model ...　　如何实现ClassByName呢？　　我们当然可以在ClassByName中使用一个多重分支检查来实现，也就是　　IntelligentMotor* ClassByName(const std::string& model_name, & const std::string& port_name) & { & if (model_name==&IM9001&) & return new IM9001(port_name); & else if (model_name==&IM9002&) & return new IM9002(port_name); & // 所有支持的型号 & else & throw &不支持该型号的设备。&; & }　　然而这种编程风格是糟糕的。随着系统支持的型号种类增加，分支检查语句的长度也会同时增加，造成代码尺寸膨胀和可维护性的下降。　　因此必须在类型名字和类(或者类的实例)之间建立一种映射。由于派生类的指针(或引用)可以隐式的转换成基类的指针(或引用)，因此很容易得到这样的构造：　　struct Map & { & const std::string ModelN & IntelligentMotor* D & };　　进而我们还可以构造一个型号映射表，并且在编译时增加所有支持的型号。　　Map ModelTable[]= & { & {&IM9001&,new IM9001}, & {&IM9002&,new IM9002} & // 所有支持的型号 & };　　然后就得到了更清晰的ClassByName。　　IntelligentMotot* ClassByName(const std::string& model_name, & const std::string& port_name) & { & for (int i=0;i&sizeof(ModelTable)/sizeof(Map);++i) & { & if (model_name==ModelTable[i].ModelName) & return ModelTable[i].D & } & throw &不支持该型号的设备。&; & }　　然而，在上面我故意忽略了一个问题，设备类(IM9001, IM9002等)并没有提供默认构造函数，因此实际上这些代码是无法通过编译的。可以通过修改接口的设计来避开这个问题，即增加默认构造函数和指定端口的构造函数。虽然这和实际情况不符(因为这里的设备不支持热插拔，不能再程序运行时更换连接的端口)，但是为了便于实现也是可以接受的。　　但是，更隐蔽的一个缺陷是，如果设备类本身的尺寸较大，那么为所有支持的型号创建实例，将增加空间负荷，而实际上实际使用的设备可能仅仅只用到其中的两三个型号而已。　　从这个角度看，型号映射表中应该映射的是类的创建器，而不是类的实例本身，而类的创建器几乎没有什么空间负担。　　这里有一个极其简单的创建器，　　template &class T& & IntelligentMotor* IntelligentMotorCreator(const std::string& port_name) & { & return new T(port_name); & }　　现在我们的映射表变成了　　typedef IntelligentMotor* (*Creator)(const std::string& port_name); & struct Map & { & const std::string ModelN & Creator DeviceC & }; & Map model_table[]= & { & {&IM9001&,&(IntelligentMotorCreator&IM9001&)}, & {&IM9002&,&(IntelligentMotorCreator&IM9002&)} & //... & };　　而ClassByName则变成了　　IntelligentMotor* ClassByName(const std::string& model_name, & const std::string& port_name) & { & &
H3C认证Java认证Oracle认证
基础英语软考英语项目管理英语职场英语
.NETPowerBuilderWeb开发游戏开发Perl
二级模拟试题一级模拟试题一级考试经验四级考试资料
软件测试软件外包系统分析与建模敏捷开发
法律法规历年试题软考英语网络管理员系统架构设计师信息系统监理师
高级通信工程师考试大纲设备环境综合能力
路由技术网络存储无线网络网络设备
CPMP考试prince2认证项目范围管理项目配置管理项目管理案例项目经理项目干系人管理
职称考试题目
招生信息考研政治
网络安全安全设置工具使用手机安全
生物识别传感器物联网传输层物联网前沿技术物联网案例分析
Java核心技术J2ME教程
Linux系统管理Linux编程Linux安全AIX教程
Windows系统管理Windows教程Windows网络管理Windows故障
数据库开发Sybase数据库Informix数据库
&&&&&&&&&&&&&&&
希赛网 版权所有 & &&动态对象创建
动态对象创建
动态对象创建　　有时我们知道程序中需要创建多少对象，但是多数情况下，我们不能预知所需对象的确切数量。比如公路交通管理系统必须同时处理多少辆汽车？一个三维建筑设计系统需要处理多少个模型？解决这些编程问题的方法，是要能够支持在运行时动态创建和销毁对象。　　一个对象被动态创建时，依次发生两件事情：　　1． 为对象分配内存；　　2． 调用构造函数来初始化这块内存。　　同样，一个对象被动态销毁时，按照顺序发生了下面两件事情：　　1． 调用析构函数清除对象；　　2． 释放对象的内存；　　C++提供了两个运算符new和delete，分别用来完成动态对象的创建和销毁。当我们用new创建一个对象时，就在堆里为对象分配内存并调用相应的构造函数。new返回一个指向刚刚创建的对象的指针；当我们用delete销毁一个对象时，就调用相应的析构函数，释放掉分配的堆内存，delete运算符的操作数是指向对象的指针。需要注意的是：用new创建的对象必须用delete销毁，否则，会出现内存泄漏。　　举个例子说明利用new和delete动态创建和销毁对象的过程：
#include &iostream.h&class Tree{　public:　Tree(int height)　{　　cout&&"tree object is creating"&&　　this-&height =　}　~Tree()　{　　cout&&"tree object is deleting"&&　}　void display()　{　　cout&&"this tree is "&&height&&" meters high"&&　}private: 　};void main(){　Tree* tree = new Tree (100);　tree-&display();　}
　　程序的输出结果如下：　　tree object is creating　　this tree is 100 meters high　　tree object is deleting 　　main( )函数中的第一个语句，是用new运算符动态创建一个Tree类对象，new后面括号中的100，实际上是new创建对象时，传给构造函数的参数。main( )函数的第二个语句是调用对象的显示函数，打印出的结果显示树高为100米，可见new操作符确实调用了类的构造函数display。main( )函数的最后一个语句用delete运算符销毁用new创建的对象。对象一旦被销毁后，就不再存在。如果继续访问对象tree的数据成员或成员函数，则程序会产生错误。
发表评论：
TA的推荐TA的最新馆藏[转]&