内存不够处理 -- 自己写new_handler(转：没考虑多线程问题)

如果不满足内存分配请求时，不断重复调用new-handler函数
当前的new-handler可以利用set_new_handler安装新的new-handler取代它。

/**/
//
// FileName : lianxi.cpp
// Creator  : longshen
// Date : 2009-7-17
// Commet : 处理内存不够
//
/**/
#include  < new >
#include  < iostream >

using   namespace  std;


/**/ /* *
* @brief    内存不够的处理    
* @return    __cdecl
*/
void  __cdecl noMoreMemory( )
{
   cout  <<   " Unable to satisfy request for memory "   <<  endl;
    throw  bad_alloc( );
    return ;
}


int  main( ) 
{
    // 安装新new-handler函数
    set_new_handler(noMoreMemory);         // The new handler is used by operator new
    try
    {
       while  (  1  ) 
       {
          new   int [ 5000000 ];
         cout  <<   " Allocating 5000000 ints. "   <<  endl;
      }
   }
    catch  (exception e)
    {
      cout  <<  e.what( )  <<  endl;
   }
    return   0 ;
}

   C++不支持专门针对类的new-handler函数，我们可以自己来实现它

/**/
//
// FileName : lianxi.cpp
// Creator  : longshen
// Date : 2009-7-17
// Commet : 处理内存不够
//
/**/
#include  < new >
#include  < iostream >

using   namespace  std;


/**/ /* *
* @brief    内存不够的处理    
* @return    __cdecl
*/
void  __cdecl noMoreMemory( )
{
   cout  <<   " Unable to satisfy request for memory "   <<  endl;
    throw  bad_alloc( );
    return ;
}


class  Kx
{
     public :
         static  new_handler set_new_handler(new_handler p);
         static   void *   operator   new (size_t size);
         int  a[ 10000000 ];
     private :
         static  new_handler currentHandler;
} ;


/**/ /* *
* @brief    设置类的currentHandler，并返回旧的new-handler
* @param    p    输入的new-handler函数
* @return    返回旧的new-handler
*/
new_handler Kx::set_new_handler(new_handler p)
{
    new_handler oldHandler  =  currentHandler;
    currentHandler  =  p;
     return  oldHandler;
}


/**/ /* *
* @brief    缺省设置currentHandler为0(即null)
* @return    返回new-handler函数地址
*/
new_handler Kx::currentHandler;       //  缺省设置currentHandler为0(即null)


/**/ /* *
* @brief    重载new
* @param    size 申请要开辟内存的大小
* @return    内存空间指针
*/
void *  Kx:: operator   new (size_t size)
{
    new_handler globalHandler  =                          //  安装Kx的new_handler
        std::set_new_handler(currentHandler);

     void *  memory;
     // 尝试分配内存
     try
     {
        memory  =  :: operator   new (size);
    }
     catch (std::bad_alloc & )
     {
        std::set_new_handler(globalHandler);     // 恢复旧的new_handler
         throw ;                                 // 抛出异常
    }

    std::set_new_handler(globalHandler);         // 恢复旧的new_handler
    
     return  memory;
}


int  main()
{
    
     try   {
         while ( 1 )
         {
             // 把noMoreMemroy设置为Kx的new-handling函数
            Kx::set_new_handler(noMoreMemory);            
            

            Kx *  pkx  =   new  Kx;             // 如果内存分配失败，调用noMoreMemory


             string *  pszStr  =   new   string ;  // 如果内存分配失败，调用全局new-handling函数

             // 设Kx的new-handling函数为空
            Kx::set_new_handler( 0 );        

            Kx *  pkx2  =   new  Kx;         // 如果内存分配失败，立即抛出异常
                                     // 类Kx没有new-handling函数

            cout  <<   " Allocating 20000000 ints. "   <<  endl;
        }
    }
     catch  ( exception e )
     {
        cout  <<  e.what( )  <<  endl;
    }
     return   0 ;
}

 

http://www.cppblog.com/longshen/archive/2009/07/17/90352.html