📄 effective c++ 2e item7.htm
字号:
<TD align=middle width=120><B>贴文时间</B><BR>2001-7-2 16:25:54 </TD>
<TD align=middle width=80><B>文章类型: </B><BR>翻译 </TD>
<TD align=middle width=100><B>给贴子投票 </B><BR><A
href="http://www.csdn.net/develop/addscore.asp?id=8610">投票</A> </TD></TR>
<TR>
<TD> lostmouse 翻译 </TD>
<TD vAlign=top colSpan=3><B>出处: </B><A
href="http://www.csdn.net/develop/article/8/Effective%20C++%202e%20electronic%20book">Effective
C++ 2e electronic book </A></TD></TR>
<TR>
<TD bgColor=#cccc99 colSpan=5> </TD></TR></TD></TR></TBODY></TABLE>
<DIV align=center>
<DIV class=fst align=left>
<DIV class=fstdiv3 id=print2><BR><BR>
<P>条款7：预先准备好内存不够的情况</P>
<P>operator
new在无法完成内存分配请求时会抛出异常(以前的做法一般是返回0，一些旧一点的编译器还这么做。你愿意的话也可以把你的编译器设置成这样。关于这个话题我将推迟到本条款的结尾处讨论)。大家都知道，处理内存不够所产生的异常真可以算得上是个道德上的行为，但实际做起来又会象刀架在脖子上那样痛苦。所以，你有时会不去管它，也许一直没去管它。但你心里一定还是深深地隐藏着一种罪恶感：万一new真的产生了异常怎么办？</P>
<P>你会很自然地想到处理这种情况的一种方法，即回到以前的老路上去，使用预处理。例如，C的一种常用的做法是，定义一个类型无关的宏来分配内存并检查分配是否成功。对于C++来说，这个宏看起来可能象这样：<BR>
#define NEW(PTR,
TYPE)
\<BR> try { (PTR) = new TYPE;
}
\<BR> catch (std::bad_alloc&) {
assert(0); }<BR>（“慢！std::bad_alloc是做什么的？”你会问。bad_alloc是operator
new不能满足内存分配请求时抛出的异常类型，std是bad_alloc所在的名字空间(见条款28)的名称。“好！”你会继续问，“assert又有什么用？”如果你看看标准C头文件<assert.h>(或与它相等价的用到了名字空间的版本<cassert>，见条款49)，就会发现assert是个宏。这个宏检查传给它的表达式是否非零，如果不是非零值，就会发出一条出错信息并调用abort。assert只是在没定义标准宏NDEBUG的时候，即在调试状态下才这么做。在产品发布状态下，即定义了NDEBUG的时候，assert什么也不做，相当于一条空语句。所以你只能在调试时才能检查断言(assertion)）。</P>
<P>NEW宏不但有着上面所说的通病，即用assert去检查可能发生在已发布程序里的状态(然而任何时候都可能发生内存不够的情况)，同时，它还在C++里有另外一个缺陷：它没有考虑到new有各种各样的使用方式。例如，想创建类型T对象，一般有三种常见的语法形式，你必须对每种形式可能产生的异常都要进行处理：<BR>
new T;</P>
<P> new T(constructor arguments);</P>
<P> new T[size];</P>
<P>这里对问题大大进行了简化，因为有人还会自定义(重载)operator new，所以程序里会包含任意个使用new的语法形式。</P>
<P>那么，怎么办？如果想用一个很简单的出错处理方法，可以这么做：当内存分配请求不能满足时，调用你预先指定的一个出错处理函数。这个方法基于一个常规，即当operator
new不能满足请求时，会在抛出异常之前调用客户指定的一个出错处理函数——一般称为new-handler函数。(operator
new实际工作起来要复杂一些，详见条款8)</P>
<P>指定出错处理函数时要用到set_new_handler函数，它在头文件<new>里大致是象下面这样定义的：<BR>
typedef void (*new_handler)();<BR> new_handler
set_new_handler(new_handler p) throw();</P>
<P>可以看到，new_handler是一个自定义的函数指针类型，它指向一个没有输入参数也没有返回值的函数。set_new_handler则是一个输入并返回new_handler类型的函数。</P>
<P>set_new_handler的输入参数是operator
new分配内存失败时要调用的出错处理函数的指针，返回值是set_new_handler没调用之前就已经在起作用的旧的出错处理函数的指针。</P>
<P>可以象下面这样使用set_new_handler：<BR>// function to call if operator new can't
allocate enough memory<BR>void noMoreMemory()<BR>{<BR> cerr <<
"Unable to satisfy request for memory\n";<BR> abort();<BR>}</P>
<P>int main()<BR>{<BR> set_new_handler(noMoreMemory);</P>
<P> int *pBigDataArray = new int[100000000];</P>
<P> ...</P>
<P>}</P>
<P>假如operator
new不能为100,000,000个整数分配空间，noMoreMemory将会被调用，程序发出一条出错信息后终止。这就比简单地让系统内核产生错误信息来结束程序要好。(顺便考虑一下，假如cerr在写错误信息的过程中要动态分配内存，那将会发生什么...)</P>
<P>operator
new不能满足内存分配请求时，new-handler函数不只调用一次，而是不断重复，直至找到足够的内存。实现重复调用的代码在条款8里可以看到，这里我用描述性的的语言来说明：一个设计得好的new-handler函数必须实现下面功能中的一种。<BR>
·产生更多的可用内存。这将使operator
new下一次分配内存的尝试有可能获得成功。实施这一策略的一个方法是：在程序启动时分配一个大的内存块，然后在第一次调用new-handler时释放。释放时伴随着一些对用户的警告信息，如内存数量太少，下次请求可能会失败，除非又有更多的可用空间。<BR>
·安装另一个不同的new-handler函数。如果当前的new-handler函数不能产生更多的可用内存，可能它会知道另一个new-handler函数可以提供更多的资源。这样的话，当前的new-handler可以安装另一个new-handler来取代它(通过调用set_new_handler)。下一次operator
new调用new-handler时，会使用最近安装的那个。(这一策略的另一个变通办法是让new-handler可以改变它自己的运行行为，那么下次调用时，它将做不同的事。方法是使new-handler可以修改那些影响它自身行为的静态或全局数据。)<BR>
·卸除new-handler。也就是传递空指针给set_new_handler。没有安装new-handler，operator
new分配内存不成功时就会抛出一个标准的std::bad_alloc类型的异常。<BR>
·抛出std::bad_alloc或从std::bad_alloc继承的其他类型的异常。这样的异常不会被operator
new捕捉，所以它们会被送到最初进行内存请求的地方。(抛出别的不同类型的异常会违反operator
new异常规范。规范中的缺省行为是调用abort，所以new-handler要抛出一个异常时，一定要确信它是从std::bad_alloc继承来的。想更多地了解异常规范，参见条款M14。)<BR>
·没有返回。典型做法是调用abort或exit。abort/exit可以在标准C库中找到(还有标准C++库，参见条款49)。</P>
<P>上面的选择给了你实现new-handler函数极大的灵活性。</P>
<P>处理内存分配失败的情况时采取什么方法，取决于要分配的对象的类：<BR>class X {<BR>public:<BR> static void
outOfMemory();</P>
<P> ...</P>
<P>};</P>
<P>class Y {<BR>public:<BR> static void outOfMemory();</P>
<P> ...</P>
<P>};</P>
<P>X* p1 = new X; // 若分配成功，调用X::outOfMemory</P>
<P>Y* p2 = new Y; // 若分配不成功，调用Y::outOfMemory</P>
<P>C++不支持专门针对于类的new-handler函数，而且也不需要。你可以自己来实现它，只要在每个类中提供自己版本的set_new_handler和operator
new。类的set_new_handler可以为类指定new-handler(就象标准的set_new_handler指定全局new-handler一样)。类的operator
new则保证为类的对象分配内存时用类的new-handler取代全局new-handler。</P>
<P>假设处理类X内存分配失败的情况。因为operator
new对类型X的对象分配内存失败时，每次都必须调用出错处理函数，所以要在类里声明一个new_handler类型的静态成员。那么类X看起来会象这样：<BR>
class X {<BR> public:<BR> static
new_handler set_new_handler(new_handler p);<BR>
static void * operator new(size_t size);</P>
<P> private:<BR> static
new_handler currentHandler;<BR> };</P>
<P>类的静态成员必须在类外定义。因为想借用静态对象的缺省初始化值0，所以定义X::currentHandler时没有去初始化。<BR>new_handler
X::currentHandler; //
缺省设置currentHandler为0(即null)</P>
<P>类X中的set_new_handler函数会保存传给它的任何指针，并返回在调用它之前所保存的任何指针。这正是标准版本的set_new_handler所做的：<BR>new_handler
X::set_new_handler(new_handler p)<BR>{<BR> new_handler oldHandler =
currentHandler;<BR> currentHandler = p;<BR> return
oldHandler;<BR>}</P>
<P>最后看看X的operator new所做的：<BR>1.
调用标准set_new_handler函数，输入参数为X的出错处理函数。这使得X的new-handler函数成为全局new-handler函数。注意下面的代码中，用了"::"符号显式地引用std空间(标准set_new_handler函数就存在于std空间)。</P>
<P>2. 调用全局operator new分配内存。如果第一次分配失败，全局operator
new会调用X的new-handler，因为它刚刚(见1.)被安装成为全局new-handler。如果全局operator
new最终未能分配到内存，它抛出std::bad_alloc异常，X的operator new会捕捉到它。X的operator
new然后恢复最初被取代的全局new-handler函数，最后以抛出异常返回。</P>
<P>3. 假设全局operator new为类型X的对象分配内存成功，, X的operator
new会再次调用标准set_new_handler来恢复最初的全局出错处理函数。最后返回分配成功的内存的指针。</P>
<P>C++是这么做的：<BR>void * X::operator new(size_t size)<BR>{<BR> new_handler
globalHandler
=
// 安装X的new_handler<BR>
std::set_new_handler(currentHandler); </P>
<P> void *memory;</P>
<P> try
{
// 尝试分配内存<BR> memory = ::operator
new(size);
<BR> }<BR> catch (std::bad_alloc&)
{
// 恢复旧的new_handler<BR>
std::set_new_handler(globalHandler);
<BR>
throw;
// 抛出异常<BR>
}
</P>
<P>
std::set_new_handler(globalHandler); //
恢复旧的new_handler<BR>
<BR> return memory;<BR>}</P>
<P>如果你对上面重复调用std::set_new_handler看不顺眼，可以参见条款M9来除去它们。</P>
<P>使用类X的内存分配处理功能时大致如下：<BR>void
noMoreMemory();
//
X的对象分配内存失败时调用的<BR>
//
new_handler函数的声明<BR>
// </P>
<P>X::set_new_handler(noMoreMemory);<BR>
//
把noMoreMemory设置为X的<BR>
// new-handling函数</P>
<P>X *px1 = new
X;
//
如内存分配失败，<BR>
// 调用noMoreMemory</P>
<P>string *ps = new
string;
//
如内存分配失败，<BR>
//
调用全局new-handling函数<BR>
// </P>
<P>X::set_new_handler(0);
//
设X的new-handling函数为空<BR>
// </P>
<P>X *px2 = new
X;
//
如内存分配失败，立即抛出异常<BR>
//
(类X没有new-handling函数)<BR>
//</P>
<P>你会注意到，处理以上类似情况，如果不考虑类的话，实现代码是一样的，这就很自然地想到在别的地方也能重用它们。正如条款41所说明的，继承和模板可以用来设计可重用代码。在这里，我们把两种方法结合起来使用，从而满足了你的要求。</P>
<P>你只要创建一个“混合风格”(mixin-style)的基类，这种基类允许子类继承它某一特定的功能——这里指的是建立一个类的new-handler的功能。之所以设计一个基类，是为了让所有的子类可以继承set_new_handler和operator
new功能，而设计模板是为了使每个子类有不同的currentHandler数据成员。这听起来很复杂，不过你会看到代码其实很熟悉。区别只不过是它现在可以被任何类重用了。<BR>template<class
T> // 提供类set_new_handler支持的<BR>class NewHandlerSupport
{ //
“混合风格”的基类<BR>public: </P>
<P> static new_handler set_new_handler(new_handler p);<BR> static
void * operator new(size_t size);</P>
<P>private:<BR> static new_handler currentHandler;<BR>};</P>
<P>template<class T><BR>new_handler
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -