对new的几种形式的一些认识 (一)

原创 2006年06月24日 10:07:00
一道考题:请说说已经有malloc函数了为何还要引进new?

答:当用在内置数据类型或者结构时,malloc能满足我们的需要,但用在类类型时不能,这就需要引用new,

new既分配堆内存,又自动调用类的构造函数来创建对象。

是本教科书都有提到上面这一点,可是这些公司为何还乐此不疲的考到这到道题呢?事情不是这么简单,我献

丑说这几句。

一、new 与 opeartor new

    首先问大家一个问题:new 与 opeartor new有何区别?
如果你回答:operator new就是new的重载运算符呗!

回答错误,new是C++内部定义的一种操作符,总像sizeof一样是一种操作符,而operator new是实作者定义的

一个全局函数。不信,你可以写下面的语句:

int *p = operator new(  //这时候,用的是VC的话,就会自动提示该函数的原型。嗯,有七个版本之多。好

,现在我们弄清楚了,一个是操作符,一个是全局函数,而不是原来所以为的是重载的关系。正同我们看看他

们各有什么用?

new操作符作了三件事.语句:

    MyClass * p = new MyClass;
的伪码大至如下:

void *memory = operator new(sizeof(MyClass)); //1调用全局函数: operator new
MyClass::MyClass();              //2调用构造函数创建对象,如带参数的话                            

       //调用的就是带参构造函数

MyClass * p = static_cast<MyClass*>(memory); //3转换指针类型,并赋给p


我们可以猜测到真正的内存分配是在operator new函数中完成的。

operator new函数其之的原型是:
void* operator new(size_t size) throw(std::bad_alloc)
返回类型是void* ,  参数类型是:size_t ,是一个在系统头文件 <cstddef>中定义的typedef。sizeof()的

操作结果就是该类型的。

void* operator new(size_t size)大至如下:

void *p ;
while((p = malloc(size)) == 0)
{
     //内存分配失败。
    if ( _callnewh(size) == 0)
    {
          _Nomemory();
    }
}

return p;

如果内存分配成功则直接返回所分配的内存的首地址。不然就循环调用if语句,首先判断 _callnewh(size)调

用是否成功,不成功则调用_Nomemory(),_Nomemory()实际上作用是抛出一个异常,所抛出的是一个标准库中

定义的std::bad_alloc对象。_callnewh()函数首先会判断一个全局变量 _pnhHeap是否为零, _pnhHeap存放的

是一个函数指针,我们可以为new操作指定一个出错处理函数,也就是说当new分配内存失败时就会调用我们刚

才指定的函数,出错处理函数原型必须是无参且返回类型是void的函数。可以通过全局函数set_new_handler

(new_handler pnew)来设定我们的出错处理函数,而他又是通过调用_PNH _set_new_handler(_PNH pnh)来实现

设定我们的出错处理函数的。下面是_PNH _set_new_handler(_PNH pnh)的定义:

_PNH __cdecl _set_new_handler(
        _PNH pnh
        )
{
        _PNH pnhOld;

        /* lock the heap */
        _mlock(_HEAP_LOCK);

        pnhOld = _pnhHeap;  //把原来在起作用的出错处理函数的指针赋给pnhOld
        _pnhHeap = pnh;     //我们新设定的出错处理函数的指针。

        /* unlock the heap */
        _munlock(_HEAP_LOCK);

        return(pnhOld);     //返回原来旧的出错处理函数的指针。
}


回到我们的_callnewh()函数,如果在MyClass * p = new MyClass;语句之前设定了出错处理函数,那么这里的

_pnhHeap就不为零,接着就会调用(*_pnhHeap)()即我们的出错处理函数,否则返回零。接着调用_Nomemory()

抛出异常。这个出错处理函数是个重要的函数,设计的好的话可以做很多事情,因为他是在while中被调用的有

多次被调用的机会。在我们的出错处理函数中如果没有使用exit(1)等退出程序的语句,也没有抛出异常的话,

执行完我们的出错处理函数后,又回到while((p = malloc(size)) == 0),再次分配内存并判断,还是失败的

话,再次调用我们的出错处理函数,当然这个出错处理函数和上面的那个出错处理函数不一样了,因为我们可

以在上面那个出错处理函数中调用set_new_handler(_PNH pnh)重新设定一个出错处理函数,也就是我们第二次

调用的这个出错处理函数。还不行的话,可以继续循环,直到你满意为止。如果你觉得累了,不玩了,最后就

会调用_Nomemory()抛出异常,函数返回到new调用的地方。

  好,现在我们清楚了操作符new作了三件事,首先调用全局operator new函数, 后者通过调用传统的malloc

函数分配内存,如果成功直接返回,不然,判断出错处理函数是否为零,不为零的话,调用我们的出错处理函

数。否则调用_Nomemory()抛出异常。如果p = malloc(size)成功,new接着做第二件事,创建对象,最后转换

指针类型并返回。

我们可以重写operator new函数。当编译器看到语句MyClass * p = new MyClass;

首先会检查我们的类定义看是否提供有operator new函数,如有,则调用该函数,接着调用构造函数,转换类

型并返回。如果没有重写operator new函数,则new操作符会调用全局中的那个operator new函数,也就是我们

上面说的这个函数。但是如果我们在new操作符前面限定了::即这样写 ::new MyClass则编译器不会去检查我们

的类的定义而直接调用全局的operator new函数。

    操作符new不可以重载,就像sizeof操作符一样是不可以重载的。我们重载的是operator new函数。所以有

一些限定,我们重载的operator new函数的返回类型必须是void*,第一个参数必须是size_t类型的。下面是一

个自定义的operator new函数:

class MyClass
{
  public:
     MyClass()
     {
       cout << "MyClass::MyClass()" << endl;
      }

    static void* operator new(size_t size);

  ~MyClass()
  {
     cout << "MyClass::~MyClass()" << endl;
  }
};

void* MyClass::operator new(size_t size)
{
   //在这里可以对类的静态成员数据做些控制。我们在这里有一句输出语句代替。
  
   cout << "MyClass::operator new" << endl;
  
   void* p = new MyClass;

   return p;
}
    
这样写是行不通的,因为在MyClass::operator new中的void* p = new MyClass的new是操作符new,他做三件

事,第一件就是调用MyClass::operator new(size_t size),所以这里
是递归调用了。把程序改成:

void* MyClass::operator new(size_t size)
{
   //在这里可以对类的静态成员数据做些控制。我们在这里有一句输出语句代替。
   cout << "MyClass::operator new" << endl;
  
   void* p = operator new(size);  //已修改。

   return p;
}

这样还是不行的,这样是直接递归(自己调用自己)。刚才是间接递归。应该改成:void* p = ::operator new

(size);  OK,使用的是全局中的operator new,或者写成:void* p = malloc( size),只是这样一来,出错后

不会自动调用出错处理函数了,只会简单的返回NULL,所以在使用new操作符的地方要注意先检测返回值是否为

零,所以最好不用malloc,还是用:: operator new(size)好,这里还可以用void* p = new char[size],用的

是new[]操作符,不会两次调用构造函数,也不会造成递归。只是要注意在我们重写的operator delete函数中

要调用delete[] 后释放。一般情况下,我们重写了operator new函数,都要重写operator delete函数,而且

后者中的释放资源的函数要与前者分配资源的函数的形式要搭配。


另外,要想把自己重写的operator new函数设计得好,还是有好些地方需要注意的。好在需要我们重写这个函

数的情况不多,真正需要重写时,还是先参考些这方面的资料才行,<effective c++>一书中就有相关的知识介

绍。在这里我只是提到一下,让大家知道有这么一回事,应付一下这道公司们乐此不疲的考题。洋洋洒洒写上

上千字,小样,看你还敢不敢考这样的考题。


二、new[] 与 operator new[]

  new[]操作符与new差不多,同样做三件事:调用operator new[]函数,历遍一个vector调用构造函数。转换

指向首地址的指针类型并返回。

operator new[]函数通过把操作符new A[number]中的A与number进行计算:size_t count = number * sizeof

(A), 然后调用全局函数operator new(count).

三 new(void*) Myclass 与 operator new(size_t, void*)
  
   指定位置创建操作符new()同样做三件事,第一件就是调用operator new(size_t, void*)函数,下面两件和

new操作符的最后二件事是一样的。让我们来看看vs.net中operator new(size_t, void*)的定义:

inline void *__cdecl operator new(size_t, void *_Where) _THROW0()
    {    // construct array with placement at _Where
    return (_Where);
    }

和operator new相比好简单哦,我们看到了,他并没有调用malloc函数,也没有调用operator new函数,他怎

么分配的内存啊?!对于operator new函数,他通过循环调用malloc函数来分配一块内存,最好把这块分配好的

内存return p返回给操作符new,让他在上面做第二,第三件事。我们这里return (_Where);按此推理,_Where
6应该指向一块已分配的可使用的内存。_Where从那里来的啊?答案是使用操作符new(void* _Where) MyClass

时所指定的。这就是指定位置创建操作符new()的用法,先在别处分配好一块内存,然后把这块内存的首地址做

为参数调用new(),new()就会在这块指定位置上创建对象,然后再把这块指定的内存的首地址自制一份给p,接

着转换类型并返回。这样子操作符new()并没有真正分配内存,所以不能调用delete来释放内存。当程度使用共

享内存或者memory-mapped I/O指定位置创建就比较有用,因为在这样的程序里对象必须放置在一个确定的地址

上或者一块被例程分配的内存里。下面看个例子。


#include <iostream>
#include <new>                     //要使用指定位置创建操作符发布包含该头文件。
using namespace std;

void* mallocShared(size_t size);  //用于分配共享内存,该函数是别的程序员写的,你只知道通过
                                   //调用他可以获得一块已分配而未初始化的内存。

class A
{
   public:
   A()
   {
      cout << "A::A()" << endl;
      m_n = 0;
   }

   int Get()
   {
      return m_n;
   }

   ~A()
   {
      cout << "A::~A()" << endl;
   }

private:
int m_n;
};

int main()
{
    void* p = mallocShared(sizeof(A)); //该句也有可能是在别的地方调用的,
                                       //然后把p传过来。这里为了简化而放在此调用

    A* pA = new(p) A;

    cout << pA->Get() << endl;

    delete pA;

    return 0;
}


////////////////////////////////////////////////////////////////////////////////////

/* 下面是另一个程序员在一个模块中写的mallocShared()函数,
  你不知道其具体实现,只是通过导出该函数来使用。*/


void* mallocShared(size_t size)
{
    void* p = malloc(size);
    
    if ( p == NULL)
    {
        cerr << "mallocShared(size_t size) failed!" << endl;

        exit(1);
    }

    return p;
}

这个程序有问题吗?抛开设计上的好坏不说,就说这个程序能否通过编译?如能,运行结果如何?请先思考三

分钟再往下看。









有疑问的可能是这一句delete pA; 函数mallocShared不是你写的,你不知道其内部是通过什么形式分配的内存

,就调用delete来释放能行吗?假如又让我们知道他内部是通过malloc函数来分配的内存,用delete来释放能

行吗?答案是:能通过编译,并能得出正确结果,通过malloc函数来分配的内存用delete来释放是没问题的,

new操作符不也是通过malloc来分配的内存,同样可以用delete来释放啊。如果mallocShared是下面这样子,情

况又怎么样呢?

void* mallocShared(size_t size)
{
    
    return (new char[size]);
}

结果是和上面是一样的,delete p没问题,只要用new[]来分配的内存块的大小和用delete释放的内存的大小是

一样的就没问题。回想一下看,我们用new A来分配内存时,实际上是通过operator new(size)来分配的,这里

的size = sizeof(A),这种情况下我们可以用 delete p来释放,只要p 的类型是A*,因为delete 是通过调用

operator delete(size)函数来释放的内存,这里的size也是等于sizeof(P),当我们调用new char[number]时

,先调用operator new[]函数,后者实际上也是调用 operator new(number* sizeof(char))来分配的内存,既

然都是通过调用operator new来分配的内存,所以调用delete 来释放应该也是没问题的。因为这

里:mallocShared(sizeof(A)) ---->  size == sizeof(A) == size* sizeof(char) == sizeof(P) 大小一样。
改成:

void* mallocShared(size_t size)
{
    
    return (operator new(size));
}

结果也是一样的! 当然这里是假设没有提供自己的operator new函数的情况下,如果重写了operator new函数

就要改成:

void* mallocShared(size_t size)
{
    
    return (::operator new(size));   //用的是全局函数
}

这个程序目前没问题,但是存在很多的安全隐患,很容易就出错,一不小心就阴沟里翻船,有“未定义”行为

产生,结果是啥事都有可能发生。应该谢绝写这样的程序。

上面说了mallocShared(sizeof(A));可能不是在你的程序中调用的,而是在别人那里调用的,然后别人给你传

来一个指针让你把这个指针作为参数调用你自己的A* pA = new(p) A,这样子你调用delete p来释放,别人那里

或者还需要用,因为这是共共享的内存,又或者别人那里在做完想要做的工作之后,调用delete ,这样子就出

问题了。同一块内存不能释放两次。就算mallocShared(sizeof(A));是在你这里调用的,那么你可以算是内存

的分配者,你有权利and义务把他释放,可是你也要先确定别人还需不需要用到这块内存,需要的话,你就不能

马上delete,又或者呆会你自己也还需要用到,再次在这块内存上指定位置创建。所以就不必再调用

mallocShared(sizeof(A));来分配内存。把主函数改成下面这样,结果又如何,能通过编译吗?

int main()
{
    void* p = mallocShared(sizeof(A)); //就限定是在这里调用的。

    A* pA = new(p) A;

    cout << pA->Get() << endl;

    A* pA1 = new(p) A;                 //再次指定位置创建。



    delete pA;

    return 0;
}

答案是:能通过编译,运行结果如下:

A::A()
0
A::A()
~A::A()

原来的那块内存是确实被释放掉了的,只是这里构造函数A::A()调用了两次而析构函数A::~A()只调用一次,
这显然不太好,如果你的类在其他地方分配了资源,需要通过析构函数来释放,这样子你少调用了一次析构函

数就会造成内存泄漏或者别的问题了。所以应该把程序改成下面这样:


int main()
{
    void* p = mallocShared(sizeof(A)); //就限定是在这里调用的。

    A* pA = new(p) A;

    cout << pA->Get() << endl;

    A* pA1 = new(p) A;                 //再次指定位置创建。

        pA->~A();         //这里显式调用析构函数来析构对象,但是内存并没有释放,还可以再次使用。

    A* pA1 = new(p) A;

       //在这里判断别的程序是否还需要用到该内存

    delete pA;      //当别人不再需要,自己也不会再用到,可以释放!

    return 0;
}

这句delete p总让我担心受怕,最好调用和mallocShared函数相对应的函数来释放内存,你写了mallocShared

函数来分配资源就有义务写一个freeShared函数来释放资源,分配资源函数和释放资源函数是一对的,一起提

供给别人使用。因为只有你自己最清楚你的mallocShared函数是怎么分配的资源,你的freeShared就应该做相

应的工作。比如在mallocShared中除了分配内存,还用到其他资源,如果直接调用delete p来释放那就成问题

了。应该调用freeShared来释放。如果你是老板而你的员工只写一个mallocShared函数却没有提供相应的

freeShared函数,建议你让他走人! 不然迟早会出问题的。如果void* p = mallocShared(sizeof(A)); 语句不

是在这里调用的,你既不能使用delete p,也不能使用freeShared(p),或者其他一切释放资源的函数。不是你

分配的资源你无权释放。当然你对整个程序把握得比较好,一切尽在你控制中,而你又和别人有协议由你来释

放的情况除外。
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

hadoop+lucene几种结合形式

  • 2017-01-10 09:42
  • 484KB
  • 下载

Effective c++ 条款16学习笔记: 成对使用new和delete时要采取相同形式

User the same from in corresponding uses of new and deletes 条款16:User the same from in correspond...

Javascript函数深入研究:函数中判断自己是以哪种形式被调用的,是A(),还是new A()或者其它?

Javascript函数深入研究:函数中判断自己是以哪种形式被调用的,是A(),还是new A()或者其它? 本文通过一个比较全面的示例,展示如何在函数定义中对各种情形进行判断。 需要指出的是,有...

C++之成对使用的new和delete时采取相同形式(16)---《Effective C++》

条款16:成对使用new和delete时候采取相同形式成对使用的new和delete需要采用相同的形式,可以先看如下代码:std::string* stringArray=new std::strin...

条款16:成对使用new和delete时要采取相同形式

条款16:成对使用new和delete时要采取相同形式
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)