对象动态创建

最新推荐文章于 2024-04-09 15:16:21 发布
最新推荐文章于 2024-04-09 15:16:21 发布
阅读量206 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/webor2006/p/5677402.html
版权

还记得之前写过一个代码么？如下：

上面代码是用来根据指定的形状名称来创建相印的形状实例，这里面有很多if...else...语句，如果有新的形状要创建，则里面的代码得不断的进行修改，所以这种设计不是很灵活，所以对象动态创建技术就可以很好的解决此问题。

什么是对象动态创建呢？简单的说它是指可以通过一个字符串创建一个类对象，比如之前我们使用的"Circle"可以创建一个Circle类对象，对于学过JAVA的人来说其实很容易理解，它跟反射技术很类似，所谓反射，它其实是动态的获取类型信息（包括方法和属性）：动态的创建对象、动态调用对象中的方法、动态操作对象的属性。而目前只需要观注动态创建对象，这里的目标是：对原有的类不做任何更改，只需要增加一个宏就能够实现动态创建。下面用代码一步步来实现这个目标：

先将之前的Shape类相关的代码拷贝至新的工程中并更改文件名为Shape.h：

并且创建一些其它的文件，需要将代码进行行折分一下：

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 <iostream>
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;
}

DynTest.cpp【存放测试代码】:

#include "Shape.h"
#include <iostream>
#include <vector>
using namespace std;

//绘制所有的形状
void drawAllShapes(const vector<Shape*>& v) {
    vector<Shape*>::const_iterator it;
    for(it=v.begin();it!=v.end();++it) {
        (*it)->draw();
    }
}

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

int main(void) {
    //Shape s;//ERROR,不能实例化抽象类
    vector<Shape*> v;
    /*Shape* ps;
    ps = new Circle;
    v.push_back(ps);
    ps = new Square;
    v.push_back(ps);
    ps = new Rectangle;
    v.push_back(ps);*/

    /*Shape* ps;
    ps = ShapeFactory::createShape("Circle");
    v.push_back(ps);
    ps = ShapeFactory::createShape("Square");
    v.push_back(ps);
    ps = ShapeFactory::createShape("Rectangle");
    v.push_back(ps);*/

    drawAllShapes(v);
    deleteAllShapes(v);

    return 0;
}

以上代码没有什么大的变化，差不多只是将原来一个文件中的代码进行的折分。

接下来编写DynBase.h，之后如果想动态创建对象，只需要包含该头文件既可，也就是代码核心之所在，下面一步步来实现：

实际上就是原先的ShapFactory，只是这里变换了写法，接下来如果哪个类想动态创建对象，可以包含此头文件，并利用宏来注册，伪代码如下：

下面来定义这样的宏，核心中的核心啦：

#ifndef _DYN_BASE_H
#define _DYN_BASE_H
#include <string>
#include <map>

typedef void* (*CREATE_FUNC)();

class DynObjectFactory {
public:
    static void* createObject(const string& name, CREATE_FUNC func) {
        map<string, CREATE_FUNC>::const_iterator it;
        it = mapCls_.find(name);
        if(it != mapCls_.end())
            return 0;
        else
            it->second();
    }

    

private:
    static map<string, CREATE_FUNC> mapCls_;
};

#define REGISTER_CLASS(class_name) \//其中'\'表示换行的意思，在宏声明中换行需要用到它
class class_name##Resgiter { \
public: \
    static void* newInstance() { \
        return new class_name; \
    } \
}; \


#endif //_DYN_BASE_H

接着得想办法将newInstance存入到DynObjectFactory中的mapCls_中，以便创建对象，所以需要在DynObjectFactory类中增加一个注册的方法：

#ifndef _DYN_BASE_H
#define _DYN_BASE_H
#include <string>
#include <map>

typedef void* (*CREATE_FUNC)();

class DynObjectFactory {
public:
    static void* createObject(const string& name, CREATE_FUNC func) {
        map<string, CREATE_FUNC>::const_iterator it;
        it = mapCls_.find(name);
        if(it != mapCls_.end())
            return 0;
        else
            it->second();
    }

    static void register(const string& name, CREATE_FUNC func) {
        mapCls_[name] = func;
    }

private:
    static map<string, CREATE_FUNC> mapCls_;
};

#define REGISTER_CLASS(class_name) \
class class_name##Resgiter { \
public: \
    static void* newInstance() { \
        return new class_name; \
    } \
}; \


#endif //_DYN_BASE_H

下面一步就是想办法来调用register方法，如何做呢？可以用一个技巧：

#ifndef _DYN_BASE_H
#define _DYN_BASE_H
#include <string>
#include <map>

typedef void* (*CREATE_FUNC)();

class DynObjectFactory {
public:
    static void* createObject(const string& name, CREATE_FUNC func) {
        map<string, CREATE_FUNC>::const_iterator it;
        it = mapCls_.find(name);
        if(it != mapCls_.end())
            return 0;
        else
            it->second();
    }

    static void register(const string& name, CREATE_FUNC func) {
        mapCls_[name] = func;
    }

private:
    static map<string, CREATE_FUNC> mapCls_;
};

//创建一个类，利用构造函数去调用DynObjectFactory的register方法达到注册的目的
class Register {
public:
    Register(const string& name, CREATE_FUNC func) {
        DynObjectFactory::register(name, func);
    }
};

#define REGISTER_CLASS(class_name) \
class class_name##Resgiter { \
public: \
    static void* newInstance() { \
        return new class_name; \
    } \
}; \


#endif //_DYN_BASE_H

这时在回到宏定义中，定义一个静态成员变量，如下：

对于静态变量在类体中只是一个声明，我们还需要在类体外面进行定义，所以修改代码如下：

#ifndef _DYN_BASE_H
#define _DYN_BASE_H
#include <string>
#include <map>

typedef void* (*CREATE_FUNC)();

class DynObjectFactory {
public:
    static void* createObject(const string& name, CREATE_FUNC func) {
        map<string, CREATE_FUNC>::const_iterator it;
        it = mapCls_.find(name);
        if(it != mapCls_.end())
            return 0;
        else
            it->second();
    }

    static void register(const string& name, CREATE_FUNC func) {
        mapCls_[name] = func;
    }

private:
    static map<string, CREATE_FUNC> mapCls_;
};

map<string, CREATE_FUNC> DynObjectFactory::mapCls_;

//创建一个类，利用构造函数去调用DynObjectFactory的createObject方法达到注册的目的
class Register {
public:
    Register(const string& name, CREATE_FUNC func) {
        DynObjectFactory::createObject(name, func);
    }
};

#define REGISTER_CLASS(class_name) \
class class_name##Resgiter { \
public: \
    static void* newInstance() { \
        return new class_name; \
    } \
private: \
    static Register reg_; \
}; \

Register class_name##Resgiter::reg_(#class_name, class_name##Resgiter::newInstance);//在实例化Register中主动去调用带两个参数的构造函数，从而达到自动注册


#endif //_DYN_BASE_H

这时编译一下：

报了N多个错误，不要害怕，下面一一来解决它，首先我们忘了包含一个命名空间：

再次编译看一下：

错误一下就减少了很多，继续来解决，先来看"error C2159: 指定了一个以上的存储类"，这是哪错了呢？

从代码来看貌似没啥错呀，但是实际上一个隐蔽的错误我们忽略了，那就是默认关键字，register实际上是一个关键字，所以问题很明显啦，更改方法名既可：

再次编译：

还有最后一点错误，接着来解决“error C2014: 预处理器命令必须作为第一个非空白空间启动”，是哪一行呢？

从错误提示来看貌似宏定义中不能以空白空间启动，这行上面确实是空了一行，难道将其删掉才可以，试一下：

再次看下还有没有错误：

成功消除掉所有错误。下面来使用一下这个头文件，看能否动态创建对象？

DynTest.cpp:

#include "Shape.h"
#include "DynBase.h"
#include <iostream>
#include <vector>
using namespace std;

//绘制所有的形状
void drawAllShapes(const vector<Shape*>& v) {
    vector<Shape*>::const_iterator it;
    for(it=v.begin();it!=v.end();++it) {
        (*it)->draw();
    }
}

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

int main(void) {
    //Shape s;//ERROR,不能实例化抽象类
    vector<Shape*> v;

    Shape* ps;
    //ps = ShapeFactory::createShape("Circle");
    ps = static_cast<Shape*>(DynObjectFactory::createObject("Circle"));
    v.push_back(ps);
    //ps = ShapeFactory::createShape("Square");
    ps = static_cast<Shape*>(DynObjectFactory::createObject("Square"));
    v.push_back(ps);
    //ps = ShapeFactory::createShape("Rectangle");
    ps = static_cast<Shape*>(DynObjectFactory::createObject("Rectangle"));
    v.push_back(ps);

    drawAllShapes(v);
    deleteAllShapes(v);

    return 0;
}

编译运行：

再次编译：

还是有错误，真的一波三折啊~继续查找原因，没办法：提示是重复定义了，那是哪里重复定义了呢？

而mapCls_对象是在DynBase.h头文件中定义的，是不是有两个文件都包含过了它？

果真是被两个cpp文件包含了，如何解决此问题呢？有两种解决方案：

方案一：将它的定义放到DynBase.cpp文件中，但是还得新建一个文件，我们的目标是不用新建也能编译通过，那就得采用方案二了：

方案二：采用一个扩展的属性来进行修饰，在vc++中可以用"__declspec(selectany)"、在g++中可以用“__attribute((weak))”。

修改代码如下：

有了这个修饰之后，mapCls_既使被多个文件包含也只会定义一次，再次编译看是否解决：

但是还有一个警告，看是哪行代码出的：

代码修改如下：

再次编译：

终于没报错了，下面来运行一下：

呃~~让人崩溃，居然运行出错了，只能硬着头皮来DEBUG看一下，这里直接贴出最终原因，以免写得太哆嗦：

更改为：

最终来运行一下：

下面回过头来看一下动态创建的过程：

而宏只是代码的包含，下面来对其中一个进行代码展开，就拿Circle为例代码展开为：

class CircleResgiter {
public:
    static void* newInstance(){
        return new Circle;
    }
private:
    static Register reg_;
};

Register CircleResgiter::reg_("Circle", CircleResgiter::newInstance())

而这时会调用Register的构造函数，它会去调用DynObjectFactory中的注册方法：

而main函数是在注册之后运行，所以在main函数中就只要去创建对象既可:

这就是整个动态创建的过程，以后如果再有新的形状，只需要定义然后注册一下既可，核心代码完全不要动，扩展性就相当好了，这实际上是组件编程的一个初步。

转载于:https://www.cnblogs.com/webor2006/p/5677402.html

weixin_30341735
关注
C++编程思想学习笔记---第13章　动态创建对象
青春不谢的专栏
11-08 861
一个空中交通指挥系统需要处理多少架飞机？一个网络中将会有多少个节点？为了解决这个普通的问题，我们需要在运行时可以创建和销毁对象是最基本的要求。当然Ｃ早就提供了动态内存分配 函数malloc()和free()，它们可以从堆中分配存储单元。 然而这些函数将不能很好地运行，因为构造函数不允许我们向他传递内存地址来进行初始化。如果这么做了，我们可能： 1. 忘记了。则在c++中的对象初始化将会难以保证
25 C++ - 动态对象创建
阿甘兄
10-08 700
当我们创建数组的时候，总是需要提前预定数组的长度，然后编译器分配预定长度的数组空间，在使用数组的时，会有这样的问题，数组也许空间太大了，浪费空间，也许空间不足，所以对于数组来讲，如果能根据需要来分配空间大小再好不过。 所以动态的意思意味着不确定性。 为了解决这个普遍的编程问题，在运行中可以创建和销毁对象是最基本的要求。当然c早就提供了动态内存分配（dynamic memory allocation...
如何一个动态创建对象？
...
07-22 617
反射八：动态创建对象 1、获得Class对象 2、构造一个对象 3、通过构造器创建对象 4、通过反射调用普通方法 5、通过反射调用方法 6、通过方式操作属性 ==这里的User为反射一中的User 代码示例： package reflect; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import jav
动态创建对象
朱铭雷的日记本
04-28 9983
1 静态存储区。全局对象所使用的内存在这里分配，这个存储空间在程序整个运行期间都存在。
QtQuick组件与对象动态创建详解（二）
02-21
现在我们看看如何动态创建、销毁组件。下面是dynamic_component.qml：这次我们在界面上放一个按钮，通过按钮来控制颜色选择组件的创建与销毁。启动应用时没有创建颜色选择组件，如图4所示：图4动态创建组件初始效果...
qt通过类名动态创建对象
02-09
在Qt框架中，动态创建对象是一项重要的编程技巧，它允许我们根据字符串形式的类名来实例化对应的对象。这样的功能在实现插件机制、运行时加载不同组件或处理未知类型对象时尤为有用。本篇文章将深入探讨如何在Qt中...
php使用变量动态创建类的对象用法示例
10-20
动态创建类的对象，意味着在运行时，我们使用变量来确定要实例化的类。这通常涉及到两个步骤：一是存储类名到变量，二是使用该变量来创建对象。在给定的代码中，我们有： ```php $pay_code='T'; $payment = new $...
（P36）对象动态创建
喜欢打篮球的普通人
10-09 381
文章目录1.对象动态创建 1.对象动态创建 反射技术指的是：动态获取类型信息（指的是：方法与属性）； 反射技术就是在运行时，动态创建对象，动态调用对象的方法，动态操作对象的属性； 要实现反射，需要给每个类添加元数据，这些元数据就是类的方法与属性； 我们这里只讲动态创建对象，即：对原有的类不做任何更改，只需要增加一个宏就能实现动态创建； 总结 （1）避免了P35\01.cpp中工厂模式的if else语句的编写 （2）增加了可扩展性，增加一个新类，不需要再工厂模式的类中增加if else语句 （3）可以将
【C++】动态对象创建
Jacky_Feng的博客
10-20 5773
在C语言中提供了内存分配函数malloc()（或calloc()/realloc()）和free()，这些函数在运行时从堆内存中分配存储单元。 然而，在C++中这些函数将不能很好地运行。因为构造函数不允许我们向它传递内存地址来进行初始化。 C++是如何保证正确的初始化和清理，又允许我们在堆上动态创建对象呢？ malloc()和free()都是库函数，因此不在编译器控制范围为内。然而，如果有一个完成动态内存分配及初始化组合动作的运算符和另一个完成清理及释放内存组合动作的运算符，编译器就可以保证所有对象的
动态对象创建-----new和delete
hflyingheart的专栏
07-27 1707
 C++中的new和delete是如何在堆上安全地创建对象为对象分配内存的三种方式：１）静态内存分配在程序开始之前就已分配好了存储空间，直到程序结束２）在栈上分配内存当程序运行到一个执行点（譬如以“ { ”开始的一个程序块），存储空间在栈上被创建，当出这个这程序块时，自动释放。如果为一些局部变量分配存储单元一样。这种分配方法分配的存储空间大小是固定的，且要在程序中明确指定所要分
C++回顾（六）—— 对象动态建立
qq_50615776的博客
03-02 560
简单介绍了一下new和delete的用法，以及初始化对象列表
C++面向对象程序设计 - 对象的动态建立和释放、赋值和复制
最新发布
觉醒法师的专栏
04-09 1247
在C++中，对象的动态建立和释放通过使用new和delete操作符来完成的，new用于在运行时动态分配内存以创建对象，而delete用于释放这些动态分配的内存。对象的赋值和复制是两个不同的概念，赋值是通过操作符“=”进行的；复制是构造函数来实现的。
R5-2填写程序中的空白，完成指定的功能
77生活工作室的博客
06-09 2959
#include<iostream> using namespace std; class R{ int len,w; public: R(int len,int w);//成员函数声明； int getArea(); //构造函数声明； }; R::R(int len,int w){ this->len=len; this->w=w; //对象数据成员名字一样，用this指针表示 //参数与成员变量名相同时，如this->n = .
静态创建和动态创建对象的区别
Stephen___Qin的博客
04-13 1354
一.区别介绍 静态创建对象指的是在栈上创建对象,比如A a;它会在对象的作用域结束后自动销毁. 动态创建对象指的是在堆上创建对象,然后栈上的指针指向创建的对象.比如A *pa = new A();它需要程序员手动delete掉.如果不进行delete操作,只能等到程序结束后,由OS来回收掉. 代码说明: #include <iostream> using namespace std...
动态创建宏的简单实现
tigerinyy的专栏
03-20 687
练习的动态创建，从字符串创建对象的实现用一个类里面的静态变量保存所有注册过的类的类名和创建函数的指针//u.h#pragma once#include #include using std::string; using std::map; using std::pair; //强制转换模板函数 template Dest force_cast(Src src) { union {
QtQuick组件与对象动态创建深度解析
本文主要讲解了QtQuick中的Component（组件）以及如何动态创建和使用这些组件，这是QtQuick组件与对象动态创建详解系列的第一部分。 在QtQuick中，Component是一种非常重要的概念，它是预先定义并封装好的QML类型，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值