网易 
新闻 LOFTER 邮箱 相册 阅读 图书 有道 摄影 企业邮箱 优惠券 云笔记 闪电邮 邮箱大师 印像派 考拉海购
 
更多
博客 
手机博客 博客搬家 博客VIP服务 发现 小组 风格
 
群博客 博客油菜地 博客话题 博客热点 博客圈子 找朋友
 
登录  
 加关注
查看详情
   显示下一条  |  关闭
温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！立即重新绑定新浪微博》  |  关闭

图像处理 视频分析 机器视觉 模式识别

方向比努力更重要

导航

 
 
 
 
 

日志

 
 
关于我
河北程序员

河北软件开发项目,电子警察卡口项目,公安天网项目,媒体流处理,数字图像处理。媒体服务器 RTSP、图像处理、车牌识别……DCT变换,H.264压缩

文章分类

构造函数 析构函数 堆和类数组 重载new和delete运算符  

2010-06-10 09:13:37|  分类： C + 算法 |  标签： |举报 |字号大中小 订阅

  下载LOFTER 我的照片书  |

用new[]的方法一定要提供默认构造函数(否则不能通过编译).

一、构造函数和析构函数
    前面的例子已经运用了new和delete来为类对象分配和释放内存。当使用new为类对象分配内存时，编译器首先用new运算符分配内存，然后调用类的构造函数；类似的，当使用delete来释放内存时，编译器会首先调用泪的析构函数，然后再调用delete运算符。
        #include iostream.h
        class Date
        {
            int mo,da,yr;
        public:
            Date()  { cout<<Date constructor<<endl; }
            ~Date() { cout<<Date destructor<<endl; }
        }
        int main()
        {
            Date* dt = new Date;
            cout<<Process the date<<endl;
            delete dt;
            return 0;
        }
    程序定义了一个有构造函数和析构函数的Date类，这两个函数在执行时会显示一条信息。当new运算符初始化指针dt时，执行了构造函数，当delete运算符释放内存时，又执行了析构函数。
    程序输出如下：
        Date constructor
        Process the date
        Date destructor
二、堆和类数组
    前面提到，类对象数组的每个元素都要调用构造函数和析构函数。下面的例子给出了一个错误的释放类数组所占用的内存的例子。
        #include iostream.h
        class Date
        {
            int mo, da, yr;
        public:
            Date()  { cout<<Date constructor<<endl; }
            ~Date() { cout<<Date destructor<<endl; }
        }
        int main()
        {
            Date* dt = new Date[5];
            cout<<Process the date<<endl;
            delete dt;          //这儿
            return 0;
        }
    指针dt指向一个有五个元素的数组。按照数组的定义，编译器会让new运算符调用Date类的构造函数五次。但是delete被调用时，并没有明确告诉编译器指针指向的Date对象有几个，所以编译时，只会调用析构函数一次。下面是程序输出；
        Date constructor
        Date constructor
        Date constructor
        Date constructor
        Date constructor
        Process the date
        Date destructor
    为了解决这个问题，C++允许告诉delete运算符，正在删除的那个指针时指向数组的，程序修改如下：
        #include iostream.h
        class Date
        {
            int mo, da, yr;
        public:
            Date()  { cout<<Date constructor<<endl; }
            ~Date() { cout<<Date destructor<<endl; }
        }
        int main()
        {
            Date* dt = new Date[5];
            cout<<Process the date<<endl;
            delete [] dt;          //这儿
            return 0;
        }
    最终输出为：
        Date constructor
        Date constructor
        Date constructor
        Date constructor
        Date constructor
        Process the date
        Date destructor
        Date destructor
        Date destructor
        Date destructor
        Date destructor
三、重载new和delete运算符
    前面已经介绍了如何用new和delete运算符函数来动态第管理内存，在那些例子中使用的都是全局的new和delete运算符。我们可以重载全局的new和delete运算符，但这不是好的想法，除非在进行低级的系统上或者嵌入式的编程。
    但是，在某个类的内部重载new和delete运算符时可以的。这允许一个类有它自己的new和delete运算符。当一个类需要和内存打交道时，采用这种方法来处理其中的细节，可以获得很搞的效率，同时避免了使用全局new和delete运算符带来的额外开销。因为全局堆操作时调用操作系统函数来分配和释放内存，这样效率很低。
    如果确定某个类在任何时候，其实例都不会超过一个确定的值，那么就可以一次性为类的所有实例分配足够的内存，然后用该类的new和delete运算符来管理这些内存。下面的程序说明了如何对new和delete进行重载。
        #include iostream.h
        #include string.h
        #include stddef.h
        #include new.h
        const int maxnames = 5;
        class Names
        {
            char name[25];
            static char Names::pool[];
            static bool Names::inuse[maxnames];
        public:
            Names(char* s)  { strncpy(name,s,sizeof(name)); }
            void* operator new(size_t) throw(bad_alloc);
            void operator delete(void*) throw();
            void display() const  { cout<<name<<endl; }
        };
        char Names::pool[maxnames * sizeof(Names)];
        bool Names::inuse[maxnames];
        void* Names::operator new(size_t) throw(bad_alloc)
        {
            for(int p=0; p<maxnames; p++)
            {
                if(!inuse[p])
                {
                    inuse[p] = true;
                    return pool+p*sizeof(Names);
                }
            }
            throw bad_alloc();
        }
        void Names::operator delete(void* p) throw()
        {
            if(p!=0)
                inuse[((char*)p - pool)/sizeof(Names)] = false;
        }
        int main()
        {
            Names* nm[maxnames];
            int i;
            for(i=0; i<maxnames; i++)
            {
                cout<<endl<<Enter name # <<i+1<<:;
                char name[25];
                cin >> name;
                nm = new Names(name);
            }
            for(i=0; i<maxnames; i++)
            {
                nm->display();
                delete nm;
            }
            return 0;
        }
    上面的程序提示输入5个姓名，然后显示它们。程序中定义了名为Names的类，它的构造函数初始化对象的name值。这个类定义了自己的new和delete运算符。这是因为程序能保证不会一次使用超过maxnames个姓名，所以可以通过重载默认的new和delete运算符来提高运行速度。
    Names类中的内存池是一个字符数组，可以同时容纳程序需要的所有姓名。与之相关的布尔型数组inuse为每个姓名记录了一个true和false值，指出内存中的对应的项是否正在使用。
    重载的new运算符在内存池中寻找一个没有被使用的项，然后返回它的地址。重载的delete运算符则标记那些没有被使用的项。
    在类定义中重载的new和delete运算符函数始终是静态的，并且没有和对象相关的this指针。这是因为编译器会在调用构造函数之前调用new函数，在调用析构函数后调用delete函数。
    new函数是在类的构造函数之前被调用的。因为这时内存中还不存在类的对象而且构造函数也没有提供任何初始化值，所以它不可以访问类的任何成员。同理，delete运算符是在析构函数之后被调用的，所以它也不可以访问类的成员。
四、异常监测和异常处理
    1.检测异常
        上面的例子还缺少必要的保护机制。比如，重载的delete运算符函数并没有检查它的参数，确认其是否落在内存池内部。如果你绝对相信自己编的程序中不会传递错误的指针值给delete运算符，那么可以省掉合法性检查以提高效率，特别是在优先考虑效率的程序中。否则应该使用预编译的条件语句。在软件的测试版本中加入这些检测，在正式的发行版本中去掉这些检查。
    2.重载new和delete中的异常处理
        上面的两个重载运算符函数都是用了异常处理。异常处理是C++的新内容之一，目前还没有讲到。在这里不必关心它是如何工作的。上面程序中，当试图分配超过内存池容量的Names缓冲区，重载的new运算符函数就会抛出异常，终止程序。
五、重载new[]和delete[]
    对于上面的程序，假如有下面的语句:
        Names *nms=new Names[10]
          ...
        delete [] nms;
    那么，这些语句会调用全局new和delete运算符，而不是重载过的new和delete。为了重载能为对象数组分配内存的new和delete运算符，必须像下面的程序一样，对new[]和delete[]也进行重载。
        #include iostream.h
        #include string.h
        #include stddef.h
        #include new.h
        const int maxnames = 5;
        class Names
        {
            char name[25];
            static char Names::pool[];
            static bool Names::inuse[maxnames];
        public:
            Names(char* s)  { strncpy(name,s,sizeof(name)); }
            void* operator new(size_t) throw(bad_alloc);
            void operator delete(void*) throw();
            void display() const  { cout<<name<<endl; }
        };
        char Names::pool[maxnames * sizeof(Names)];
        bool Names::inuse[maxnames];
        void* Names::operator new[](size_t size) throw(bad_alloc)
        {
            int elements=size/sizeof(Names);
            int p=-1;
            int i=0;
            while((i<maxnames) && (p==-1))
            {
                if(!inuse)  p=i;
                ++i;
            }
            // Not enough room.
            if ((p==-1) || ((maxnames-p)<elements))  throw bad_alloc();
            for(int x=0; x<elements; ++x)   inuse[p+x]=elements;
            return pool+p*sizeof(Names);
        }
        void Names::operator delete[](void* b) throw()
        {
            if(b!=0)
            {
                int p=((char*)b- pool)/sizeof(Names);
                int elements=inuse[p];
                for (int i=0; i<elements; i++)   inuse[p+i]=0;
            }
        }
        int main()
        {
            Names* np = new Names[maxnames];
            int i;
            for(i=0; i<maxnames; i++)
            {
                cout<<endl<<Enter name # <<i+1<< :;
                char name[25];
                cin >> name;
                *(np + i) = name;
            }
            for(i=0; i<maxnames; i++) (np+i)->display();
            delete [] np;
            return 0;
        }
    重载new[]和delete[]要比重载new和delete考虑更多的问题。这是因为new[]运算符时为数组分配内存，所以它必须记住数组的大小，重载的delete[]运算符才能正确地把缓冲区释放回内存池。上面的程序采用的方法比较简单，吧原来存放缓冲区使用标志的布尔型数组换成一个整型数组，该数组的每个元素记录new[]运算符分配的缓冲区个数，而不再是一个简单的true。当delete[]运算符函数需要把缓冲区释放回内存池时，它就会用该数组来确认释放的缓冲区个数。

  评论这张
 
阅读(3341)| 评论(3)

历史上的今天

评论

<#--最新日志，群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇，下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

我的照片书 - 手机博客 - 下载LOFTER APP - 订阅此博客

网易公司版权所有 ©1997-2018