zh-cnGoodspeed Rss10Tue, 07 Jul 2009 02:10:38 GMTTue, 01 May 2007 14:54:13 GMThttp://blog.ednchina.com/blog/levension/24634/message.aspx<span class="vcer">1、什么是const? <p>常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。（当然，我们可以偷梁换柱进行更新：） <p> <p>2、为什么引入const？ <p>　 const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。 <p> <p>3、cons有什么主要的作用？ <p>（1）可以定义const常量，具有不可变性。 <p>例如： <p>const int Max="100"; <p>int Array[Max]; <p>（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。 <p>例如： <p>void f(const int i) { .........} <p>编译器就会知道i是一个常量，不允许修改； <p>（3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。 <p>同宏定义一样，可以做到不变则已，一变都变！如（1）中，如果想修改Max的内容，只需要：const int Max="you" want;即可！ <p>（4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。 <p>还是上面的例子，如果在函数体内修改了i，编译器就会报错； <p>例如： <p>void f(const int i) { i="10";//error! } <p>(5) 为函数重载提供了一个参考。 <p>class A <p>{ <p>...... <p>void f(int i) {......} //一个函数 <p>void f(int i) const {......} //上一个函数的重载 <p>...... <p>}; <p>(6) 可以节省空间，避免不必要的内存分配。 <p>例如： <p>#define PI 3.14159 //常量宏 <p>const doulbe Pi="3".14159; //此时并未将Pi放入ROM中 <p>...... <p>double i="Pi"; //此时为Pi分配内存，以后不再分配！ <p>double I="PI"; //编译期间进行宏替换，分配内存 <p>double j="Pi"; //没有内存分配 <p>double J="PI"; //再进行宏替换，又一次分配内存！ <p>const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过 <p> <p>程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。 <p>（7） 提高了效率。 <p>编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作， <p> <p>使得它的效率也很高。 <p> <p>3、如何使用const？ <p>（1）修饰一般常量 <p>　　 一般常量是指简单类型的常量。这种常量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。 <p>例如： <p>int const x="2";　　或　　const int x="2"; <p>（2）修饰常数组 <p>　　 定义或说明一个常数组可采用如下格式： <p>　　 int const a[5]={1, 2, 3, 4, 5};　 <p>const int a[5]={1, 2, 3, 4, 5}; <p>（3）修饰常对象 <p>　常对象是指对象常量，定义格式如下： <p>class A; <p>　　 const A a; <p>A const a; <p>　　 定义常对象时，同样要进行初始化，并且该对象不能再被更新，修饰符const可以放在类名后面，也可以放在类名前面。　 <p>（4）修饰常指针 <p>const int *A;&nbsp; &nbsp; //const/修饰指向的对象，A可变，A指向的对象不可变 <p>int const *A; 　 //const修饰指向的对象，A可变，A指向的对象不可变 <p>int *const A;&nbsp; &nbsp; //const修饰指针A， A不可变，A指向的对象可变 <p>const int *const A; //指针A和A指向的对象都不可变 <p>（5）修饰常引用 <p>　使用const修饰符也可以说明引用，被说明的引用为常引用，该引用所引用的对象不能被更新。其定义格式如下： <p>　　 const double &amp; v; <p>　 （6）修饰函数的常参数 <p>const修饰符也可以修饰函数的传递参数，格式如下： <p>void Fun(const int Var); <p>告诉编译器Var在函数体中的无法改变，从而防止了使用者的一些无意的或错误的修改。 <p>（7）修饰函数的返回值： <p>const修饰符也可以修饰函数的返回值，是返回值不可被改变，格式如下： <p>const int Fun1(); <p>const MyClass Fun2(); <p>（8）修饰类的成员函数： <p>const修饰符也可以修饰类的成员函数，格式如下： <p>class ClassName <p>{ <p>public: <p>　 　int Fun() const; <p>　 ..... <p>}； <p>这样，在调用函数Fun时就不能修改类里面的数据 <p>（9）在另一连接文件中引用const常量 <p>extern const int i; //正确的引用 <p>extern const int j="10"; //错误！常量不可以被再次赋值 <p>另外，还要注意，常量必须初始化！ <p>例如： <p>const int i="5"; <p> <p>4、几点值得讨论的地方： <p>（1）const究竟意味着什么？ <p>说了这么多，你认为const意味着什么？一种修饰符？接口抽象？一种新类型？ <p>也许都是，在Stroustup最初引入这个关键字时，只是为对象放入ROM做出了一种可能，对于const对象，C++既允许对其进行静态初始化，也允 <p> <p>许对他进行动态初始化。理想的const对象应该在其构造函数完成之前都是可写的，在析够函数执行开始后也都是可写的，换句话说，const对 <p> <p>象具有从构造函数完成到析够函数执行之前的不变性，如果违反了这条规则，结果都是未定义的！虽然我们把const放入ROM中，但这并不能够 <p> <p>保证const的任何形式的堕落，我们后面会给出具体的办法。无论const对象被放入ROM中，还是通过存储保护机制加以保护，都只能保证，对于 <p> <p>用户而言这个对象没有改变。 <p>（2）位元const V.S. 抽象const? <p>对于关键字const的解释有好几种方式，最常见的就是位元const 和 抽象const。下面我们看一个例子： <p>class A <p>{ <p>public: <p>...... <p>A f(const A&amp; a); <p>...... <p>}; <p>如果采用抽象const进行解释，那就是f函数不会去改变所引用对象的抽象值，如果采用位元const进行解释，那就成了f函数不会去改变所引用 <p> <p>对象的任何位元。 <p>我们可以看到位元解释正是c++对const问题的定义，const成员函数不被允许修改它所在对象的任何一个数据成员。 <p>为什么这样呢？因为使用位元const有2个好处： <p>最大的好处是可以很容易地检测到违反位元const规定的事件：编译器只用去寻找有没有对数据成员的赋值就可以了。另外，如果我们采用了位 <p> <p>元const，那么，对于一些比较简单的const对象，我们就可以把它安全的放入ROM中，对于一些程序而言，这无疑是一个很重要的优化方式。 <p>当然，位元const也有缺点，要不然，抽象const也就没有产生的必要了。 <p>首先，位元const的抽象性比抽象const的级别更低！实际上，大家都知道，一个库接口的抽象性级别越低，使用这个库就越困难。 <p>其次，使用位元const的库接口会暴露库的一些实现细节，而这往往会带来一些负面效应。所以，在库接口和程序实现细节上，我们都应该采用 <p> <p>抽象const。 <p>有时，我们可能希望对const做出一些其它的解释，那么，就要注意了，目前，大多数对const的解释都是类型不安全的，这里我们就不举例子 <p> <p>了，你可以自己考虑一下，总之，我们尽量避免对const的重新解释。 <p>（3）放在类内部的常量有什么限制？ <p>看看下面这个例子： <p>class A <p>{ <p>private: <p>const int c3 = 7; // ??? <p>static int c4 = 7; // ??? <p>static const float c5 = 7; // ??? <p>...... <p>}; <p>你认为上面的3句对吗？呵呵，都不对！使用这种类内部的初始化语法的时候，常量必须是被一个常量表达式初始化的整型或枚举类型，而且必 <p> <p>须是static和const形式。这显然是一个很严重的限制！ <p>那么，我们的标准委员会为什么做这样的规定呢？一般来说，类在一个头文件中被声明，而头文件被包含到许多互相调用的单元去。但是，为 <p> <p>了避免复杂的编译器规则，C++要求每一个对象只有一个单独的定义。如果C++允许在类内部定义一个和对象一样占据内存的实体的话，这种规 <p> <p>则就被破坏了。 <p> <p>（4）如何初始化类内部的常量？ <p>一种方法就是static 和 const 并用，在内部初始化，如上面的例子； <p>另一个很常见的方法就是初始化列表： <p>class A <p>{ <p>public: <p>A(int i="0"):test(i) {} <p>private: <p>const int test; <p>}； <p>还有一种方式就是在外部初始化，例如： <p>class A <p>{ <p>public: <p>A() {} <p>private: <p>static const int i; //注意必须是静态的！ <p>}； <p>const int A::i=3; <p>（5）常量与数组的组合有什么特殊吗？ <p>我们给出下面的代码： <p>const int size[3]={10,20,50}; <p>int array]; <p>有什么问题吗？对了，编译通不过！为什么呢？ <p>const可以用于集合，但编译器不能把一个集合存放在它的符号表里，所以必须分配内存。在这种情况下，const意味着“不能改变的一块存储 <p> <p>”。然而，其值在编译时不能被使用，因为编译器在编译时不需要知道存储的内容。自然，作为数组的大小就不行了：） <p> <p>（6）this指针是不是const类型的？ <p>this指针是一个很重要的概念，那该如何理解她呢？也许这个话题太大了，那我们缩小一些：this指针是个什么类型的？这要看具体情况：如 <p> <p>果在非const成员函数中，this指针只是一个类类型的；如果在const成员函数中，this指针是一个const类类型的；如果在volatile成员函数中 <p> <p>,this指针就是一个volatile类类型的。 <p>（7）const到底是不是一个重载的参考对象？ <p>先看一下下面的例子： <p>class A <p>{ <p>...... <p>void f(int i) {......} //一个函数 <p>void f(int i) const {......} //上一个函数的重载 <p>...... <p>}; <p>上面是重载是没有问题的了，那么下面的呢？ <p>class A <p>{ <p>...... <p>void f(int i) {......} //一个函数 <p>void f(const int i) {......} //？？？？？/ <p>...... <p>}; <p>这个是错误的，编译通不过。那么是不是说明内部参数的const不予重载呢？再看下面的例子： <p>class A <p>{ <p>...... <p>void f(int&amp; ) {......} //一个函数 <p>void f(const int&amp; ) {......}//？？？？？/ <p>...... <p>}; <p>这个程序是正确的，看来上面的结论是错误的。为什么会这样呢？这要涉及到接口的透明度问题。按值传递时，对用户而言，这是透明的，用 <p> <p>户不知道函数对形参做了什么手脚，在这种情况下进行重载是没有意义的，所以规定不能重载！当指针或引用被引入时，用户就会对函数的操 <p> <p>作有了一定的了解，不再是透明的了，这时重载是有意义的，所以规定可以重载。 <p>（8）什么情况下为const分配内存？ <p>以下是我想到的可能情况，当然，有的编译器进行了优化，可能不分配内存。 <p>A、作为非静态的类成员时； <p>B、用于集合时； <p>C、被取地址时； <p>D、在main函数体内部通过函数来获得值时； <p>E、const的 class或struct有用户定义的构造函数、析构函数或基类时；。 <p>F、当const的长度比计算机字长还长时； <p>G、参数中的const； <p>H、使用了extern时。 <p>不知道还有没有其他情况，欢迎高手指点：） <p> <p>（9）临时变量到底是不是常量？ <p>很多情况下，编译器必须建立临时对象。像其他任何对象一样，它们需要存储空间而且必须被构造和删除。区别是我们从来看不到编译器负责 <p> <p>决定它们的去留以及它们存在的细节。对于C++标准草案而言：临时对象自动地成为常量。因为我们通常接触不到临时对象，不能使用与之相关 <p> <p>的信息，所以告诉临时对象做一些改变有可能会出错。当然，这与编译器有关，例如：vc6、vc7都对此作了扩展，所以，用临时对象做左值， <p> <p>编译器并没有报错。 <p>（10）与static搭配会不会有问题？ <p>假设有一个类： <p>class A <p>{ <p>public: <p>...... <p>static void f() const { ......} <p>...... <p>}; <p>我们发现编译器会报错，因为在这种情况下static不能够与const共存！ <p>为什么呢？因为static没有this指针，但是const修饰this指针，所以... <p>（11）如何修改常量？ <p>有时候我们却不得不对类内的数据进行修改，但是我们的接口却被声明了const，那该怎么处理呢？我对这个问题的看法如下： <p>1）标准用法：mutable <p>class A <p>{ <p>public: <p>A(int i="0"):test(i) { } <p>void Setvalue(int i)const { test="i"; } <p>private: <p>mutable int test;//这里处理！ <p>}； <p>2）强制转换：const_cast <p>class A <p>{ <p>public: <p>A(int i="0"):test(i) { } <p>void Setvalue(int i)const <p>{ const_cast &lt;int&gt;(test)=i; }//这里处理！ <p>private: <p>int test; <p>}； <p>3）灵活的指针：int* <p>class A <p>{ <p>public: <p>A(int i="0"):test(i) { } <p>void Setvalue(int i)const <p>{ *test=i; } <p>private: <p>int* test; //这里处理！ <p>}； <p>4）未定义的处理 <p>class A <p>{ <p>public: <p>A(int i="0"):test(i) { } <p>void Setvalue(int i)const <p>{ int *p=(int*)&amp;test; *p=i; }//这里处理！ <p>private: <p>int test; <p>}； <p>注意，这里虽然说可以这样修改，但结果是未定义的，避免使用！ <p>5）内部处理：this指针 <p>class A <p>{ <p>public: <p>A(int i="0"):test(i) { } <p>void Setvalue(int i)const <p>{ ((A*)this)-&gt;test=i; }//这里处理！ <p>private: <p>int test; <p>}； <p>6）最另类的处理：空间布局 <p>class A <p>{ <p>public: <p>A(int i="0"):test(i),c('a') { } <p>private: <p>char c; <p>const int test; <p>}; <p>int main() <p>{ <p>A a(3); <p>A* pa=&amp;a; <p>char* p=(char*)pa; <p>int* pi=(int*)(p+4）；//利用边缘调整 <p>*pi=5; file://此处改变了test的值！ <p>return 0; <p>} <p>虽然我给出了6中方法，但是我只是想说明如何更改，但出了第一种用法之外，另外5种用法，我们并不提倡， <p>（12）最后我们来讨论一下常量对象的动态创建。 <p>既然编译器可以动态初始化常量，就自然可以动态创建，例如： <p>const int* pi="new" const int(10); <p>这里要注意2点： <p>1）const对象必须被初始化！所以(10)是不能够少的。 <p>2）new返回的指针必须是const类型的。 <p>那么我们可不可以动态创建一个数组呢？ <p>答案是否定的，因为new内置类型的数组，不能被初始化。</p></span>http://blog.ednchina.com/blog/levension/24634/message.aspx编程天地 软件开发Tue, 17 Apr 2007 14:38:38 GMThttp://blog.ednchina.com/blog/levension/22520/message.aspx曾经碰到过让你迷惑不解、类似于int * (* (*fp1) (int) ) [10];这样的变量声明吗？本文将由易到难，一步一步教会你如何理解这种复杂的C/C++声明。 <br><br>　　我们将从每天都能碰到的较简单的声明入手，然后逐步加入const修饰符和typedef，还有函数指针，最后介绍一个能够让你准确地理解任何C/C++声明的“右左法则”。 <br><br>　　需要强调一下的是，复杂的C/C++声明并不是好的编程风格；我这里仅仅是教你如何去理解这些声明。注意：为了保证能够在同一行上显示代码和相关注释，本文最好在至少1024x768分辨率的显示器上阅读。 <br>让我们从一个非常简单的例子开始，如下：<br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>int n;</pre></td></tr></tbody></table></center><br><br>这个应该被理解为“declare n as an int”（n是一个int型的变量）。接下去来看一下指针变量，如下： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>int *p;</pre></td></tr></tbody></table></center><br><br>这个应该被理解为“declare p as an int *”（p是一个int *型的变量），或者说p是一个指向一个int型变量的指针。我想在这里展开讨论一下：我觉得在声明一个指针（或引用）类型的变量时，最好将*（或&amp;）写在紧靠变量之前，而不是紧跟基本类型之后。这样可以避免一些理解上的误区，比如： <br>再来看一个指针的指针的例子： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>char **argv;</pre></td></tr></tbody></table></center><br><br>理论上，对于指针的级数没有限制，你可以定义一个浮点类型变量的指针的指针的指针的指针，再来看如下的声明： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>int RollNum[30][4]; <br>int (*p)[4]=RollNum; <br>int *q[5];</pre></td></tr></tbody></table></center>这里，p被声明为一个指向一个4元素（int类型）数组的指针，而q被声明为一个包含5个元素（int类型的指针）的数组。另外，我们还可以在同一个声明中混合实用*和&amp;，如下： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>int **p1; <br>// p1 is a pointer&nbsp;&nbsp;to a pointer&nbsp;&nbsp;to an int. <br>int *&amp;p2; <br>// p2 is a reference to a pointer&nbsp;&nbsp;to an int. <br>int &amp;*p3; <br>// ERROR: Pointer&nbsp;&nbsp;to a reference is illegal. <br>int &amp;&amp;p4;<br>// ERROR: Reference to a reference is illegal.</pre></td></tr></tbody></table></center><br><br>注：p1是一个int类型的指针的指针；p2是一个int类型的指针的引用；p3是一个int类型引用的指针（不合法！）；p4是一个int类型引用的引用（不合法！）。 <br><br>const修饰符 <br><br>当你想阻止一个变量被改变，可能会用到const关键字。在你给一个变量加上const修饰符的同时，通常需要对它进行初始化，因为以后的任何时候你将没有机会再去改变它。例如： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>const int n="5"; <br>int const m="10";</pre></td></tr></tbody></table></center><br><br>上述两个变量n和m其实是同一种类型的——都是const int（整形恒量）。因为C++标准规定，const关键字放在类型或变量名之前等价的。我个人更喜欢第一种声明方式，因为它更突出了const修饰符的作用。当const与指针一起使用时，容易让人感到迷惑。例如，我们来看一下下面的p和q的声明： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>const int *p; <br>int const *q;</pre></td></tr></tbody></table></center><br><br>他们当中哪一个代表const int类型的指针（const直接修饰int），哪一个代表int类型的const指针（const直接修饰指针）？实际上，p和q都被声明为const int类型的指针。而int类型的const指针应该这样声明： <br><br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>int * const r= &amp;n;<br>// n has been declared as an int</pre></td></tr></tbody></table></center><br><br>这里，p和q都是指向const int类型的指针，也就是说，你在以后的程序里不能改变*p的值。而r是一个const指针，它在声明的时候被初始化指向变量n（即r=&amp;n;）之后，r的值将不再允许被改变（但*r的值可以改变）。 <br><br>组合上述两种const修饰的情况，我们来声明一个指向const int类型的const指针，如下： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>const int * const p=&amp;n <br>// n has been declared as const int</pre></td></tr></tbody></table></center><br><br>下面给出的一些关于const的声明，将帮助你彻底理清const的用法。不过请注意，下面的一些声明是不能被编译通过的，因为他们需要在声明的同时进行初始化。为了简洁起见，我忽略了初始化部分；因为加入初始化代码的话，下面每个声明都将增加两行代码。 <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>char ** p1; <br>//&nbsp;&nbsp;&nbsp;&nbsp;pointer to&nbsp;&nbsp;&nbsp;&nbsp;pointer to&nbsp;&nbsp;&nbsp;&nbsp;char <br>const char **p2;<br>//&nbsp;&nbsp;&nbsp;&nbsp;pointer to&nbsp;&nbsp;&nbsp;&nbsp;pointer to const char <br>char * const * p3;<br>//&nbsp;&nbsp;&nbsp;&nbsp;pointer to const pointer to&nbsp;&nbsp;&nbsp;&nbsp;char <br>const char * const * p4;<br>//&nbsp;&nbsp;&nbsp;&nbsp;pointer to const pointer to const char <br>char ** const p5;<br>// const pointer to&nbsp;&nbsp;&nbsp;&nbsp;pointer to&nbsp;&nbsp;&nbsp;&nbsp;char <br>const char ** const p6;<br>// const pointer to&nbsp;&nbsp;&nbsp;&nbsp;pointer to const char <br>char * const * const p7;<br>// const pointer to const pointer to&nbsp;&nbsp;&nbsp;&nbsp;char <br>const char * const * const p8;<br>// const pointer to const pointer to const char</pre></td></tr></tbody></table></center><br><br>注：p1是指向char类型的指针的指针；p2是指向const char类型的指针的指针；p3是指向char类型的const指针；p4是指向const char类型的const指针；p5是指向char类型的指针的const指针；p6是指向const char类型的指针的const指针；p7是指向char类型const指针的const指针；p8是指向const char类型的const指针的const指针。 <br><br>typedef的妙用 <br><br>typedef给你一种方式来克服“*只适合于变量而不适合于类型”的弊端。你可以如下使用typedef： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>typedef char * PCHAR; <br>PCHAR p,q;</pre></td></tr></tbody></table></center><br><br>这里的p和q都被声明为指针。（如果不使用typedef，q将被声明为一个char变量，这跟我们的第一眼感觉不太一致！）下面有一些使用typedef的声明，并且给出了解释： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>typedef char * a;<br>// a is a pointer to a char <br><br>typedef a b();<br>// b is a function that returns <br>// a pointer to a char <br><br>typedef b *c;<br>// c is a pointer to a function <br>// that returns a pointer to a char <br><br>typedef c d();<br>// d is a function returning <br>// a pointer to a function <br>// that returns a pointer to a char <br><br>typedef d *e;<br>// e is a pointer to a function <br>// returning a pointer to a <br>// function that returns a <br>// pointer to a char <br><br>e var[10];<br>// var is an array of 10 pointers to <br>// functions returning pointers to <br>// functions returning pointers to chars.</pre></td></tr></tbody></table></center><br><br>typedef经常用在一个结构声明之前，如下。这样，当创建结构变量的时候，允许你不使用关键字struct（在C中，创建结构变量时要求使用struct关键字，如struct tagPOINT a；而在C++中，struct可以忽略，如tagPOINT b）。 <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>typedef struct tagPOINT <br>{ <br>&nbsp;&nbsp;int x; <br>&nbsp;&nbsp;int y; <br>}POINT; <br><br>POINT p; /* Valid C code */</pre></td></tr></tbody></table></center>函数指针<br><br>函数指针可能是最容易引起理解上的困惑的声明。函数指针在DOS时代写TSR程序时用得最多；在Win32和X-Windows时代，他们被用在需要回调函数的场合。当然，还有其它很多地方需要用到函数指针：虚函数表，STL中的一些模板，Win NT/2K/XP系统服务等。让我们来看一个函数指针的简单例子：<br><br><br><br><br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>int (*p)(char);</pre></td></tr></tbody></table></center><br><br>这里p被声明为一个函数指针，这个函数带一个char类型的参数，并且有一个int类型的返回值。另外，带有两个float类型参数、返回值是char类型的指针的指针的函数指针可以声明如下： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>char ** (*p)(float, float);</pre></td></tr></tbody></table></center><br><br>那么，带两个char类型的const指针参数、无返回值的函数指针又该如何声明呢？参考如下： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>void * (*a[5])(char * const, char * const);</pre></td></tr></tbody></table></center><br><br>“右左法则”是一个简单的法则，但能让你准确理解所有的声明。这个法则运用如下：从最内部的括号开始阅读声明，向右看，然后向左看。当你碰到一个括号时就调转阅读的方向。括号内的所有内容都分析完毕就跳出括号的范围。这样继续，直到整个声明都被分析完毕。 <br><br>对上述“右左法则”做一个小小的修正：当你第一次开始阅读声明的时候，你必须从变量名开始，而不是从最内部的括号。 <br><br>下面结合例子来演示一下“右左法则”的使用。 <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>int * (* (*fp1) (int) ) [10];</pre></td></tr></tbody></table></center><br><br>阅读步骤： <br><br>1. 从变量名开始——fp1 <br><br>2. 往右看，什么也没有，碰到了)，因此往左看，碰到一个*——一个指针 <br><br>3. 跳出括号，碰到了(int)——一个带一个int参数的函数 <br><br>4. 向左看，发现一个*——（函数）返回一个指针 <br><br>5. 跳出括号，向右看，碰到[10]——一个10元素的数组 <br><br>6. 向左看，发现一个*——指针 <br><br>7. 向左看，发现int——int类型 <br><br>总结：fp1被声明成为一个函数的指针,该函数返回指向指针数组的指针. <br><br>再来看一个例子： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>int *( *( *arr[5])())();</pre></td></tr></tbody></table></center><br><br>阅读步骤： <br><br>1. 从变量名开始——arr <br><br>2. 往右看，发现是一个数组——一个5元素的数组 <br><br>3. 向左看，发现一个*——指针 <br><br>4. 跳出括号，向右看，发现()——不带参数的函数 <br><br>5. 向左看，碰到*——（函数）返回一个指针 <br><br>6. 跳出括号，向右发现()——不带参数的函数 <br><br>7. 向左，发现*——（函数）返回一个指针 <br><br>8. 继续向左，发现int——int类型 <br><br>还有更多的例子： <br><br> <center><ccid_NOBR></ccid_NOBR> <table cellSpacing="0" borderColorDark="#ffffff" cellPadding="2" width="400" align="center" borderColorLight="#000000" border="1"> <tbody> <tr> <td class="code" style="FONT-SIZE: 9pt" bgColor="#e6e6e6"><pre><ccid_CODE></ccid_CODE>float ( * ( *b()) [] )();<br>// b is a function that returns a <br>// pointer to an array of pointers <br>// to functions returning floats. <br>void * ( *c) ( char, int (*)());<br>// c is a pointer to a function that takes <br>// two parameters: <br>// a char and a pointer to a <br>// function that takes no <br>// parameters and returns <br>// an int <br>// and returns a pointer to void. <br>void ** (*d) (int &amp;, <br>char **(*)(char *, char **));<br>// d is a pointer to a function that takes <br>// two parameters: <br>// a reference to an int and a pointer <br>// to a function that takes two parameters: <br>// a pointer to a char and a pointer <br>// to a pointer to a char <br>// and returns a pointer to a pointer <br>// to a char <br>// and returns a pointer to a pointer to void <br>float ( * ( * e[10]) <br>&nbsp;&nbsp;(int &amp;) ) [5];<br>// e is an array of 10 pointers to <br>// functions that take a single <br>// reference to an int as an argument <br>// and return pointers to <br>// an array of 5 floats.</pre></td></tr></tbody></table></center>http://blog.ednchina.com/blog/levension/22520/message.aspx编程天地 软件开发Tue, 17 Apr 2007 14:32:57 GMThttp://blog.ednchina.com/blog/levension/22519/message.aspx<p>诠释C指针操作</p> <p>第一章。指针的概念 </p> <p>指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。 要搞清一个指针需要搞清指</p> <p>针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针</p> <p>本身所占据的内存区。让我们分别说明。 先声明几个指针放着做例子： 例一： (1)int *ptr; (2)char </p> <p>*ptr; (3)int **ptr; (4)int (*ptr)[3]; (5)int *(*ptr)[4]; 如果看不懂后几个例子的话，请参阅我</p> <p>前段时间贴出的文?lt;&lt;如何理解c和c ++的复杂类型声明&gt;&gt;。 1。 指针的类型。 从语法的角度看，你</p> <p>只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型</p> <p>。让我们看看例一中各个指针的类型： (1)int *ptr; //指针的类型是int * (2)char *ptr; //指针的</p> <p>类型是char * (3)int **ptr; //指针的类型是 int ** (4)int (*ptr)[3]; //指针的类型是 int(*)[3] </p> <p>(5)int *(*ptr)[4]; //指针的类型是 int *(*)[4] 怎么样？找出指针的类型的方法是不是很简单？ 2</p> <p>。指针所指向的类型。 当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将</p> <p>把那片内存区里的内容当做什么来看待。 从语法上看，你只须把指针声明语句中的指针名字和名字左边</p> <p>的指针声明符*去掉，剩下的就是指针所指向的类型。例如： (1)int *ptr; //指针所指向的类型是int </p> <p>(2)char *ptr; //指针所指向的的类型是char (3)int **ptr; //指针所指向的的类型是 int * (4)int </p> <p>(*ptr)[3]; //指针所指向的的类型是 int()[3] (5)int *(*ptr)[4]; //指针所指向的的类型是 int *</p> <p>()[4] 在指针的算术运算中，指针所指向的类型有很大的作用。 指针的类型(即指针本身的类型)和指针</p> <p>所指向的类型是两个概念。当你对C越来越熟悉时，你会发现，把与指针搅和在一起的"类型"这个概念分</p> <p>成"指针的类型"和"指针所指向的类型"两个概念，是精通指针的关键点之一。我看了不少书，发现有些</p> <p>写得差的书中，就把指针的这两个概念搅在一起了，所以看起书来前后矛盾，越看越糊涂。 3。 指针的</p> <p>值，或者叫指针所指向的内存区或地址。 指针的值是指针本身存储的数值，这个值将被编译器当作一个</p> <p>地址，而不是一个一般的数值。在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序</p> <p>里内存地址全都是32位长。 指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为</p> <p>sizeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相当于说该指针指向了</p> <p>以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内</p> <p>存区域的首地址。 指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中，指针所</p> <p>指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的</p> <p>。 以后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指向的类型是什么？该指针指向</p> <p>了哪里？ 4。 指针本身所占据的内存区。 指针本身占了多大的内存？你只要用函数sizeof(指针的类型</p> <p>)测一下就知道了。在32位平台里，指针本身占据了4个字节的长度。 指针本身占据的内存这个概念在判</p> <p>断一个指针表达式是否是左值时很有用。</p> <p><br>第二章。指针的算术运算</p> <p>指针可以加上或减去一个整数。指针的这种运算的意义和通常的数值的加减运算的意义是不一样的。例</p> <p>如： 例二： 1。 char a[20]; 2。 int *ptr=a; ... ... 3。 ptr++; 在上例中，指针ptr的类型是</p> <p>int*,它指向的类型是int，它被初始化为指向整形变量a。接下来的第3句中，指针ptr被加了1，编译器</p> <p>是这样处理的：它把指针ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由于地址是用字节</p> <p>做单位的，故ptr所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。 由于char类型的长</p> <p>度是一个字节，所以，原来ptr是指向数组a的第 0号单元开始的四个字节，此时指向了数组a中从第4号</p> <p>单元开始的四个字节。 我们可以用一个指针和一个循环来遍历一个数组，看例子： 例三： int array</p> <p>[20]; int *ptr=array; ... //此处略去为整型数组赋值的代码。 ... for(i=0;i&lt;20;i++) { (*ptr)</p> <p>++; ptr++； } 这个例子将整型数组中各个单元的值加1。由于每次循环都将指针 ptr加1，所以每次循</p> <p>环都能访问数组的下一个单元。再看例子： 例四： 1。 char a[20]; 2。 int *ptr=a; ... ... 3。 </p> <p>ptr+=5; 在这个例子中，ptr被加上了5，编译器是这样处理的：将指针ptr 的值加上5乘sizeof(int)，</p> <p>在32位程序中就是加上了5乘4=20。由于地址的单位是字节，故现在的ptr所指向的地址比起加5后的ptr</p> <p>所指向的地址来说，向高地址方向移动了20个字节。在这个例子中，没加5前的ptr指向数组a的第0号单</p> <p>元开始的四个字节，加5后，ptr已经指向了数组a的合法范围之外了。虽然这种情况在应用上会出问题，</p> <p>但在语法上却是可以的。这也体现出了指针的灵活性。 如果上例中，ptr是被减去5，那么处理过程大同</p> <p>小异，只不过ptr 的值是被减去5乘sizeof(int)，新的ptr指向的地址将比原来的ptr所指向的地址向低</p> <p>地址方向移动了20个字节。 总结一下，一个指针ptrold加上一个整数n后，结果是一个新的指针ptrnew</p> <p>，ptrnew的类型和ptrold的类型相同，ptrnew所指向的类型和ptrold所指向的类型也相同。ptrnew的值</p> <p>将比ptrold的值增加了n乘sizeof(ptrold所指向的类型)个字节。就是说，ptrnew所指向的内存区将比</p> <p>ptrold所指向的内存区向高地址方向移动了n乘sizeof (ptrold所指向的类型)个字节。 a一个指针</p> <p>ptrold减去一个整数n后，结果是一个新的指针ptrnew， ptrnew的类型和ptrold的类型相同，ptrnew所</p> <p>指向的类型和ptrold所指向的类型也相同。 ptrnew的值将比ptrold的值减少了n乘sizeof(ptrold所指向</p> <p>的类型)个字节，就是说， ptrnew所指向的内存区将比ptrold所指向的内存区向低地址方向移动了n乘</p> <p>sizeof(ptrold 所指向的类型)个字节。</p> <p><br>第三章。</p> <p>运算?amp;和* 这里&amp;是取地址运算符，*是...书上叫做"间接运算符"。 &amp;a的运算结果是一个指针，指针</p> <p>的类型是a的类型加个*，指针所指向的类型是a的类型，指针所指向的地址嘛，那就是a的地址。 *p的运</p> <p>算结果就五花八门了。总之*p的结果是p所指向的东西，这个东西有这些特点：它的类型是p指向的类型</p> <p>，它所占用的地址是p所指向的地址。 例五： int a="12"; int b; int *p; int **ptr; p=&amp;a;//&amp;a的结</p> <p>果是一个指针，类型是int*，指向的类型是int，指向的地址是a的地址。 *p=24;//*p的结果，在这里它</p> <p>的类型是int，它所占用的地址是p所指向的地址，显然，*p就是变量a。 ptr=&amp;p;//&amp;p的结果是个指针，</p> <p>该指针的类型是p的类型加个*，在这里是int**。该指针所指向的类型是p的类型，这里是int*。该指针</p> <p>所指向的地址就是指针p自己的地址。 *ptr=&amp;b;//*ptr是个指针，&amp;b的结果也是个指针，且这两个指针</p> <p>的类型和所指向的类型是一样的，所以用&amp;b来给*ptr赋值就是毫无问题的了。 **ptr=34;//*ptr的结果</p> <p>是ptr所指向的东西，在这里是一个指针，对这个指针再做一次*运算，结果就是一个int类型的变量。</p> <p>&nbsp;<br>第四章。</p> <p>指针表达式。 一个表达式的最后结果如果是一个指针，那么这个表达式就叫指针表达式。 下面是一些</p> <p>指针表达式的例子： 例六： int a,b; int array[10]; int *pa; pa=&amp;a;//&amp;a是一个指针表达式。 int </p> <p>**ptr=&amp;pa;//&amp;pa也是一个指针表达式。 *ptr=&amp;b;//*ptr和&amp;b都是指针表达式。 pa="array"; pa++;//这</p> <p>也是指针表达式。 例七： char *arr[20]; char **parr=arr;//如果把arr看作指针的话，arr也是指针</p> <p>表达式 char *str; str=*parr;//*parr是指针表达式 str=*(parr+1);//*(parr+1)是指针表达式 </p> <p>str=*(parr+2);//*(parr+2)是指针表达式 由于指针表达式的结果是一个指针，所以指针表达式也具有</p> <p>指针所具有的四个要素：指针的类型，指针所指向的类型，指针指向的内存区，指针自身占据的内存。 </p> <p>好了，当一个指针表达式的结果指针已经明确地具有了指针自身占据的内存的话，这个指针表达式就是</p> <p>一个左值，否则就不是一个左值。 在例七中，&amp;a不是一个左值，因为它还没有占据明确的内存。*ptr </p> <p>是一个左值，因为*ptr这个指针已经占据了内存，其实*ptr就是指针pa，既然pa已经在内存中有了自己</p> <p>的位置，那么*ptr当然也有了自己的位置。<br>&nbsp;</p> <p>第五章。</p> <p>数组和指针的关系 <br>如果对声明数组的语句不太明白的话，请参阅我前段时间贴出的文?lt;&lt;如何理解c和c++的复杂类型声明</p> <p>&gt;&gt;。 数组的数组名其实可以看作一个指针。看下例： 例八： int array[10]=</p> <p>{0,1,2,3,4,5,6,7,8,9},value; ... ... value="array"[0];//也可写成：value=*array; value="array"</p> <p>[3];//也可写成：value=*(array+3); value="array"[4];//也可写成：value=*(array+4); 上例中，一般</p> <p>而言数组名array代表数组本身，类型是int [10]，但如果把array看做指针的话，它指向数组的第0个单</p> <p>元，类型是int *，所指向的类型是数组单元的类型即int。因此*array等于0就一点也不奇怪了。同理，</p> <p>array+3是一个指向数组第3个单元的指针，所以*(array+3)等于3。其它依此类推。 例九： char *str</p> <p>[3]={ "Hello,this is a sample!","Hi,good morning.","Hello world" }; char s[80]； strcpy</p> <p>(s,str[0]);//也可写成strcpy(s,*str); strcpy(s,str[1]);//也可写成strcpy(s,*(str+1)); strcpy</p> <p>(s,str[2]);//也可写成strcpy(s,*(str+2)); 上例中，str是一个三单元的数组，该数组的每个单元都</p> <p>是一个指针，这些指针各指向一个字符串。把指针数组名str当作一个指针的话，它指向数组的第0 号单</p> <p>元，它的类型是char**，它指向的类型是char *。 *str也是一个指针，它的类型是char*，它所指向的</p> <p>类型是char，它指向的地址是字符串"Hello,this is a sample!"的第一个字符的地址，即'H'的地址。 </p> <p>str+1也是一个指针，它指向数组的第1号单元，它的类型是 char**，它指向的类型是char *。 *</p> <p>(str+1)也是一个指针，它的类型是char*，它所指向的类型是 char，它指向"Hi,good morning."的第一</p> <p>个字符'H'，等等。 下面总结一下数组的数组名的问题。声明了一个数组TYPE array [n]，则数组名称</p> <p>array就有了两重含义：第一，它代表整个数组，它的类型是TYPE [n]；第二，它是一个指针，该指针的</p> <p>类型是TYPE*，该指针指向的类型是TYPE，也就是数组单元的类型，该指针指向的内存区就是数组第0号</p> <p>单元，该指针自己占有单独的内存区，注意它和数组第0号单元占据的内存区是不同的。该指针的值是不</p> <p>能修改的，即类似array++的表达式是错误的。 在不同的表达式中数组名array可以扮演不同的角色。 </p> <p>在表达式sizeof(array)中，数组名array代表数组本身，故这时 sizeof函数测出的是整个数组的大小。 </p> <p>在表达式*array中，array扮演的是指针，因此这个表达式的结果就是数组第0号单元的值。sizeof</p> <p>(*array)测出的是数组单元的大小。 表达式array+n（其中n=0，1，2，....。）中，array扮演的是指</p> <p>针，故array+n的结果是一个指针，它的类型是TYPE*，它指向的类型是TYPE，它指向数组第n号单元。故</p> <p>sizeof(array+n)测出的是指针类型的大小。 例十： int array[10]; int (*ptr)[10]; ptr=&amp;array; </p> <p>上例中ptr是一个指针，它的类型是int (*)[10]，他指向的类型是 int [10]，我们用整个数组的首地址</p> <p>来初始化它。在语句ptr=&amp;array中，array代表数组本身。 本节中提到了函数sizeof()，那么我来问一</p> <p>问，sizeof(指针名称) 测出的究竟是指针自身类型的大小呢还是指针所指向的类型的大小？答案是前者</p> <p>。例如： int (*ptr)[10]; 则在32位程序中，有： sizeof(int(*)[10])==4 sizeof(int [10])==40 </p> <p>sizeof(ptr)==4 实际上，sizeof(对象)测出的都是对象自身的类型的大小，而不是别的什么类型的大小</p> <p>。 </p> <p><br>第六章。</p> <p>指针和结构类型的关系<br>&nbsp;可以声明一个指向结构类型对象的指针。 例十一： struct MyStruct { int a; int b; int c; } </p> <p>MyStruct ss={20,30,40};//声明了结构对象ss，并把ss的三个成员初始化为20，30和40。 MyStruct </p> <p>*ptr=&amp;ss;//声明了一个指向结构对象ss的指针。它的类型是MyStruct*,它指向的类型是MyStruct。 int </p> <p>*pstr=(int*)&amp;ss;//声明了一个指向结构对象ss的指针。但是它的类型和它指向的类型和ptr是不同的。 </p> <p>请问怎样通过指针ptr来访问ss的三个成员变量？ 答案： ptr-&gt;a; ptr-&gt;b; ptr-&gt;c; 又请问怎样通过指</p> <p>针pstr来访问ss的三个成员变量？ 答案： *pstr；//访问了ss的成员a。 *(pstr+1);//访问了ss的成员</p> <p>b。 *(pstr+2)//访问了ss的成员c。 呵呵，虽然我在我的MSVC++6.0上调式过上述代码，但是要知道，</p> <p>这样使用pstr来访问结构成员是不正规的，为了说明为什么不正规，让我们看看怎样通过指针来访问数</p> <p>组的各个单元：<br>例十二： <br>int array[3]={35,56,37}; <br>int *pa=array; <br>通过指针pa访问数组array的三个单元的方法是： </p> <p>*pa;//访问了第0号单元 <br>*(pa+1);//访问了第1号单元 <br>*(pa+2);//访问了第2号单元 <br>从格式上看倒是与通过指针访问结构成员的不正规方法的格式一<br>样。 <br>所有的C/C++编译器在排列数组的单元时，总是把各个数组单元存<br>放在连续的存储区里，单元和单元之间没有空隙。但在存放结构对象的各个成员时，在某<br>种编译环境下，可能会需要字对齐或双字对齐或者是别的什么对齐，需要在相邻两个成员<br>之间加若干"填充字节"，这就导致各个成员之间可能会有若干个字节的空隙。 </p> <p><br>所以，在例十二中，即使*pstr访问到了结构对象ss的第一个成员<br>变量a，也不能保证*(pstr+1)就一定能访问到结构成员b。因为成员a和成员b之间可能会有<br>若干填充字节，说不定*(pstr+1)就正好访问到了这些填充字节呢。这也证明了指针的灵活<br>性。要是你的目的就是想看看各个结构成员之间到底有没有填充字节，嘿，这倒是个不错<br>的方法。 <br>通过指针访问结构成员的正确方法应该是象例十二中使用指针ptr<br>的方法。 </p> <p><br>第七章。指针和函数的关系 </p> <p>可以把一个指针声明成为一个指向函数的指针。 <br>int fun1(char*,int); <br>int (*pfun1)(char*,int); <br>pfun1=fun1; <br>.... <br>.... <br>int a=(*pfun1)("abcdefg",7);//通过函数指针饔煤? </p> <p>可以把指针作为函数的形参。在函数调用语句中，可以用指针表达<br>式来作为 实参。 <br>例十三： <br>int fun(char*); <br>int a; <br>char str[]="abcdefghijklmn"; <br>a=fun(str); <br>... <br>... <br>int fun(char*s) <br>{ <br>int num="0"; <br>for(int i="0";i <br>{ <br>num+=*s;s++; <br>} <br>return num; <br>} <br>这个例子中的函数fun统计一个字符串中各个字符的ASCII码值之<br>和。前面说了，数组的名字也是一个指针。在函数调用中，当把str作为实参传递给形参s<br>后，实际是把str的值传递给了s，s所指向的地址就和str所指向的地址一致，但是str和s<br>各自占用各自的存储空间。在函数体内对s进行自加1运算，并不意味着同时对str进行了自<br>加1运算。 </p> <p><br>第八章。指针类型转换 </p> <p>当我们初始化一个指针或给一个指针赋值时，赋值号的左边是一个<br>指针，赋值号的右边是一个指针表达式。在我们前面所举的例子中，绝大多数情况下，指<br>针的类型和指针表达式的类型是一样的，指针所指向的类型和指针表达式所指向的类型是<br>一样的。 </p> <p>例十四： </p> <p>1。 float f="12".3; <br>2。 float *fptr=&amp;f; <br>3。 int *p; <br>在上面的例子中，假如我们想让指针p指向实数f，应该怎么搞？是<br>用下面的 语句吗？ <br>p=&amp;f; <br>不对。因为指针p的类型是int*，它指向的类型是int。表达式&amp;f的<br>结果是一个指针，指针的类型是float*,它指向的类型是float。两者不一致，直接赋值的<br>方法是不行的。至少在我的MSVC++6.0上，对指针的赋值语句要求赋值号两边的类型一致，<br>所指向的类型也一致，其它的编译器上我没试过，大家可以试试。为了实现我们的目的，<br>需要进行"强制类型转换"： <br>p=(int*)&amp;f; <br>如果有一个指针p，我们需要把它的类型和所指向的类型改为TYEP*<br>和TYPE，那么语法格式是： <br>(TYPE*)p； <br>这样强制类型转换的结果是一个新指针，该新指针的类型是<br>TYPE*，它指向的类型是TYPE，它指向的地址就是原指针指向的地址。而原来的指针p的一<br>切属性都没有被修改。 <br>一个函数如果使用了指针作为形参，那么在函数调用语句的实参和<br>形参的结合过程中，也会发生指针类型的转换。 <br>例十五： <br>void fun(char*); <br>int a="125",b; <br>fun((char*)&amp;a); <br>... <br>... <br>void fun(char*s) <br>{ <br>char c; <br>c=*(s+3);*(s+3)=*(s+0);*(s+0)=c; <br>c=*(s+2);*(s+2)=*(s+1);*(s+1)=c; <br>} <br>} <br>注意这是一个32位程序，故int类型占了四个字节，char类型占一<br>个字节。函数fun的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗？在函数调<br>用语句中，实参&amp;a的结果是一个指针，它的类型是int *，它指向的类型是int。形参这个<br>指针的类型是char*，它指向的类型是char。这样，在实参和形参的结合过程中，我们必须<br>进行一次从int*类型到char*类型的转换。结合这个例子，我们可以这样来想象编译器进行<br>转换的过程：编译器先构造一个临时指针 char*temp，然后执行temp=(char*)&amp;a，最后再<br>把temp的值传递给s。所以最后的结果是：s的类型是char*,它指向的类型是char，它指向<br>的地址就是a的首地址。 </p> <p>我们已经知道，指针的值就是指针指向的地址，在32位程序中，指<br>针的值其实是一个32位整数。那可不可以把一个整数当作指针的值直接赋给指针呢？就象<br>下面的语句： </p> <p>unsigned int a; </p> <p>TYPE *ptr;//TYPE是int，char或结构类型等等类型。 </p> <p>... <br>... <br>a=20345686; <br>ptr=20345686;//我们的目的是要使指针ptr指向地址20345686（十<br>进制） <br>ptr=a;//我们的目的是要使指针ptr指向地址20345686（十进制）</p> <p>编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就<br>不能达到了吗？不，还有办法： <br>unsigned int a; <br>TYPE *ptr;//TYPE是int，char或结构类型等等类型。 </p> <p>... <br>... <br>a=某个数，这个数必须代表一个合法的地址； <br>ptr=(TYPE*)a；//呵呵，这就可以了。 <br>严格说来这里的(TYPE*)和指针类型转换中的(TYPE*)还不一样。这<br>里的(TYPE*)的意思是把无符号整数a的值当作一个地址来看待。 </p> <p>上面强调了a的值必须代表一个合法的地址，否则的话，在你使用<br>ptr的时候，就会出现非法操作错误。 </p> <p>想想能不能反过来，把指针指向的地址即指针的值当作一个整数取<br>出来。完全可以。下面的例子演示了把一个指针的值当作一个整数取出来，然后再把这个<br>整数当作一个地址赋给一个指针： </p> <p>例十六： </p> <p>int a="123",b; <br>int *ptr=&amp;a; <br>char *str; <br>b=(int)ptr;//把指针ptr的值当作一个整数取出来。 </p> <p>str=(char*)b;//把这个整数的值当作一个地址赋给指针str。</p> <p>好了，现在我们已经知道了，可以把指针的值当作一个整数取出<br>来，也可以把一个整数值当作地址赋给一个指针。 <br>第九章。指针的安全问题 <br>看下面的例子： <br>例十七： <br>char s='a'; <br>int *ptr; <br>ptr=(int*)&amp;s; <br>*ptr=1298； <br>指针ptr是一个int*类型的指针，它指向的类型是int。它指向的地<br>址就是s的首地址。在32位程序中，s占一个字节，int类型占四个字节。最后一条语句不但<br>改变了s所占的一个字节，还把和s相临的高地址方向的三个字节也改变了。这三个字节是<br>干什么的？只有编译程序知道，而写程序的人是不太可能知道的。也许这三个字节里存储<br>了非常重要的数据，也许这三个字节里正好是程序的一条代码，而由于你对指针的马虎应<br>用，这三个字节的值被改变了！这会造成崩溃性的错误。 </p> <p>让我们再来看一例： </p> <p>例十八： </p> <p>1。 char a; <br>2。 int *ptr=&amp;a; <br>... <br>... <br>3。 ptr++; <br>4。 *ptr=115; <br>该例子完全可以通过编译，并能执行。但是看到没有？第3句对指<br>针ptr进行 <br>自加1运算后，ptr指向了和整形变量a相邻的高地址方向的一块存<br>储区。这块存储区里是什么？我们不知道。有可能它是一个非常重要的数据，甚至可能是<br>一条代码。而第4句竟然往这片存储区里写入一个数据！这是严重的错误。所以在使用指针<br>时，程序员心里必须非常清楚：我的指针究竟指向了哪里。 </p> <p>在用指针访问数组的时候，也要注意不要超出数组的低端和高端界<br>限，否则也会造成类似的错误。 <br>在指针的强制类型转换：ptr1=(TYPE*)ptr2中，如果sizeof(ptr2<br>的类型)大于sizeof(ptr1的类型)，那么在使用指针ptr1来访问ptr2所指向的存储区时是安<br>全的。如果sizeof(ptr2的类型)小于sizeof(ptr1的类型)，那么在使用指针ptr1来访问<br>ptr2所指向的存储区时是不安全的。至于为什么，读者结合例十七来想一想，应该会明白<br>的。</p>http://blog.ednchina.com/blog/levension/22519/message.aspx编程天地 软件开发Tue, 10 Apr 2007 16:26:00 GMThttp://blog.ednchina.com/blog/levension/21415/message.aspx<p>C语言宏定义技巧（常用宏定义）&nbsp; <br>&nbsp; <br>写好C语言，漂亮的宏定义很重要，使用宏定义可以防止出错，提高可移植性，可读性，方便性 等等。下面列举一些成熟软件中常用得宏定义。。。。。。 </p> <p>&nbsp; </p> <p>1，防止一个头文件被重复包含 </p> <p>#ifndef COMDEF_H </p> <p>#define COMDEF_H </p> <p>&nbsp; //头文件内容 </p> <p>#endif </p> <p>2，重新定义一些类型，防止由于各种平台和编译器的不同，而产生的类型字节数差异，方便移植。 </p> <p>typedef&nbsp; unsigned char&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; boolean;&nbsp;&nbsp;&nbsp;&nbsp; /* Boolean value type. */ </p> <p>&nbsp; </p> <p>typedef&nbsp; unsigned long int&nbsp; uint32;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Unsigned 32 bit value */ </p> <p>typedef&nbsp; unsigned short&nbsp;&nbsp;&nbsp;&nbsp; uint16;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Unsigned 16 bit value */ </p> <p>typedef&nbsp; unsigned char&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; uint8;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Unsigned 8&nbsp; bit value */ </p> <p>&nbsp; </p> <p>typedef&nbsp; signed long int&nbsp;&nbsp;&nbsp; int32;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Signed 32 bit value */ </p> <p>typedef&nbsp; signed short&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int16;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Signed 16 bit value */ </p> <p>typedef&nbsp; signed char&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int8;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Signed 8&nbsp; bit value */ </p> <p>&nbsp; </p> <p>&nbsp; </p> <p>//下面的不建议使用 </p> <p>typedef&nbsp; unsigned char&nbsp;&nbsp;&nbsp;&nbsp; byte;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Unsigned 8&nbsp; bit value type. */ </p> <p>typedef&nbsp; unsigned short&nbsp;&nbsp;&nbsp; word;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Unsinged 16 bit value type. */ </p> <p>typedef&nbsp; unsigned long&nbsp;&nbsp;&nbsp;&nbsp; dword;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Unsigned 32 bit value type. */ </p> <p>&nbsp; </p> <p>typedef&nbsp; unsigned char&nbsp;&nbsp;&nbsp;&nbsp; uint1;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Unsigned 8&nbsp; bit value type. */ </p> <p>typedef&nbsp; unsigned short&nbsp;&nbsp;&nbsp; uint2;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Unsigned 16 bit value type. */ </p> <p>typedef&nbsp; unsigned long&nbsp;&nbsp;&nbsp;&nbsp; uint4;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Unsigned 32 bit value type. */ </p> <p>&nbsp; </p> <p>typedef&nbsp; signed char&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int1;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Signed 8&nbsp; bit value type. */ </p> <p>typedef&nbsp; signed short&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int2;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Signed 16 bit value type. */ </p> <p>typedef&nbsp; long int&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; int4;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Signed 32 bit value type. */ </p> <p>&nbsp; </p> <p>typedef&nbsp; signed long&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; sint31;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Signed 32 bit value */ </p> <p>typedef&nbsp; signed short&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; sint15;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Signed 16 bit value */ </p> <p>typedef&nbsp; signed char&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; sint7;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /* Signed 8&nbsp; bit value */ </p> <p>&nbsp; </p> <p>3，得到指定地址上的一个字节或字 </p> <p>#define&nbsp; MEM_B( x )&nbsp; ( *( (byte *) (x) ) ) </p> <p>#define&nbsp; MEM_W( x )&nbsp; ( *( (word *) (x) ) ) </p> <p>4，求最大值和最小值 </p> <p>&nbsp;&nbsp; #define&nbsp; MAX( x, y ) ( ((x) &gt; (y)) ? (x) : (y) ) </p> <p>&nbsp;&nbsp; #define&nbsp; MIN( x, y ) ( ((x) &lt; (y)) ? (x) : (y) ) </p> <p>5，得到一个field在结构体(struct)中的偏移量 </p> <p>#define FPOS( type, field ) \ </p> <p>/*lint -e545 */ ( (dword) &amp;(( type *) 0)-&gt; field ) /*lint +e545 */ </p> <p>6,得到一个结构体中field所占用的字节数 </p> <p>#define FSIZ( type, field ) sizeof( ((type *) 0)-&gt;field ) </p> <p>7，按照LSB格式把两个字节转化为一个Word </p> <p>#define&nbsp; FLIPW( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] ) </p> <p>8，按照LSB格式把一个Word转化为两个字节 </p> <p>#define&nbsp; FLOPW( ray, val ) \ </p> <p>&nbsp; (ray)[0] = ((val) / 256); \ </p> <p>&nbsp; (ray)[1] = ((val) &amp; 0xFF) </p> <p>9，得到一个变量的地址（word宽度） </p> <p>#define&nbsp; B_PTR( var )&nbsp; ( (byte *) (void *) &amp;(var) ) </p> <p>#define&nbsp; W_PTR( var )&nbsp; ( (word *) (void *) &amp;(var) ) </p> <p>10，得到一个字的高位和低位字节 </p> <p>#define&nbsp; WORD_LO(xxx)&nbsp; ((byte) ((word)(xxx) &amp; 255)) </p> <p>#define&nbsp; WORD_HI(xxx)&nbsp; ((byte) ((word)(xxx) &gt;&gt; 8)) </p> <p>11，返回一个比X大的最接近的8的倍数 </p> <p>#define RND8( x )&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ((((x) + 7) / 8 ) * 8 ) </p> <p>12，将一个字母转换为大写 </p> <p>#define&nbsp; UPCASE( c ) ( ((c) &gt;= 'a' &amp;&amp; (c) &lt;= 'z') ? ((c) - 0x20) : (c) ) </p> <p>13，判断字符是不是10进值的数字 </p> <p>#define&nbsp; DECCHK( c ) ((c) &gt;= '0' &amp;&amp; (c) &lt;= '9') </p> <p>14，判断字符是不是16进值的数字 </p> <p>#define&nbsp; HEXCHK( c ) ( ((c) &gt;= '0' &amp;&amp; (c) &lt;= '9') ||\ </p> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ((c) &gt;= 'A' &amp;&amp; (c) &lt;= 'F') ||\ </p> <p>((c) &gt;= 'a' &amp;&amp; (c) &lt;= 'f') ) </p> <p>15，防止溢出的一个方法 </p> <p>#define&nbsp; INC_SAT( val )&nbsp; (val = ((val)+1 &gt; (val)) ? (val)+1 : (val)) </p> <p>16，返回数组元素的个数 </p> <p>#define&nbsp; ARR_SIZE( a )&nbsp; ( sizeof( (a) ) / sizeof( (a[0]) ) ) </p> <p>17，返回一个无符号数n尾的值MOD_BY_POWER_OF_TWO(X,n)=X%(2^n) </p> <p>#define MOD_BY_POWER_OF_TWO( val, mod_by ) \ </p> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; ( (dword)(val) &amp; (dword)((mod_by)-1) ) </p> <p>18，对于IO空间映射在存储空间的结构，输入输出处理 </p> <p>&nbsp; #define inp(port)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; (*((volatile byte *) (port))) </p> <p>&nbsp; #define inpw(port)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; (*((volatile word *) (port))) </p> <p>&nbsp; #define inpdw(port)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; (*((volatile dword *)(port))) </p> <p>&nbsp;&nbsp; </p> <p>&nbsp; #define outp(port, val)&nbsp;&nbsp; (*((volatile byte *) (port)) = ((byte) (val))) </p> <p>&nbsp; #define outpw(port, val)&nbsp; (*((volatile word *) (port)) = ((word) (val))) </p> <p>&nbsp; #define outpdw(port, val) (*((volatile dword *) (port)) = ((dword) (val))) </p> <p>[2005-9-9添加]&nbsp; </p> <p>19,使用一些宏跟踪调试 </p> <p>A N S I标准说明了五个预定义的宏名。它们是： </p> <p>_ L I N E _ </p> <p>_ F I L E _ </p> <p>_ D A T E _ </p> <p>_ T I M E _ </p> <p>_ S T D C _ </p> <p>如果编译不是标准的，则可能仅支持以上宏名中的几个，或根本不支持。记住编译程序 </p> <p>也许还提供其它预定义的宏名。 </p> <p>_ L I N E _及_ F I L E _宏指令在有关# l i n e的部分中已讨论，这里讨论其余的宏名。 </p> <p>_ D AT E _宏指令含有形式为月/日/年的串，表示源文件被翻译到代码时的日期。 </p> <p>源代码翻译到目标代码的时间作为串包含在_ T I M E _中。串形式为时：分：秒。 </p> <p>如果实现是标准的，则宏_ S T D C _含有十进制常量1。如果它含有任何其它数，则实现是 </p> <p>非标准的。 </p> <p>可以定义宏，例如: </p> <p>当定义了_DEBUG，输出数据信息和所在文件所在行 </p> <p>#ifdef _DEBUG </p> <p>#define DEBUGMSG(msg,date) printf(msg);printf(“%d%d%d”,date,_LINE_,_FILE_) </p> <p>#else </p> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; #define DEBUGMSG(msg,date)&nbsp; </p> <p>#endif </p> <p>&nbsp; </p> <p>20，宏定义防止使用是错误 </p> <p>用小括号包含。 </p> <p>例如：#define ADD(a,b) （a+b） </p> <p>用do{}while(0)语句包含多语句防止错误 </p> <p>例如：#difne DO(a,b) a+b;\ </p> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; a++; </p> <p>应用时：if(….) </p> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; DO(a,b); //产生错误 </p> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; else </p> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; </p> <p>解决方法: #difne DO(a,b) do{a+b;\ </p> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; a++;}while(0) </p> <p>&nbsp;</p> <p><br>　宏中"#"和"##"的用法 <br>一、一般用法 <br>我们使用#把宏参数变为一个字符串,用##把两个宏参数贴合在一起. <br>用法: <br>#include&lt;cstdio&gt; <br>#include&lt;climits&gt; <br>using namespace std; </p> <p>#define STR(s)&nbsp;&nbsp;&nbsp;&nbsp; #s <br>#define CONS(a,b)&nbsp; int(a##e##b) </p> <p>int main() <br>{ <br>&nbsp;&nbsp;&nbsp; printf(STR(vck));&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 输出字符串"vck" <br>&nbsp;&nbsp;&nbsp; printf("%d\n", CONS(2,3));&nbsp; // 2e3 输出:2000 <br>&nbsp;&nbsp;&nbsp; return 0; <br>} </p> <p>二、当宏参数是另一个宏的时候 <br>需要注意的是凡宏定义里有用'#'或'##'的地方宏参数是不会再展开. </p> <p>1, 非'#'和'##'的情况 <br>#define TOW&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; (2) <br>#define MUL(a,b) (a*b) </p> <p>printf("%d*%d=%d\n", TOW, TOW, MUL(TOW,TOW)); <br>这行的宏会被展开为： <br>printf("%d*%d=%d\n", (2), (2), ((2)*(2))); <br>MUL里的参数TOW会被展开为(2). </p> <p>2, 当有'#'或'##'的时候 <br>#define A&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; (2) <br>#define STR(s)&nbsp;&nbsp;&nbsp;&nbsp; #s <br>#define CONS(a,b)&nbsp; int(a##e##b) </p> <p>printf("int max: %s\n",&nbsp; STR(INT_MAX));&nbsp;&nbsp;&nbsp; // INT_MAX #include&lt;climits&gt; <br>这行会被展开为： <br>printf("int max: %s\n", "INT_MAX"); </p> <p>printf("%s\n", CONS(A, A));&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // compile error&nbsp; <br>这一行则是： <br>printf("%s\n", int(AeA)); </p> <p>INT_MAX和A都不会再被展开, 然而解决这个问题的方法很简单. 加多一层中间转换宏. <br>加这层宏的用意是把所有宏的参数在这层里全部展开, 那么在转换宏里的那一个宏(_STR)就能得到正确的宏参数. </p> <p>#define A&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; (2) <br>#define _STR(s)&nbsp;&nbsp;&nbsp;&nbsp; #s <br>#define STR(s)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; _STR(s)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 转换宏 <br>#define _CONS(a,b)&nbsp; int(a##e##b) <br>#define CONS(a,b)&nbsp;&nbsp; _CONS(a,b)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 转换宏 </p> <p>printf("int max: %s\n", STR(INT_MAX));&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // INT_MAX,int型的最大值，为一个变量 #include&lt;climits&gt; <br>输出为: int max: 0x7fffffff <br>STR(INT_MAX) --&gt;&nbsp; _STR(0x7fffffff) 然后再转换成字符串； </p> <p>printf("%d\n", CONS(A, A)); <br>输出为：200 <br>CONS(A, A)&nbsp; --&gt;&nbsp; _CONS((2), (2))&nbsp; --&gt; int((2)e(2)) </p> <p>三、'#'和'##'的一些应用特例 <br>1、合并匿名变量名 <br>#define&nbsp; ___ANONYMOUS1(type, var, line)&nbsp; type&nbsp; var##line <br>#define&nbsp; __ANONYMOUS0(type, line)&nbsp; ___ANONYMOUS1(type, _anonymous, line) <br>#define&nbsp; ANONYMOUS(type)&nbsp; __ANONYMOUS0(type, __LINE__) <br>例：ANONYMOUS(static int);&nbsp; 即: static int _anonymous70;&nbsp; 70表示该行行号； <br>第一层：ANONYMOUS(static int);&nbsp; --&gt;&nbsp; __ANONYMOUS0(static int, __LINE__); <br>第二层：&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; --&gt;&nbsp; ___ANONYMOUS1(static int, _anonymous, 70); <br>第三层：&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; --&gt;&nbsp; static int&nbsp; _anonymous70; <br>即每次只能解开当前层的宏，所以__LINE__在第二层才能被解开； </p> <p>2、填充结构 <br>#define&nbsp; FILL(a)&nbsp;&nbsp; {a, #a} </p> <p>enum IDD{OPEN, CLOSE}; <br>typedef struct MSG{ <br>&nbsp; IDD id; <br>&nbsp; const char * msg; <br>}MSG; </p> <p>MSG _msg[] = {FILL(OPEN), FILL(CLOSE)}; <br>相当于： <br>MSG _msg[] = {{OPEN, "OPEN"}, <br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; {CLOSE, "CLOSE"}}; </p> <p>3、记录文件名 <br>#define&nbsp; _GET_FILE_NAME(f)&nbsp;&nbsp; #f <br>#define&nbsp; GET_FILE_NAME(f)&nbsp;&nbsp;&nbsp; _GET_FILE_NAME(f) <br>static char&nbsp; FILE_NAME[] = GET_FILE_NAME(__FILE__); </p> <p>4、得到一个数值类型所对应的字符串缓冲大小 <br>#define&nbsp; _TYPE_BUF_SIZE(type)&nbsp; sizeof #type <br>#define&nbsp; TYPE_BUF_SIZE(type)&nbsp;&nbsp; _TYPE_BUF_SIZE(type) <br>char&nbsp; buf[TYPE_BUF_SIZE(INT_MAX)]; <br>&nbsp;&nbsp;&nbsp;&nbsp; --&gt;&nbsp; char&nbsp; buf[_TYPE_BUF_SIZE(0x7fffffff)]; <br>&nbsp;&nbsp;&nbsp;&nbsp; --&gt;&nbsp; char&nbsp; buf[sizeof "0x7fffffff"]; <br>这里相当于： <br>char&nbsp; buf[11]; <br></p>http://blog.ednchina.com/blog/levension/21415/message.aspx编程天地 软件开发Sat, 07 Apr 2007 13:56:44 GMThttp://blog.ednchina.com/blog/levension/21018/message.aspx<p>括号下标最优先，指向结构体成员；</p> <p>逻辑非后按位反，自增自减负类型；</p> <p>指针地址与长度，乘除求余加减法；</p> <p>左移右移找关系，等不等于按位与；</p> <p>异或之后按位或，逻辑与或有条件；</p> <p>赋值号多辈分低，最不优先数逗号。</p>http://blog.ednchina.com/blog/levension/21018/message.aspx编程天地 软件开发Fri, 06 Apr 2007 15:50:48 GMThttp://blog.ednchina.com/blog/levension/20864/message.aspx<p>只要功率足够，砖头也能飞起来！</p> <p>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; <a href="http://blog.ednchina.com/Upload/Blog/2007/4/6/a7011f02-1358-4583-9c90-0e7fdc49db6a.pdf" target=_blank><img alt="pdf" src="http://space.ednchina.com/images/FileIco/pdf.gif"></a></p>http://blog.ednchina.com/blog/levension/20864/message.aspx编程天地 软件开发Sat, 10 Mar 2007 13:36:47 GMThttp://blog.ednchina.com/blog/levension/17759/message.aspx<div class="postText"><font size="2">堆和栈的区别<br>一、预备知识—程序的内存分配<br>一个由c/C++编译的程序占用的内存分为以下几个部分<br>1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。<br>2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。<br>3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放<br>4、文字常量区—常量字符串就是放在这里的。 程序结束后由系统释放<br>5、程序代码区—存放函数体的二进制代码。<br>二、例子程序<br>这是一个前辈写的，非常详细<br>//main.cpp<br>int a = 0; 全局初始化区<br>char *p1; 全局未初始化区<br>main()<br>{<br>int b; 栈<br>char s[] = "abc"; 栈<br>char *p2; 栈<br>char *p3 = "123456"; 123456\0在常量区，p3在栈上。<br>static int c =0； 全局（静态）初始化区<br>p1 = (char *)malloc(10);<br>p2 = (char *)malloc(20);<br>分配得来得10和20字节的区域就在堆区。<br>strcpy(p1, "123456"); 123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。<br>}<br><br><br>二、堆和栈的理论知识<br>2.1申请方式<br>stack:<br>由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间<br>heap:<br>需要程序员自己申请，并指明大小，在c中malloc函数<br>如p1 = (char *)malloc(10);<br>在C++中用new运算符<br>如p2 = (char *)malloc(10);<br>但是注意p1、p2本身是在栈中的。<br><br><br>2.2<br>申请后系统的响应<br>栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。<br>堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，<br>会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。<br><br>2.3申请大小的限制<br>栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。<br>堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。<br><br><br>2.4申请效率的比较：<br>栈由系统自动分配，速度较快。但程序员是无法控制的。<br>堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.<br>另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。<br><br>2.5堆和栈中的存储内容<br>栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。<br>当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。<br>堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。<br><br>2.6存取效率的比较<br><br>char s1[] = "aaaaaaaaaaaaaaa";<br>char *s2 = "bbbbbbbbbbbbbbbbb";<br>aaaaaaaaaaa是在运行时刻赋值的；<br>而bbbbbbbbbbb是在编译时就确定的；<br>但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。<br>比如：<br>＃i nclude<br>void main()<br>{<br>char a = 1;<br>char c[] = "1234567890";<br>char *p ="1234567890";<br>a = c[1];<br>a = p[1];<br>return;<br>}<br>对应的汇编代码<br>10: a = c[1];<br>00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]<br>0040106A 88 4D FC mov byte ptr [ebp-4],cl<br>11: a = p[1];<br>0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]<br>00401070 8A 42 01 mov al,byte ptr [edx+1]<br>00401073 88 45 FC mov byte ptr [ebp-4],al<br>第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。<br><br><br>2.7小结：<br>堆和栈的区别可以用如下的比喻来看出：<br>使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。<br>使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。<br><br><br><br><br><br>windows进程中的内存结构<br><br><br>在阅读本文之前，如果你连堆栈是什么多不知道的话，请先阅读文章后面的基础知识。<br><br>接触过编程的人都知道，高级语言都能通过变量名来访问内存中的数据。那么这些变量在内存中是如何存放的呢？程序又是如何使用这些变量的呢？下面就会对此进行深入的讨论。下文中的C语言代码如没有特别声明，默认都使用VC编译的release版。<br><br>首先，来了解一下 C 语言的变量是如何在内存分部的。C 语言有全局变量(Global)、本地变量(Local)，静态变量(Static)、寄存器变量(Regeister)。每种变量都有不同的分配方式。先来看下面这段代码：<br><br>＃i nclude &lt;stdio.h&gt;<br><br>int g1=0, g2=0, g3=0;<br><br>int main()<br>{<br>static int s1=0, s2=0, s3=0;<br>int v1=0, v2=0, v3=0;<br><br>//打印出各个变量的内存地址<br><br>printf("0x%08x\n",&amp;v1); //打印各本地变量的内存地址<br>printf("0x%08x\n",&amp;v2);<br>printf("0x%08x\n\n",&amp;v3);<br>printf("0x%08x\n",&amp;g1); //打印各全局变量的内存地址<br>printf("0x%08x\n",&amp;g2);<br>printf("0x%08x\n\n",&amp;g3);<br>printf("0x%08x\n",&amp;s1); //打印各静态变量的内存地址<br>printf("0x%08x\n",&amp;s2);<br>printf("0x%08x\n\n",&amp;s3);<br>return 0;<br>}<br><br>编译后的执行结果是：<br><br>0x0012ff78<br>0x0012ff7c<br>0x0012ff80<br><br>0x004068d0<br>0x004068d4<br>0x004068d8<br><br>0x004068dc<br>0x004068e0<br>0x004068e4<br><br>输出的结果就是变量的内存地址。其中v1,v2,v3是本地变量，g1,g2,g3是全局变量，s1,s2,s3是静态变量。你可以看到这些变量在内存是连续分布的，但是本地变量和全局变量分配的内存地址差了十万八千里，而全局变量和静态变量分配的内存是连续的。这是因为本地变量和全局/静态变量是分配在不同类型的内存区域中的结果。对于一个进程的内存空间而言，可以在逻辑上分成3个部份：代码区，静态数据区和动态数据区。动态数据区一般就是“堆栈”。“栈 (stack)”和“堆(heap)”是两种不同的动态数据区，栈是一种线性结构，堆是一种链式结构。进程的每个线程都有私有的“栈”，所以每个线程虽然代码一样，但本地变量的数据都是互不干扰。一个堆栈可以通过“基地址”和“栈顶”地址来描述。全局变量和静态变量分配在静态数据区，本地变量分配在动态数据区，即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。<br><br><br>├———————┤低端内存区域<br>│ …… │<br>├———————┤<br>│ 动态数据区 │<br>├———————┤<br>│ …… │<br>├———————┤<br>│ 代码区 │<br>├———————┤<br>│ 静态数据区 │<br>├———————┤<br>│ …… │<br>├———————┤高端内存区域<br><br><br>堆栈是一个先进后出的数据结构，栈顶地址总是小于等于栈的基地址。我们可以先了解一下函数调用的过程，以便对堆栈在程序中的作用有更深入的了解。不同的语言有不同的函数调用规定，这些因素有参数的压入规则和堆栈的平衡。windows API的调用规则和ANSI C的函数调用规则是不一样的，前者由被调函数调整堆栈，后者由调用者调整堆栈。两者通过“__stdcall”和“__cdecl”前缀区分。先看下面这段代码：<br><br>＃i nclude &lt;stdio.h&gt;<br><br>void __stdcall func(int param1,int param2,int param3)<br>{<br>int var1=param1;<br>int var2=param2;<br>int var3=param3;<br>printf("0x%08x\n",?m1); //打印出各个变量的内存地址<br>printf("0x%08x\n",?m2);<br>printf("0x%08x\n\n",?m3);<br>printf("0x%08x\n",&amp;var1);<br>printf("0x%08x\n",&amp;var2);<br>printf("0x%08x\n\n",&amp;var3);<br>return;<br>}<br><br>int main()<br>{<br>func(1,2,3);<br>return 0;<br>}<br><br>编译后的执行结果是：<br><br>0x0012ff78<br>0x0012ff7c<br>0x0012ff80<br><br>0x0012ff68<br>0x0012ff6c<br>0x0012ff70<br><br><br>├———————┤&lt;—函数执行时的栈顶（ESP）、低端内存区域<br>│ …… │<br>├———————┤<br>│ var 1 │<br>├———————┤<br>│ var 2 │<br>├———————┤<br>│ var 3 │<br>├———————┤<br>│ RET │<br>├———————┤&lt;—“__cdecl”函数返回后的栈顶（ESP）<br>│ parameter 1 │<br>├———————┤<br>│ parameter 2 │<br>├———————┤<br>│ parameter 3 │<br>├———————┤&lt;—“__stdcall”函数返回后的栈顶（ESP）<br>│ …… │<br>├———————┤&lt;—栈底（基地址 EBP）、高端内存区域<br><br><br>上图就是函数调用过程中堆栈的样子了。首先，三个参数以从又到左的次序压入堆栈，先压“param3”，再压“param2”，最后压入“param1”；然后压入函数的返回地址(RET)，接着跳转到函数地址接着执行（这里要补充一点，介绍UNIX下的缓冲溢出原理的文章中都提到在压入RET后，继续压入当前EBP，然后用当前ESP代替EBP。然而，有一篇介绍windows下函数调用的文章中说，在windows下的函数调用也有这一步骤，但根据我的实际调试，并未发现这一步，这还可以从param3和var1之间只有4字节的间隙这点看出来）；第三步，将栈顶(ESP)减去一个数，为本地变量分配内存空间，上例中是减去12字节(ESP=ESP-3*4，每个int变量占用4个字节)；接着就初始化本地变量的内存空间。由于“__stdcall”调用由被调函数调整堆栈，所以在函数返回前要恢复堆栈，先回收本地变量占用的内存(ESP=ESP+3*4)，然后取出返回地址，填入EIP寄存器，回收先前压入参数占用的内存(ESP=ESP+3*4)，继续执行调用者的代码。参见下列汇编代码：<br><br>;--------------func 函数的汇编代码-------------------<br><br>:00401000 83EC0C sub esp, 0000000C //创建本地变量的内存空间<br>:00401003 8B442410 mov eax, dword ptr [esp+10]<br>:00401007 8B4C2414 mov ecx, dword ptr [esp+14]<br>:0040100B 8B542418 mov edx, dword ptr [esp+18]<br>:0040100F 89442400 mov dword ptr [esp], eax<br>:00401013 8D442410 lea eax, dword ptr [esp+10]<br>:00401017 894C2404 mov dword ptr [esp+04], ecx<br><br>……………………（省略若干代码）<br><br>:00401075 83C43C add esp, 0000003C ;恢复堆栈，回收本地变量的内存空间<br>:00401078 C3 ret 000C ;函数返回，恢复参数占用的内存空间<br>;如果是“__cdecl”的话，这里是“ret”，堆栈将由调用者恢复<br><br>;-------------------函数结束-------------------------<br><br><br>;--------------主程序调用func函数的代码--------------<br><br>:00401080 6A03 push 00000003 //压入参数param3<br>:00401082 6A02 push 00000002 //压入参数param2<br>:00401084 6A01 push 00000001 //压入参数param1<br>:00401086 E875FFFFFF call 00401000 //调用func函数<br>;如果是“__cdecl”的话，将在这里恢复堆栈，“add esp, 0000000C”<br><br>聪明的读者看到这里，差不多就明白缓冲溢出的原理了。先来看下面的代码：<br><br>＃i nclude &lt;stdio.h&gt;<br>＃i nclude &lt;string.h&gt;<br><br>void __stdcall func()<br>{<br>char lpBuff[8]="\0";<br>strcat(lpBuff,"AAAAAAAAAAA");<br>return;<br>}<br><br>int main()<br>{<br>func();<br>return 0;<br>}<br><br>编译后执行一下回怎么样？哈，“"0x00414141"指令引用的"0x00000000"内存。该内存不能为"read"。”，“非法操作”喽！ "41"就是"A"的16进制的ASCII码了，那明显就是strcat这句出的问题了。"lpBuff"的大小只有8字节，算进结尾的\0，那 strcat最多只能写入7个"A"，但程序实际写入了11个"A"外加1个\0。再来看看上面那幅图，多出来的4个字节正好覆盖了RET的所在的内存空间，导致函数返回到一个错误的内存地址，执行了错误的指令。如果能精心构造这个字符串，使它分成三部分，前一部份仅仅是填充的无意义数据以达到溢出的目的，接着是一个覆盖RET的数据，紧接着是一段shellcode，那只要着个RET地址能指向这段shellcode的第一个指令，那函数返回时就能执行shellcode了。但是软件的不同版本和不同的运行环境都可能影响这段shellcode在内存中的位置，那么要构造这个RET是十分困难的。一般都在RET和shellcode之间填充大量的NOP指令，使得exploit有更强的通用性。<br><br><br>├———————┤&lt;—低端内存区域<br>│ …… │<br>├———————┤&lt;—由exploit填入数据的开始<br>│ │<br>│ buffer │&lt;—填入无用的数据<br>│ │<br>├———————┤<br>│ RET │&lt;—指向shellcode，或NOP指令的范围<br>├———————┤<br>│ NOP │<br>│ …… │&lt;—填入的NOP指令，是RET可指向的范围<br>│ NOP │<br>├———————┤<br>│ │<br>│ shellcode │<br>│ │<br>├———————┤&lt;—由exploit填入数据的结束<br>│ …… │<br>├———————┤&lt;—高端内存区域<br><br><br>windows下的动态数据除了可存放在栈中，还可以存放在堆中。了解C++的朋友都知道，C++可以使用new关键字来动态分配内存。来看下面的C++代码：<br><br>＃i nclude &lt;stdio.h&gt;<br>＃i nclude &lt;iostream.h&gt;<br>＃i nclude &lt;windows.h&gt;<br><br>void func()<br>{<br>char *buffer=new char[128];<br>char bufflocal[128];<br>static char buffstatic[128];<br>printf("0x%08x\n",buffer); //打印堆中变量的内存地址<br>printf("0x%08x\n",bufflocal); //打印本地变量的内存地址<br>printf("0x%08x\n",buffstatic); //打印静态变量的内存地址<br>}<br><br>void main()<br>{<br>func();<br>return;<br>}<br><br>程序执行结果为：<br><br>0x004107d0<br>0x0012ff04<br>0x004068c0<br><br>可以发现用new关键字分配的内存即不在栈中，也不在静态数据区。VC编译器是通过windows下的“堆(heap)”来实现new关键字的内存动态分配。在讲“堆”之前，先来了解一下和“堆”有关的几个API函数：<br><br>HeapAlloc 在堆中申请内存空间<br>HeapCreate 创建一个新的堆对象<br>HeapDestroy 销毁一个堆对象<br>HeapFree 释放申请的内存<br>HeapWalk 枚举堆对象的所有内存块<br>GetProcessHeap 取得进程的默认堆对象<br>GetProcessHeaps 取得进程所有的堆对象<br>LocalAlloc<br>GlobalAlloc<br><br>当进程初始化时，系统会自动为进程创建一个默认堆，这个堆默认所占内存的大小为1M。堆对象由系统进行管理，它在内存中以链式结构存在。通过下面的代码可以通过堆动态申请内存空间：<br><br>HANDLE hHeap="GetProcessHeap"();<br>char *buff=HeapAlloc(hHeap,0,8);<br><br>其中hHeap是堆对象的句柄，buff是指向申请的内存空间的地址。那这个hHeap究竟是什么呢？它的值有什么意义吗？看看下面这段代码吧：<br><br>#pragma comment(linker,"/entry:main") //定义程序的入口<br>＃i nclude &lt;windows.h&gt;<br><br>_CRTIMP int (__cdecl *printf)(const char *, ...); //定义STL函数printf<br>/*---------------------------------------------------------------------------<br>写到这里，我们顺便来复习一下前面所讲的知识：<br>(*注)printf函数是C语言的标准函数库中函数，VC的标准函数库由msvcrt.dll模块实现。<br>由函数定义可见，printf的参数个数是可变的，函数内部无法预先知道调用者压入的参数个数，函数只能通过分析第一个参数字符串的格式来获得压入参数的信息，由于这里参数的个数是动态的，所以必须由调用者来平衡堆栈，这里便使用了__cdecl调用规则。BTW，Windows系统的API函数基本上是 __stdcall调用形式，只有一个API例外，那就是wsprintf，它使用__cdecl调用规则，同printf函数一样，这是由于它的参数个数是可变的缘故。<br>---------------------------------------------------------------------------*/<br>void main()<br>{<br>HANDLE hHeap="GetProcessHeap"();<br>char *buff=HeapAlloc(hHeap,0,0x10);<br>char *buff2=HeapAlloc(hHeap,0,0x10);<br>HMODULE hMsvcrt="LoadLibrary"("msvcrt.dll");<br>printf=(void *)GetProcAddress(hMsvcrt,"printf");<br>printf("0x%08x\n",hHeap);<br>printf("0x%08x\n",buff);<br>printf("0x%08x\n\n",buff2);<br>}<br><br>执行结果为：<br><br>0x00130000<br>0x00133100<br>0x00133118<br><br>hHeap 的值怎么和那个buff的值那么接近呢？其实hHeap这个句柄就是指向HEAP首部的地址。在进程的用户区存着一个叫PEB(进程环境块)的结构，这个结构中存放着一些有关进程的重要信息，其中在PEB首地址偏移0x18处存放的ProcessHeap就是进程默认堆的地址，而偏移0x90处存放了指向进程所有堆的地址列表的指针。windows有很多API都使用进程的默认堆来存放动态数据，如windows 2000下的所有ANSI版本的函数都是在默认堆中申请内存来转换ANSI字符串到Unicode字符串的。对一个堆的访问是顺序进行的，同一时刻只能有一个线程访问堆中的数据，当多个线程同时有访问要求时，只能排队等待，这样便造成程序执行效率下降。<br><br>最后来说说内存中的数据对齐。所位数据对齐，是指数据所在的内存地址必须是该数据长度的整数倍，DWORD数据的内存起始地址能被4除尽，WORD数据的内存起始地址能被2除尽，x86 CPU能直接访问对齐的数据，当他试图访问一个未对齐的数据时，会在内部进行一系列的调整，这些调整对于程序来说是透明的，但是会降低运行速度，所以编译器在编译程序时会尽量保证数据对齐。同样一段代码，我们来看看用VC、Dev-C++和lcc三个不同编译器编译出来的程序的执行结果：<br><br>＃i nclude &lt;stdio.h&gt;<br><br>int main()<br>{<br>int a;<br>char b;<br>int c;<br>printf("0x%08x\n",&amp;a);<br>printf("0x%08x\n",&amp;b);<br>printf("0x%08x\n",&amp;c);<br>return 0;<br>}<br><br>这是用VC编译后的执行结果：<br>0x0012ff7c<br>0x0012ff7b<br>0x0012ff80<br>变量在内存中的顺序：b(1字节)-a(4字节)-c(4字节)。<br><br>这是用Dev-C++编译后的执行结果：<br>0x0022ff7c<br>0x0022ff7b<br>0x0022ff74<br>变量在内存中的顺序：c(4字节)-中间相隔3字节-b(占1字节)-a(4字节)。<br><br>这是用lcc编译后的执行结果：<br>0x0012ff6c<br>0x0012ff6b<br>0x0012ff64<br>变量在内存中的顺序：同上。<br><br>三个编译器都做到了数据对齐，但是后两个编译器显然没VC“聪明”，让一个char占了4字节，浪费内存哦。<br><br><br>基础知识：<br>堆栈是一种简单的数据结构，是一种只允许在其一端进行插入或删除的线性表。允许插入或删除操作的一端称为栈顶，另一端称为栈底，对堆栈的插入和删除操作被称为入栈和出栈。有一组CPU指令可以实现对进程的内存实现堆栈访问。其中，POP指令实现出栈操作，PUSH指令实现入栈操作。CPU的ESP寄存器存放当前线程的栈顶指针，EBP寄存器中保存当前线程的栈底指针。CPU的EIP寄存器存放下一个CPU指令存放的内存地址，当CPU执行完当前的指令后，从 EIP寄存器中读取下一条指令的内存地址，然后继续执行。<br>讨论常见的堆性能问题以及如何防范它们<br><br>前言<br>您是否是动态分配的 C/C++ 对象忠实且幸运的用户？您是否在模块间的往返通信中频繁地使用了“自动化”？您的程序是否因堆分配而运行起来很慢？不仅仅您遇到这样的问题。几乎所有项目迟早都会遇到堆问题。大家都想说，“我的代码真正好，只是堆太慢”。那只是部分正确。更深入理解堆及其用法、以及会发生什么问题，是很有用的。<br><br>什么是堆？<br>（如果您已经知道什么是堆，可以跳到“什么是常见的堆性能问题？”部分）<br><br>在程序中，使用堆来动态分配和释放对象。在下列情况下，调用堆操作：<br><br>事先不知道程序所需对象的数量和大小。<br><br><br>对象太大而不适合堆栈分配程序。<br>堆使用了在运行时分配给代码和堆栈的内存之外的部分内存。下图给出了堆分配程序的不同层。<br><br><br>GlobalAlloc/GlobalFree：Microsoft Win32 堆调用，这些调用直接与每个进程的默认堆进行对话。<br><br>LocalAlloc/LocalFree：Win32 堆调用（为了与 Microsoft Windows NT 兼容），这些调用直接与每个进程的默认堆进行对话。<br><br>COM 的 IMalloc 分配程序（或 CoTaskMemAlloc / CoTaskMemFree）：函数使用每个进程的默认堆。自动化程序使用“组件对象模型 (COM)”的分配程序，而申请的程序使用每个进程堆。<br><br>C/C++ 运行时 (CRT) 分配程序：提供了 malloc() 和 free() 以及 new 和 delete 操作符。如 Microsoft Visual Basic 和 Java 等语言也提供了新的操作符并使用垃圾收集来代替堆。CRT 创建自己的私有堆，驻留在 Win32 堆的顶部。<br><br>Windows NT 中，Win32 堆是 Windows NT 运行时分配程序周围的薄层。所有 API 转发它们的请求给 NTDLL。<br><br>Windows NT 运行时分配程序提供 Windows NT 内的核心堆分配程序。它由具有 128 个大小从 8 到 1,024 字节的空闲列表的前端分配程序组成。后端分配程序使用虚拟内存来保留和提交页。<br><br>在图表的底部是“虚拟内存分配程序”，操作系统使用它来保留和提交页。所有分配程序使用虚拟内存进行数据的存取。<br><br>分配和释放块不就那么简单吗？为何花费这么长时间？<br><br>堆实现的注意事项<br>传统上，操作系统和运行时库是与堆的实现共存的。在一个进程的开始，操作系统创建一个默认堆，叫做“进程堆”。如果没有其他堆可使用，则块的分配使用“进程堆”。语言运行时也能在进程内创建单独的堆。（例如，C 运行时创建它自己的堆。）除这些专用的堆外，应用程序或许多已载入的动态链接库 (DLL) 之一可以创建和使用单独的堆。Win32 提供一整套 API 来创建和使用私有堆。有关堆函数（英文）的详尽指导，请参见 MSDN。<br><br>当应用程序或 DLL 创建私有堆时，这些堆存在于进程空间，并且在进程内是可访问的。从给定堆分配的数据将在同一个堆上释放。（不能从一个堆分配而在另一个堆释放。）<br><br>在所有虚拟内存系统中，堆驻留在操作系统的“虚拟内存管理器”的顶部。语言运行时堆也驻留在虚拟内存顶部。某些情况下，这些堆是操作系统堆中的层，而语言运行时堆则通过大块的分配来执行自己的内存管理。不使用操作系统堆，而使用虚拟内存函数更利于堆的分配和块的使用。<br><br>典型的堆实现由前、后端分配程序组成。前端分配程序维持固定大小块的空闲列表。对于一次分配调用，堆尝试从前端列表找到一个自由块。如果失败，堆被迫从后端（保留和提交虚拟内存）分配一个大块来满足请求。通用的实现有每块分配的开销，这将耗费执行周期，也减少了可使用的存储空间。<br><br>Knowledge Base 文章 Q10758，“用 calloc() 和 malloc() 管理内存” （搜索文章编号）, 包含了有关这些主题的更多背景知识。另外，有关堆实现和设计的详细讨论也可在下列著作中找到：“Dynamic Storage Allocation: A Survey and Critical Review”，作者 Paul R. Wilson、Mark S. Johnstone、Michael Neely 和 David Boles；“International Workshop on Memory Management”, 作者 Kinross, Scotland, UK, 1995 年 9 月(http://www.cs.utexas.edu/users/oops/papers.html)（英文）。<br><br>Windows NT 的实现（Windows NT 版本 4.0 和更新版本） 使用了 127 个大小从 8 到 1,024 字节的 8 字节对齐块空闲列表和一个“大块”列表。“大块”列表（空闲列表[0]） 保存大于 1,024 字节的块。空闲列表容纳了用双向链表链接在一起的对象。默认情况下，“进程堆”执行收集操作。（收集是将相邻空闲块合并成一个大块的操作。）收集耗费了额外的周期，但减少了堆块的内部碎片。<br><br>单一全局锁保护堆，防止多线程式的使用。（请参见“Server Performance and Scalability Killers”中的第一个注意事项, George Reilly 所著，在 “MSDN Online Web Workshop”上（站点：http://msdn.microsoft.com/workshop/server/iis/tencom.asp（英文）。）单一全局锁本质上是用来保护堆数据结构，防止跨多线程的随机存取。若堆操作太频繁，单一全局锁会对性能有不利的影响。<br><br>什么是常见的堆性能问题？<br>以下是您使用堆时会遇到的最常见问题：<br><br>分配操作造成的速度减慢。光分配就耗费很长时间。最可能导致运行速度减慢原因是空闲列表没有块，所以运行时分配程序代码会耗费周期寻找较大的空闲块，或从后端分配程序分配新块。<br><br><br>释放操作造成的速度减慢。释放操作耗费较多周期，主要是启用了收集操作。收集期间，每个释放操作“查找”它的相邻块，取出它们并构造成较大块，然后再把此较大块插入空闲列表。在查找期间，内存可能会随机碰到，从而导致高速缓存不能命中，性能降低。<br><br><br>堆竞争造成的速度减慢。当两个或多个线程同时访问数据，而且一个线程继续进行之前必须等待另一个线程完成时就发生竞争。竞争总是导致麻烦；这也是目前多处理器系统遇到的最大问题。当大量使用内存块的应用程序或 DLL 以多线程方式运行（或运行于多处理器系统上）时将导致速度减慢。单一锁定的使用—常用的解决方案—意味着使用堆的所有操作是序列化的。当等待锁定时序列化会引起线程切换上下文。可以想象交叉路口闪烁的红灯处走走停停导致的速度减慢。<br>竞争通常会导致线程和进程的上下文切换。上下文切换的开销是很大的，但开销更大的是数据从处理器高速缓存中丢失，以及后来线程复活时的数据重建。<br><br>堆破坏造成的速度减慢。造成堆破坏的原因是应用程序对堆块的不正确使用。通常情形包括释放已释放的堆块或使用已释放的堆块，以及块的越界重写等明显问题。（破坏不在本文讨论范围之内。有关内存重写和泄漏等其他细节，请参见 Microsoft Visual C++(R) 调试文档 。）<br><br><br>频繁的分配和重分配造成的速度减慢。这是使用脚本语言时非常普遍的现象。如字符串被反复分配，随重分配增长和释放。不要这样做，如果可能，尽量分配大字符串和使用缓冲区。另一种方法就是尽量少用连接操作。<br>竞争是在分配和释放操作中导致速度减慢的问题。理想情况下，希望使用没有竞争和快速分配/释放的堆。可惜，现在还没有这样的通用堆，也许将来会有。<br><br>在所有的服务器系统中（如 IIS、MSProxy、DatabaseStacks、网络服务器、 Exchange 和其他）, 堆锁定实在是个大瓶颈。处理器数越多，竞争就越会恶化。<br><br>尽量减少堆的使用<br>现在您明白使用堆时存在的问题了，难道您不想拥有能解决这些问题的超级魔棒吗？我可希望有。但没有魔法能使堆运行加快—因此不要期望在产品出货之前的最后一星期能够大为改观。如果提前规划堆策略，情况将会大大好转。调整使用堆的方法，减少对堆的操作是提高性能的良方。<br><br>如何减少使用堆操作？通过利用数据结构内的位置可减少堆操作的次数。请考虑下列实例：<br><br>struct ObjectA {<br>&nbsp; // objectA 的数据<br>}<br><br>struct ObjectB {<br>&nbsp; // objectB 的数据<br>}<br><br>// 同时使用 objectA 和 objectB<br><br>//<br>// 使用指针<br>//<br>struct ObjectB {<br>&nbsp; struct ObjectA * pObjA;<br>&nbsp; // objectB 的数据<br>}<br><br>//<br>// 使用嵌入<br>//<br>struct ObjectB {<br>&nbsp; struct ObjectA pObjA;<br>&nbsp; // objectB 的数据<br>}<br><br>//<br>// 集合 – 在另一对象内使用 objectA 和 objectB<br>//<br><br>struct ObjectX {<br>&nbsp; struct ObjectA&nbsp; objA;<br>&nbsp; struct ObjectB&nbsp; objB;<br>}<br><br>避免使用指针关联两个数据结构。如果使用指针关联两个数据结构，前面实例中的对象 A 和 B 将被分别分配和释放。这会增加额外开销—我们要避免这种做法。<br><br><br>把带指针的子对象嵌入父对象。当对象中有指针时，则意味着对象中有动态元素（百分之八十）和没有引用的新位置。嵌入增加了位置从而减少了进一步分配/释放的需求。这将提高应用程序的性能。<br><br><br>合并小对象形成大对象（聚合）。聚合减少分配和释放的块的数量。如果有几个开发者，各自开发设计的不同部分，则最终会有许多小对象需要合并。集成的挑战就是要找到正确的聚合边界。<br><br><br>内联缓冲区能够满足百分之八十的需要（aka 80-20 规则）。个别情况下，需要内存缓冲区来保存字符串/二进制数据，但事先不知道总字节数。估计并内联一个大小能满足百分之八十需要的缓冲区。对剩余的百分之二十，可以分配一个新的缓冲区和指向这个缓冲区的指针。这样，就减少分配和释放调用并增加数据的位置空间，从根本上提高代码的性能。<br><br><br>在块中分配对象（块化）。块化是以组的方式一次分配多个对象的方法。如果对列表的项连续跟踪，例如对一个 {名称，值} 对的列表，有两种选择：选择一是为每一个“名称-值”对分配一个节点；选择二是分配一个能容纳（如五个）“名称-值”对的结构。例如，一般情况下，如果存储四对，就可减少节点的数量，如果需要额外的空间数量，则使用附加的链表指针。<br>块化是友好的处理器高速缓存，特别是对于 L1-高速缓存，因为它提供了增加的位置 —不用说对于块分配，很多数据块会在同一个虚拟页中。<br><br>正确使用 _amblksiz。C 运行时 (CRT) 有它的自定义前端分配程序，该分配程序从后端（Win32 堆）分配大小为 _amblksiz 的块。将 _amblksiz 设置为较高的值能潜在地减少对后端的调用次数。这只对广泛使用 CRT 的程序适用。<br>使用上述技术将获得的好处会因对象类型、大小及工作量而有所不同。但总能在性能和可升缩性方面有所收获。另一方面，代码会有点特殊，但如果经过深思熟虑，代码还是很容易管理的。<br><br>其他提高性能的技术<br>下面是一些提高速度的技术：<br><br>使用 Windows NT5 堆<br>由于几个同事的努力和辛勤工作，1998 年初 Microsoft Windows(R) 2000 中有了几个重大改进：<br><br>改进了堆代码内的锁定。堆代码对每堆一个锁。全局锁保护堆数据结构，防止多线程式的使用。但不幸的是，在高通信量的情况下，堆仍受困于全局锁，导致高竞争和低性能。Windows 2000 中，锁内代码的临界区将竞争的可能性减到最小,从而提高了可伸缩性。<br><br><br>使用 “Lookaside”列表。堆数据结构对块的所有空闲项使用了大小在 8 到 1,024 字节（以 8-字节递增）的快速高速缓存。快速高速缓存最初保护在全局锁内。现在，使用 lookaside 列表来访问这些快速高速缓存空闲列表。这些列表不要求锁定，而是使用 64 位的互锁操作，因此提高了性能。<br><br><br>内部数据结构算法也得到改进。<br>这些改进避免了对分配高速缓存的需求，但不排除其他的优化。使用 Windows NT5 堆评估您的代码；它对小于 1,024 字节 (1 KB) 的块（来自前端分配程序的块）是最佳的。GlobalAlloc() 和 LocalAlloc() 建立在同一堆上，是存取每个进程堆的通用机制。如果希望获得高的局部性能，则使用 Heap(R) API 来存取每个进程堆，或为分配操作创建自己的堆。如果需要对大块操作，也可以直接使用 VirtualAlloc() / VirtualFree() 操作。<br><br>上述改进已在 Windows 2000 beta 2 和 Windows NT 4.0 SP4 中使用。改进后，堆锁的竞争率显著降低。这使所有 Win32 堆的直接用户受益。CRT 堆建立于 Win32 堆的顶部，但它使用自己的小块堆，因而不能从 Windows NT 改进中受益。（Visual C++ 版本 6.0 也有改进的堆分配程序。）<br><br>使用分配高速缓存<br>分配高速缓存允许高速缓存分配的块，以便将来重用。这能够减少对进程堆（或全局堆）的分配/释放调用的次数，也允许最大限度的重用曾经分配的块。另外，分配高速缓存允许收集统计信息,以便较好地理解对象在较高层次上的使用。<br><br>典型地，自定义堆分配程序在进程堆的顶部实现。自定义堆分配程序与系统堆的行为很相似。主要的差别是它在进程堆的顶部为分配的对象提供高速缓存。高速缓存设计成一套固定大小（如 32 字节、64 字节、128 字节等）。这一个很好的策略，但这种自定义堆分配程序丢失与分配和释放的对象相关的“语义信息”。<br><br>与自定义堆分配程序相反，“分配高速缓存”作为每类分配高速缓存来实现。除能够提供自定义堆分配程序的所有好处之外，它们还能够保留大量语义信息。每个分配高速缓存处理程序与一个目标二进制对象关联。它能够使用一套参数进行初始化，这些参数表示并发级别、对象大小和保持在空闲列表中的元素的数量等。分配高速缓存处理程序对象维持自己的私有空闲实体池（不超过指定的阀值）并使用私有保护锁。合在一起，分配高速缓存和私有锁减少了与主系统堆的通信量，因而提供了增加的并发、最大限度的重用和较高的可伸缩性。<br><br>需要使用清理程序来定期检查所有分配高速缓存处理程序的活动情况并回收未用的资源。如果发现没有活动，将释放分配对象的池，从而提高性能。<br><br>可以审核每个分配/释放活动。第一级信息包括对象、分配和释放调用的总数。通过查看它们的统计信息可以得出各个对象之间的语义关系。利用以上介绍的许多技术之一，这种关系可以用来减少内存分配。<br><br>分配高速缓存也起到了调试助手的作用，帮助您跟踪没有完全清除的对象数量。通过查看动态堆栈返回踪迹和除没有清除的对象之外的签名，甚至能够找到确切的失败的调用者。<br><br>MP 堆<br>MP 堆是对多处理器友好的分布式分配的程序包，在 Win32 SDK（Windows NT 4.0 和更新版本）中可以得到。最初由 JVert 实现，此处堆抽象建立在 Win32 堆程序包的顶部。MP 堆创建多个 Win32 堆，并试图将分配调用分布到不同堆，以减少在所有单一锁上的竞争。<br><br>本程序包是好的步骤 —一种改进的 MP-友好的自定义堆分配程序。但是，它不提供语义信息和缺乏统计功能。通常将 MP 堆作为 SDK 库来使用。如果使用这个 SDK 创建可重用组件，您将大大受益。但是，如果在每个 DLL 中建立这个 SDK 库，将增加工作设置。<br><br>重新思考算法和数据结构<br>要在多处理器机器上伸缩，则算法、实现、数据结构和硬件必须动态伸缩。请看最经常分配和释放的数据结构。试问，“我能用不同的数据结构完成此工作吗？”例如，如果在应用程序初始化时加载了只读项的列表，这个列表不必是线性链接的列表。如果是动态分配的数组就非常好。动态分配的数组将减少内存中的堆块和碎片，从而增强性能。<br><br>减少需要的小对象的数量减少堆分配程序的负载。例如，我们在服务器的关键处理路径上使用五个不同的对象，每个对象单独分配和释放。一起高速缓存这些对象，把堆调用从五个减少到一个，显著减少了堆的负载，特别当每秒钟处理 1,000 个以上的请求时。<br><br>如果大量使用“Automation”结构，请考虑从主线代码中删除“Automation BSTR”，或至少避免重复的 BSTR 操作。（BSTR 连接导致过多的重分配和分配/释放操作。）<br><br>摘要<br>对所有平台往往都存在堆实现，因此有巨大的开销。每个单独代码都有特定的要求，但设计能采用本文讨论的基本理论来减少堆之间的相互作用。<br><br>评价您的代码中堆的使用。<br><br><br>改进您的代码，以使用较少的堆调用：分析关键路径和固定数据结构。<br><br><br>在实现自定义的包装程序之前使用量化堆调用成本的方法。<br><br><br>如果对性能不满意，请要求 OS 组改进堆。更多这类请求意味着对改进堆的更多关注。<br><br><br>要求 C 运行时组针对 OS 所提供的堆制作小巧的分配包装程序。随着 OS 堆的改进，C 运行时堆调用的成本将减小。<br><br><br>操作系统（Windows NT 家族）正在不断改进堆。请随时关注和利用这些改进。<br>Murali Krishnan 是 Internet Information Server (IIS) 组的首席软件设计工程师。从 1.0 版本开始他就设计 IIS，并成功发行了 1.0 版本到 4.0 版本。Murali 组织并领导 IIS 性能组三年 (1995-1998), 从一开始就影响 IIS 性能。他拥有威斯康星州 Madison 大学的 M.S.和印度 Anna 大学的 B.S.。工作之外，他喜欢阅读、打排球和家庭烹饪。<br><br><br><br>http://community.csdn.net/Expert/FAQ/FAQ_Index.asp?id=172835<br>我在学习对象的生存方式的时候见到一种是在堆栈(stack)之中，如下<br>CObject&nbsp; object;<br>还有一种是在堆(heap)中&nbsp; 如下<br>CObject*&nbsp; pobject="new"&nbsp; CObject();<br><br>请问<br>（1）这两种方式有什么区别？<br>（2）堆栈与堆有什么区别？？<br><br><br>---------------------------------------------------------------<br><br>1)&nbsp; about&nbsp; stack,&nbsp; system&nbsp; will&nbsp; allocate&nbsp; memory&nbsp; to&nbsp; the&nbsp; instance&nbsp; of&nbsp; object&nbsp; automatically,&nbsp; and&nbsp; to&nbsp; the<br>heap,&nbsp; you&nbsp; must&nbsp; allocate&nbsp; memory&nbsp; to&nbsp; the&nbsp; instance&nbsp; of&nbsp; object&nbsp; with&nbsp; new&nbsp; or&nbsp; malloc&nbsp; manually.<br>2)&nbsp; when&nbsp; function&nbsp; ends,&nbsp; system&nbsp; will&nbsp; automatically&nbsp; free&nbsp; the&nbsp; memory&nbsp; area&nbsp; of&nbsp; stack,&nbsp; but&nbsp; to&nbsp; the<br>heap,&nbsp; you&nbsp; must&nbsp; free&nbsp; the&nbsp; memory&nbsp; area&nbsp; manually&nbsp; with&nbsp; free&nbsp; or&nbsp; delete,&nbsp; else&nbsp; it&nbsp; will&nbsp; result&nbsp; in&nbsp; memory<br>leak.<br>3)栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。<br>4）堆上分配的内存可以有我们自己决定，使用非常灵活。</font></div>http://blog.ednchina.com/blog/levension/17759/message.aspx编程天地 软件开发Wed, 07 Mar 2007 14:01:24 GMThttp://blog.ednchina.com/blog/levension/17505/message.aspx<font size="2"><font color="#810081">函数可重入性及编写规范</font> </font> <div class="postText"> <p><font size="2">一、可重入函数<br>1）什么是可重入性？<br>可重入（reentrant）函数可以由多于一个任务并发使用，而不必担心数据错误。相反， 不可重入（non-reentrant）函数不能由超过一个任务所共享，除非能确保函数的互斥（或者使用信号量，或者在代码的关键部分禁用中断）。可重入函数可以在任意时刻被中断，稍后再继续运行，不会丢失数据。可重入函数要么使用本地变量，要么在使用全局变量时保护自己的数据。<br><br>2）可重入函数：<br>不为连续的调用持有静态数据。 <br>不返回指向静态数据的指针；所有数据都由函数的调用者提供。 <br>使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据。<br>如果必须访问全局变量，记住利用互斥信号量来保护全局变量。<br>绝不调用任何不可重入函数。<br><br>3）不可重入函数：<br>函数中使用了静态变量，无论是全局静态变量还是局部静态变量。 <br>函数返回静态变量。 <br>函数中调用了不可重入函数。<br>函数体内使用了静态的数据结构；<br>函数体内调用了malloc()或者free()函数；<br>函数体内调用了其他标准I/O函数。<br>函数是singleton中的成员函数而且使用了不使用线程独立存储的成员变量 。<br>总的来说，如果一个函数在重入条件下使用了未受保护的共享的资源，那么它是不可重入的。<br><br>4）示例<br>在多线程条件下，函数应当是线程安全的，进一步，更强的条件是可重入的。可重入函数保证了在多线程条件下，函数的状态不会出现错误。以下分别是一个不可重入和可重入函数的示例：<br>//c code<br>static int tmp;<br>void func1(int* x, int* y) {<br>&nbsp;&nbsp;&nbsp; tmp=*x; <br>&nbsp;&nbsp;&nbsp; *x=*y; <br>&nbsp;&nbsp;&nbsp; *y=tmp;<br>}<br>void func2(int* x, int* y) {<br>&nbsp;&nbsp;&nbsp; int tmp; <br>&nbsp;&nbsp;&nbsp; tmp=*x; <br>&nbsp;&nbsp;&nbsp; *x=*y; <br>&nbsp;&nbsp;&nbsp; *y=tmp;<br>}<br>func1是不可重入的，func2是可重入的。因为在多线程条件下，操作系统会在func1还没有执行完的情况下，切换到另一个线程中，那个线程可能再次调用func1，这样状态就错了。<br><br>二、函数编写规范<br>1 ：对所调用函数的错误返回码要仔细、全面地处理&nbsp;<br>&nbsp; <br>2 ：明确函数功能，精确（而不是近似）地实现函数设计&nbsp;<br>&nbsp; <br>3 ：编写可重入函数时，应注意局部变量的使用（如编写C/C++ 语言的可重入函数时，应使用auto 即缺省态局部变量或寄存器变量） <br>说明：编写C/C++语言的可重入函数时，不应使用static局部变量，否则必须经过特殊处理，才能使函数具有可重入性。<br>&nbsp; <br>4 ：编写可重入函数时，若使用全局变量，则应通过关中断、信号量（即P 、V 操作）等手段对其加以保护 <br>说明：若对所使用的全局变量不加以保护，则此函数就不具有可重入性，即当多个进程调用此函数时，很有可能使有关全局变量变为不可知状态。 <br>示例：假设Exam是int型全局变量，函数Squre_Exam返回Exam平方值。那么如下函数不具有可重入性。<br>unsigned int example( int para )<br>{<br>&nbsp;&nbsp;&nbsp; unsigned int temp;<br>&nbsp;&nbsp;&nbsp; Exam = para; // （**）<br>&nbsp;&nbsp;&nbsp; temp = Square_Exam( );<br>&nbsp;&nbsp;&nbsp; return temp;<br>}<br>此函数若被多个进程调用的话，其结果可能是未知的，因为当（**）语句刚执行完后，另外一个使用本函数的进程可能正好被激活，那么当新激活的进程执行到此函数时，将使Exam赋与另一个不同的para值，所以当控制重新回到“temp = Square_Exam( )”后，计算出的temp很可能不是预想中的结果。此函数应如下改进。<br>unsigned int example( int para )<br>{<br>&nbsp;&nbsp;&nbsp; unsigned int temp;<br>&nbsp;&nbsp;&nbsp; [申请信号量操作]&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 若申请不到“信号量”，说明另外的进程正处于<br>&nbsp;&nbsp;&nbsp; Exam = para;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 给Exam赋值并计算其平方过程中（即正在使用此<br>&nbsp;&nbsp;&nbsp; temp = Square_Exam( );&nbsp; // 信号），本进程必须等待其释放信号后，才可继<br>&nbsp;&nbsp;&nbsp; [释放信号量操作]&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 续执行。若申请到信号，则可继续执行，但其<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 它进程必须等待本进程释放信号量后，才能再使<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 用本信号。<br>&nbsp;&nbsp;&nbsp; return temp;<br>}<br>&nbsp; <br>5 ：在同一项目组应明确规定对接口函数参数的合法性检查应由函数的调用者负责还是由接口函数本身负责，缺省是由函数调用者负责 <br>说明：对于模块间接口函数的参数的合法性检查这一问题，往往有两个极端现象，即：要么是调用者和被调用者对参数均不作合法性检查，结果就遗漏了合法性检查这一必要的处理过程，造成问题隐患；要么就是调用者和被调用者均对参数进行合法性检查，这种情况虽不会造成问题，但产生了冗余代码，降低了效率。&nbsp;<br>&nbsp;&nbsp;<br>6 ：防止将函数的参数作为工作变量 <br>说明：将函数的参数作为工作变量，有可能错误地改变参数内容，所以很危险。对必须改变的参数，最好先用局部变量代之，最后再将该局部变量的内容赋给该参数。 <br>示例：如下函数的实现就不太好。 <br>void sum_data( unsigned int num, int *data, int *sum )<br>{<br>&nbsp;&nbsp;&nbsp; unsigned int count;<br>&nbsp;&nbsp;&nbsp; *sum = 0;<br>&nbsp; <br>&nbsp;&nbsp;&nbsp; for (count = 0; count &lt; num; count++)<br>&nbsp;&nbsp;&nbsp; {<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; *sum&nbsp; += data[count]; // sum成了工作变量，不太好。<br>&nbsp;&nbsp;&nbsp; }<br>}<br>若改为如下，则更好些。 <br>void sum_data( unsigned int num, int *data, int *sum )<br>{<br>&nbsp;&nbsp;&nbsp; unsigned int count ;<br>&nbsp;&nbsp;&nbsp; int sum_temp;<br>&nbsp;&nbsp;&nbsp; sum_temp = 0;<br>&nbsp; <br>&nbsp;&nbsp;&nbsp; for (count = 0; count &lt; num; count ++)<br>&nbsp;&nbsp;&nbsp; {<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; sum_temp&nbsp; += data[count]; <br>&nbsp;&nbsp;&nbsp; }<br>&nbsp; <br>&nbsp;&nbsp;&nbsp; *sum = sum_temp;<br>}<br>&nbsp;&nbsp;<br>7 ：函数的规模尽量限制在200 行以内 <br>说明：不包括注释和空格行。&nbsp;<br>8 ：一个函数仅完成一件功能&nbsp;<br><br>9 ：为简单功能编写函数 <br>说明：虽然为仅用一两行就可完成的功能去编函数好象没有必要，但用函数可使功能明确化，增加程序可读性，亦可方便维护、测试。 <br>示例：如下语句的功能不很明显。 <br>value = ( a &gt; b ) ? a : b ;<br>改为如下就很清晰了。 <br>&nbsp; <br>int max (int a, int b)<br>{<br>&nbsp;&nbsp;&nbsp; return ((a &gt; b) ? a : b);<br>}<br>&nbsp; <br>value = max (a, b);<br>&nbsp; <br>或改为如下。 <br>&nbsp; <br>#define MAX (a, b) (((a) &gt; (b)) ? (a) : (b))<br>&nbsp; <br>value = MAX (a, b);<br>&nbsp; <br>10：不要设计多用途面面俱到的函数 <br>说明：多功能集于一身的函数，很可能使函数的理解、测试、维护等变得困难。&nbsp;<br>&nbsp; <br>11：函数的功能应该是可以预测的，也就是只要输入数据相同就应产生同样的输出 <br>说明：带有内部“存储器”的函数的功能可能是不可预测的，因为它的输出可能取决于内部存储器（如某标记）的状态。这样的函数既不易于理解又不利于测试和维护。在C/C++语言中，函数的static局部变量是函数的内部存储器，有可能使函数的功能不可预测，然而，当某函数的返回值为指针类型时，则必须是STATIC的局部变量的地址作为返回值，若为AUTO类，则返回为错针。<br>示例：如下函数，其返回值（即功能）是不可预测的。 <br>&nbsp; <br>unsigned int integer_sum( unsigned int base )<br>{<br>&nbsp;&nbsp;&nbsp; unsigned int index;<br>&nbsp;&nbsp;&nbsp; static unsigned int sum = 0; // 注意，是static类型的。<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 若改为auto类型，则函数即变为可预测。<br>&nbsp;&nbsp;&nbsp; for (index = 1; index &lt;= base; index++)<br>&nbsp;&nbsp;&nbsp; {<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; sum += index;<br>&nbsp;&nbsp;&nbsp; }<br>&nbsp;&nbsp;&nbsp; return sum;<br>}<br>&nbsp;&nbsp;<br>12 ：尽量不要编写依赖于其他函数内部实现的函数 <br>说明：此条为函数独立性的基本要求。由于目前大部分高级语言都是结构化的，所以通过具体语言的语法要求与编译器功能，基本就可以防止这种情况发生。但在汇编语言中，由于其灵活性，很可能使函数出现这种情况。 <br>示例：如下是在DOS下TASM的汇编程序例子。过程Print_Msg的实现依赖于Input_Msg的具体实现，这种程序是非结构化的，难以维护、修改。<br>&nbsp; <br>...&nbsp; // 程序代码<br>proc Print_Msg // 过程（函数）Print_Msg<br>&nbsp;&nbsp;&nbsp; ...&nbsp; // 程序代码<br>&nbsp;&nbsp;&nbsp; jmp&nbsp; LABEL<br>&nbsp;&nbsp;&nbsp; ...&nbsp; // 程序代码<br>endp<br>&nbsp; <br>proc Input_Msg // 过程（函数）Input_Msg<br>&nbsp;&nbsp;&nbsp; ...&nbsp; // 程序代码<br>LABEL:<br>&nbsp;&nbsp;&nbsp; ...&nbsp; // 程序代码<br>endp<br><br>13&nbsp;：避免设计多参数函数，不使用的参数从接口中去掉 <br>说明：目的减少函数间接口的复杂度。&nbsp;<br>&nbsp;&nbsp;<br>14 ：非调度函数应减少或防止控制参数，尽量只使用数据参数 <br>说明：本建议目的是防止函数间的控制耦合。调度函数是指根据输入的消息类型或控制命令，来启动相应的功能实体（即函数或过程），而本身并不完成具体功能。控制参数是指改变函数功能行为的参数，即函数要根据此参数来决定具体怎样工作。非调度函数的控制参数增加了函数间的控制耦合，很可能使函数间的耦合度增大，并使函数的功能不唯一。 <br>示例：如下函数构造不太合理。 <br>int add_sub( int a, int b, unsigned char add_sub_flg )<br>{<br>&nbsp;&nbsp;&nbsp; if (add_sub_flg == INTEGER_ADD)<br>&nbsp;&nbsp;&nbsp; {<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return (a + b);<br>&nbsp;&nbsp;&nbsp; }<br>&nbsp;&nbsp;&nbsp; else<br>&nbsp;&nbsp;&nbsp; {<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return (a&nbsp; b);<br>&nbsp;&nbsp;&nbsp; }<br>}<br>不如分为如下两个函数清晰。 <br>int add( int a, int b )<br>{<br>&nbsp;&nbsp;&nbsp; return (a + b);<br>}<br>&nbsp; <br>int sub( int a, int b ) <br>{<br>&nbsp;&nbsp;&nbsp; return (a&nbsp; b);<br>}<br>15&nbsp;：检查函数所有参数输入的有效性&nbsp;<br>&nbsp; <br>16 ：检查函数所有非参数输入的有效性，如数据文件、公共变量等 <br>说明：函数的输入主要有两种：一种是参数输入；另一种是全局变量、数据文件的输入，即非参数输入。函数在使用输入之前，应进行必要的检查。&nbsp;<br>&nbsp;&nbsp;<br>17 ：函数名应准确描述函数的功能&nbsp;<br>&nbsp;&nbsp;<br>18 ：使用动宾词组为执行某操作的函数命名。如果是OOP 方法，可以只有动词（名词是对象本身） <br>示例：参照如下方式命名函数。 <br>void print_record( unsigned int rec_ind ) ;<br>int&nbsp; input_record( void ) ;<br>unsigned char get_current_color( void ) ;<br>&nbsp;&nbsp;<br>19 ：避免使用无意义或含义不清的动词为函数命名 <br>说明：避免用含义不清的动词如process、handle等为函数命名，因为这些动词并没有说明要具体做什么。<br>&nbsp;&nbsp;<br>20 ：函数的返回值要清楚、明了，让使用者不容易忽视错误情况 <br>说明：函数的每种出错返回值的意义要清晰、明了、准确，防止使用者误用、理解错误或忽视错误返回码。&nbsp;<br>&nbsp;&nbsp;<br>21 ：除非必要，最好不要把与函数返回值类型不同的变量，以编译系统默认的转换方式或强制的转换方式作为返回值返回&nbsp;<br>&nbsp;&nbsp;<br>22 ：让函数在调用点显得易懂、容易理解&nbsp;<br>&nbsp;&nbsp;<br>23 ：在调用函数填写参数时，应尽量减少没有必要的默认数据类型转换或强制数据类型转换 <br>说明：因为数据类型转换或多或少存在危险。&nbsp;<br>&nbsp;&nbsp;<br>24 ：避免函数中不必要语句，防止程序中的垃圾代码 <br>说明：程序中的垃圾代码不仅占用额外的空间，而且还常常影响程序的功能与性能，很可能给程序的测试、维护等造成不必要的麻烦。&nbsp;<br>&nbsp;&nbsp;<br>25 ：防止把没有关联的语句放到一个函数中 <br>说明：防止函数或过程内出现随机内聚。随机内聚是指将没有关联或关联很弱的语句放到同一个函数或过程中。随机内聚给函数或过程的维护、测试及以后的升级等造成了不便，同时也使函数或过程的功能不明确。使用随机内聚函数，常常容易出现在一种应用场合需要改进此函数，而另一种应用场合又不允许这种改进，从而陷入困境。 <br>在编程时，经常遇到在不同函数中使用相同的代码，许多开发人员都愿把这些代码提出来，并构成一个新函数。若这些代码关联较大并且是完成一个功能的，那么这种构造是合理的，否则这种构造将产生随机内聚的函数。 <br>示例：如下函数就是一种随机内聚。 <br>&nbsp; <br>void Init_Var( void )<br>{<br>&nbsp;&nbsp;&nbsp; Rect.length = 0;<br>&nbsp;&nbsp;&nbsp; Rect.width = 0; /* 初始化矩形的长与宽 */<br>&nbsp;&nbsp;&nbsp; Point.x = 10;<br>&nbsp;&nbsp;&nbsp; Point.y = 10;&nbsp;&nbsp; /* 初始化“点”的坐标 */<br>}<br>&nbsp; <br>矩形的长、宽与点的坐标基本没有任何关系，故以上函数是随机内聚。 <br>应如下分为两个函数： <br>void Init_Rect( void )<br>{<br>&nbsp;&nbsp;&nbsp; Rect.length = 0;<br>&nbsp;&nbsp;&nbsp; Rect.width = 0; /* 初始化矩形的长与宽 */<br>}<br>&nbsp; <br>void Init_Point( void )<br>{<br>&nbsp;&nbsp;&nbsp; Point.x = 10;<br>&nbsp;&nbsp;&nbsp; Point.y = 10;&nbsp;&nbsp; /* 初始化“点”的坐标 */<br>}<br>&nbsp; <br>26：如果多段代码重复做同一件事情，那么在函数的划分上可能存在问题 <br>说明：若此段代码各语句之间有实质性关联并且是完成同一件功能的，那么可考虑把此段代码构造成一个新的函数。&nbsp;<br>&nbsp; <br>27：功能不明确较小的函数，特别是仅有一个上级函数调用它时，应考虑把它合并到上级函数中，而不必单独存在 <br>说明：模块中函数划分的过多，一般会使函数间的接口变得复杂。所以过小的函数，特别是扇入很低的或功能不明确的函数，不值得单独存在。&nbsp;<br>&nbsp;&nbsp;<br>28 ：设计高扇入、合理扇出（小于7 ）的函数 <br>说明：扇出是指一个函数直接调用（控制）其它函数的数目，而扇入是指有多少上级函数调用它。 <br>扇出过大，表明函数过分复杂，需要控制和协调过多的下级函数；而扇出过小，如总是1，表明函数的调用层次可能过多，这样不利程序阅读和函数结构的分析，并且程序运行时会对系统资源如堆栈空间等造成压力。函数较合理的扇出（调度函数除外）通常是3-5。扇出太大，一般是由于缺乏中间层次，可适当增加中间层次的函数。扇出太小，可把下级函数进一步分解多个函数，或合并到上级函数中。当然分解或合并函数时，不能改变要实现的功能，也不能违背函数间的独立性。<br>扇入越大，表明使用此函数的上级函数越多，这样的函数使用效率高，但不能违背函数间的独立性而单纯地追求高扇入。公共模块中的函数及底层函数应该有较高的扇入。 <br>较良好的软件结构通常是顶层函数的扇出较高，中层函数的扇出较少，而底层函数则扇入到公共模块中。&nbsp;<br>&nbsp;&nbsp;<br>29 ：减少函数本身或函数间的递归调用 <br>说明：递归调用特别是函数间的递归调用（如A-&gt;B-&gt;C-&gt;A），影响程序的可理解性；递归调用一般都占用较多的系统资源（如栈空间）；递归调用对程序的测试有一定影响。故除非为某些算法或功能的实现方便，应减少没必要的递归调用。<br>&nbsp;&nbsp;<br>30 ：仔细分析模块的功能及性能需求，并进一步细分，同时若有必要画出有关数据流图，据此来进行模块的函数划分与组织 <br>说明：函数的划分与组织是模块的实现过程中很关键的步骤，如何划分出合理的函数结构，关系到模块的最终效率和可维护性、可测性等。根据模块的功能图或/及数据流图映射出函数结构是常用方法之一。<br>&nbsp;&nbsp;<br>31 ：改进模块中函数的结构，降低函数间的耦合度，并提高函数的独立性以及代码可读性、效率和可维护性 <br>优化函数结构时，要遵守以下原则： <br>（1）不能影响模块功能的实现。<br>（2）仔细考查模块或函数出错处理及模块的性能要求并进行完善。<br>（3）通过分解或合并函数来改进软件结构。<br>（4）考查函数的规模，过大的要进行分解。<br>（5）降低函数间接口的复杂度。<br>（6）不同层次的函数调用要有较合理的扇入、扇出。<br>（7）函数功能应可预测。<br>（8）提高函数内聚。（单一功能的函数内聚最高）<br>说明：对初步划分后的函数结构应进行改进、优化，使之更为合理。&nbsp;<br>&nbsp;&nbsp;<br>32 ：在多任务操作系统的环境下编程，要注意函数可重入性的构造 <br>说明：可重入性是指函数可以被多个任务进程调用。在多任务操作系统中，函数是否具有可重入性是非常重要的，因为这是多个进程可以共用此函数的必要条件。另外，编译器是否提供可重入函数库，与它所服务的操作系统有关，只有操作系统是多任务时，编译器才有可能提供可重入函数库。如DOS下BC和MSC等就不具备可重入函数库，因为DOS是单用户单任务操作系统。<br>&nbsp;&nbsp;<br>33 ：避免使用BOOL 参数 <br>说明：原因有二，其一是BOOL参数值无意义，TURE/FALSE的含义是非常模糊的，在调用时很难知道该参数到底传达的是什么意思；其二是BOOL参数值不利于扩充。还有NULL也是一个无意义的单词。<br>&nbsp;&nbsp;<br>34 ： 对于提供了返回值的函数，在引用时最好使用其返回值&nbsp;<br>&nbsp;&nbsp;<br>35 ：当一个过程（函数）中对较长变量（一般是结构的成员）有较多引用时，可以用一个意义相当的宏代替 <br>说明：这样可以增加编程效率和程序的可读性。 <br>示例：在某过程中较多引用TheReceiveBuffer[FirstSocket].byDataPtr，<br>则可以通过以下宏定义来代替： <br># define pSOCKDATA TheReceiveBuffer[FirstScoket].byDataPtr</font></p><font size="2"> <p style="TEXT-INDENT: 2em">一个函数如果满足以及下条件之一，那么它是不可重入的： </p> <ul> <li>函数中使用了静态变量，无论是全局静态变量还是局部静态变量。 <li>函数返回静态变量。 <li>函数中调用了不可重入函数。 <li>函数是singleton中的成员函数而且使用了不使用线程独立存储的成员变量</li></ul> <p style="TEXT-INDENT: 2em">总的来说，如果一个函数在重入条件下使用了未受保护的共享的资源，那么它是不可重入的</p> <p><a name="2"><span class="atitle2">什么是可重入性？</span></a><br><em xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">可重入（reentrant）</em>函数可以由多于一个任务并发使用，而不必担心数据错误。相反， <em xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">不可重入（non-reentrant）</em>函数不能由超过一个任务所共享，除非能确保函数的互斥（或者使用信号量，或者在代码的关键部分禁用中断）。可重入函数可以在任意时刻被中断，稍后再继续运行，不会丢失数据。可重入函数要么使用本地变量，要么在使用全局变量时保护自己的数据。</p> <p>可重入函数： </p> <ul xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <li>不为连续的调用持有静态数据。 <li>不返回指向静态数据的指针；所有数据都由函数的调用者提供。 <li>使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据。 <li>绝不调用任何不可重入函数。 </li></ul></font> <p><font size="2"></font>&nbsp;</p></div>http://blog.ednchina.com/blog/levension/17505/message.aspx编程天地 软件开发Wed, 07 Mar 2007 13:59:08 GMThttp://blog.ednchina.com/blog/levension/17504/message.aspx<table align="center"> <tbody> <tr> <td class="title" align="middle">使用可重入函数进行更安全的信号处理</td></tr> <tr> <td align="middle">&nbsp;</td></tr> <tr> <td align="left">&nbsp;</td></tr> <tr> <td> <blockquote>如果要对函数进行并发访问，不管是通过<a href="http://www.itisedu.com/phrase/200603091754305.html" target=_new>线程</a>还是通过进程，您都可能会遇到函数不可重入所导致的问题。在本文中，通过示例代码了解如果可重入性不能得到保证会产生何种异常，尤其要注意信号。引入了五条可取的编程经验，并对提出的编译器模型进行了讨论，在这个模型中，可重入性由编译器前端处理。</blockquote> <p>在早期的编程中，不可重入性对<a href="http://www.itisedu.com/phrase/200604232224305.html" target=_new>程序</a>员并不构成威胁；函数不会有并发访问，也没有中断。在很多较老的 C 语言实现中，函数被认为是在单线程进程的环境中运行。</p> <p>不过，现在，并发编程已普遍使用，您需要意识到这个缺陷。本文描述了在并行和并发<a href="http://www.itisedu.com/phrase/200602281641255.html" target=_new>程序设计</a>中函数的不可重入性导致的一些潜在问题。信号的生成和处理尤其增加了额外的复杂性。由于信号在本质上是异步的，所以难以找出当信号处理函数触发某个不可重入函数时导致的 bug。</p> <p>本文： </p> <ul xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <li>定义了可重入性，并包含一个可重入函数的 P<a href="http://www.itisedu.com/phrase/200604232131175.html" target=_new>OS</a>IX 清单。 <li>给出了示例，以说明不可重入性所导致的问题。 <li>指出了确保底层函数的可重入性的方法。 <li>讨论了在编译器层次上对可重入性的处理。</li></ul> <p><a name="2"><span class="atitle2">什么是可重入性？</span></a><br><i xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">可重入（reentrant）</i>函数可以由多于一个任务并发使用，而不必担心数据错误。相反， <i xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">不可重入（non-reentrant）</i>函数不能由超过一个任务所共享，除非能确保函数的互斥（或者使用信号量，或者在代码的关键部分禁用中断）。可重入函数可以在任意时刻被中断，稍后再继续运行，不会丢失数据。可重入函数要么使用本地变量，要么在使用全局变量时保护自己的数据。</p> <p>可重入函数： </p> <ul xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <li>不为连续的调用持有静态数据。 <li>不返回指向静态数据的指针；所有数据都由函数的调用者提供。 <li>使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据。 <li>绝不调用任何不可重入函数。</li></ul> <p>不要混淆可重入与线程安全。在程序员看来，这是两个独立的概念：函数可以是可重入的，是线程安全的，或者二者皆是，或者二者皆非。不可重入的函数不能由多个线程使用。另外，或许不可能让某个不可重入的函数是线程安全的。</p> <p>IEEE <a href="http://www.itisedu.com/phrase/200604231411575.html" target=_new>ST</a>d 1003.1 列出了 118 个可重入的 UNIX? 函数，在此没有给出副本。参见 <a href="http://www-900.ibm.com/developerworks/cn/linux/l-reent.shtml#resources" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">参考资料</a> 中指向 unix.org 上此列表的链接。</p> <p>出于以下任意某个原因，其余函数是不可重入的：</p> <ul xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"> <li>它们调用了 <code><font face="NSimsun">malloc</font></code> 或 <code><font face="NSimsun">free</font></code>。 <li>众所周知它们使用了静态数据结构体。 <li>它们是标准 I/O 程序库的一部分。</li></ul> <p><a name="3"><span class="atitle2">信号和不可重入函数</span></a><br><i xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">信号（signal）</i> 是<a href="http://www.itisedu.com/phrase/200604232134205.html" target=_new>软件</a>中断。它使得程序员可以处理异步事件。为了向进程发送一个信号，内核在进程表条目的信号域中设置一个位，对应于收到的信号的<a href="http://www.itisedu.com/phrase/200603051002565.html" target=_new>类型</a>。信号函数的 ANSI C 原型是：</p> <table cellSpacing="0" cellPadding="5" bgColor="#cccccc" border="1"> <tbody> <tr> <td><pre><code><br>void (*signal (int sigNum, void (*sigHandler)(int))) (int);<br></code></pre></td></tr></tbody></table> <p>或者，另一种描述形式：</p> <table cellSpacing="0" cellPadding="5" bgColor="#cccccc" border="1"> <tbody> <tr> <td><pre><code><br><a href="http://www.itisedu.com/phrase/200604231258125.html" target=_new>type</a>def void sigHandler(int);<br>SigHandler *signal(int, sigHandler *);<br></code></pre></td></tr></tbody></table> <p>当进程处理所捕获的信号时，正在执行的正常指令序列就会被信号处理器临时中断。然后进程继续执行，但现在执行的是信号处理器中的指令。如果信号处理器返回，则进程继续执行信号被捕获时正在执行的正常的指令序列。</p> <p>现在，在信号处理器中您并不知道信号被捕获时进程正在执行什么内容。如果当进程正在使用 <code><font face="NSimsun">malloc</font></code> 在它的堆上分配额外的内存时，您通过信号处理器调用 <code><font face="NSimsun">malloc</font></code>，那会怎样？或者，调用了正在处理全局数据结构的某个函数，而在信号处理器中又调用了同一个函数。如果是调用 <code><font face="NSimsun">malloc</font></code>，则进程会被严重破坏，因为 <code><font face="NSimsun">malloc</font></code> 通常会为所有它所分配的区域维持一个链表，而它又可能正在修改那个链表。</p> <p>甚至可以在需要多个指令的 C 操作符开始和结束之间发送中断。在程序员看来，指令可能似乎是原子的（也就是说，不能被分割为更小的操作），但它可能实际上需要不止一个处理器指令才能完成操作。例如，看这段 C 代码：</p> <table cellSpacing="0" cellPadding="5" bgColor="#cccccc" border="1"> <tbody> <tr> <td><pre><code><br>temp += 1;<br></code></pre></td></tr></tbody></table> <p>在 x86 处理器上，那个语句可能会被编译为：</p> <table cellSpacing="0" cellPadding="5" bgColor="#cccccc" border="1"> <tbody> <tr> <td><pre><code><br>mov ax,[temp]<br>inc ax<br>mov [temp],ax<br></code></pre></td></tr></tbody></table> <p>这显然不是一个原子操作。</p> <p>这个例子展示了在修改某个变量的过程中运行信号处理器可能会发生什么事情：</p><a name="IDAYSGW"><b>清单 1. 在修改某个变量的同时运行信号处理器</b></a><br> <table cellSpacing="0" cellPadding="5" bgColor="#cccccc" border="1"> <tbody> <tr> <td><pre><code><br>#include <signal.H><br>#include <stdio.H><br><br>struct two_int { int a, b; } data;<br><br>void signal_handler(int signum){<br> printf ("%d, %d ", data.a, data.b);<br> alarm (1);<br>}<br><br>int m<a href="http://www.itisedu.com/phrase/200604230831275.html" target=_new>AI</a>n (void){<br> static struct two_int zeros = { 0, 0 }, on<a href="http://www.itisedu.com/phrase/200604231411155.html" target=_new>ES</a> = { 1, 1 };<br><br> signal (SI<a href="http://www.itisedu.com/phrase/200604230903435.html" target=_new>GA</a>LRM, signal_handler);<br><br> data = zeros;<br><br> alarm (1);<br><br>while (1)<br> {data = zeros; data = ones;}<br>}<br></code></pre></td></tr></tbody></table> <p>这个程序向 <code><font face="NSimsun">data</font></code> 填充 0，1，0，1，一直交替进行。同时，alarm 信号处理器每一秒打印一次当前内容（在处理器中调用 <code><font face="NSimsun">printf</font></code> 是安全的，当信号发生时它确实没有在处理器外部被调用）。您预期这个程序会有怎样的输出？它应该打印 0,0 或者 1,1。但是实际的输出如下所示：</p> <table cellSpacing="0" cellPadding="5" bgColor="#cccccc" border="1"> <tbody> <tr> <td><pre><code><br>0, 0<br>1, 1<br><br>(Skipping some output...)<br><br>0, 1<br>1, 1<br>1, 0<br>1, 0<br>...<br></code></pre></td></tr></tbody></table> <p>在大部分机器上，在 <code><font face="NSimsun">data</font></code> 中存储一个新值都需要若干个指令，每次存储一个字。如果在这些指令期间发出信号，则处理器可能发现 <code><font face="NSimsun">data.a</font></code> 为 0 而 <code><font face="NSimsun">data.b</font></code> 为 1，或者反之。另一方面，如果我们运行代码的机器能够在一个不可中断的指令中存储一个<a href="http://www.itisedu.com/phrase/200603090845215.html" target=_new>对象</a>的值，那么处理器将永远打印 0,0 或 1,1。 </p> <p>使用信号的另一个新增的困难是，只通过运行<a href="http://www.itisedu.com/phrase/200603291707535.html" target=_new>测试用例</a>不能够确保代码没有信号 bug。这一困难的原因在于信号生成本质上异步的。</p> <p><a name="4"><span class="atitle2">不可重入函数和静态变量</span></a><br>假定信号处理器使用了不可重入的 <code><font face="NSimsun">gethostbyn</font><a href="http://www.itisedu.com/phrase/200603091620485.html" target=_new><font face="NSimsun">AM</font></a><font face="NSimsun">e</font></code>。这个函数将它的值返回到一个静态对象中：</p> <table cellSpacing="0" cellPadding="5" bgColor="#cccccc" border="1"> <tbody> <tr> <td><pre><code><br>static struct hostent host; /* result stored here*/<br></code></pre></td></tr></tbody></table> <p>它每次都重新使用同一个对象。在下面的例子中，如果信号刚好是在 <code><font face="NSimsun">main</font></code> 中调用 <code><font face="NSimsun">gethostbyname</font></code> 期间到达，或者甚至在调用之后到达，而程序仍然在使用那个值，则它将破坏程序请求的值。</p><a name="IDAFSGW"><b>清单 2. gethostbyname 的危险用法</b></a><br> <table cellSpacing="0" cellPadding="5" bgColor="#cccccc" border="1"> <tbody> <tr> <td><pre><code><br>main(){<br> struct hostent *hostPtr;<br> ...<br> signal(SIGALRM, sig_handler);<br> ...<br> hostPtr = gethostbyname(hostNameOne);<br> ...<br>}<br><br>void sig_handler(){<br> struct hostent *hostPtr;<br> ...<br> /* call to gethostbyname may clobber the value stored during the call<br> ins<a href="http://www.itisedu.com/phrase/200604261459505.html" target=_new>IDE</a> the main() */<br> hostPtr = gethostbyname(hostNameTwo);<br> ...<br>}<br></code></pre></td></tr></tbody></table> <p>不过，如果程序不使用 <code><font face="NSimsun">gethostbyname</font></code> 或者任何其他在同一对象中返回信息的函数，或者如果它每次使用时都会阻塞信号，那么就是安全的。 </p> <p>很多库函数在固定的对象中返回值，总是使用同一对象，它们全都会导致相同的问题。如果某个函数使用并修改了您提供的某个对象，那它可能就是不可重入的；如果两个调用使用同一对象，那么它们会相互干扰。</p> <p>当使用流（stream）进行 I/O 时会出现<a href="http://www.itisedu.com/phrase/200603090857555.html" target=_new>类</a>似的情况。假定信号处理器使用 <code><font face="NSimsun">fprintf</font></code> 打印一条<a href="http://www.itisedu.com/phrase/200603090938465.html" target=_new>消息</a>，而当信号发出时程序正在使用同一个流进行 <code><font face="NSimsun">fprintf</font></code> 调用。信号处理器的消息和程序的数据都会被破坏，因为两个调用操作了同一数据结构：流本身。</p> <p>如果使用第三方程序库，事情会变得更为复杂，因为您永远不知道哪部分程序库是可重入的，哪部分是不可重入的。对标准程序库而言，有很多程序库函数在固定的对象中返回值，总是重复使用同一对象，这就使得那些函数不可重入。</p> <p>近来很多提供商已经开始提供标准 C 程序库的可重入版本，这是一个好消息。对于任何给定程序库，您都应该通读它所提供的文档，以了解其原型和标准库函数的用法是否有所变化。</p> <p><a name="5"><span class="atitle2">确保可重入性的经验</span></a><br>理解这五条最好的经验将帮助您保持程序的可重入性。</p> <p><a name="IDACP0V"><span class="atitle3">经验 1</span></a><br>返回指向静态数据的指针可能会导致函数不可重入。例如，将字符串转换为大写的 <code><font face="NSimsun">strToUpper</font></code> 函数可能被实现如下：</p><a name="IDARP0V"><b>清单 3. strToUpper 的不可重入版本</b></a><br> <table cellSpacing="0" cellPadding="5" bgColor="#cccccc" border="1"> <tbody> <tr> <td><pre><code><br>char *strToUpper(char *str)<br>{<br> /*Returning pointer to static data makes it non-reentrant */<br> static char buffer[STRING_SIZE_LIMIT];<br> int index;<br><br> for (index = 0; str[index]; index++)<br> buffer[index] = toupper(str[index]);<br> buffer[index] = '</code></pre></td></tr></tbody></table> <p>&nbsp;</p></td></tr></tbody></table>http://blog.ednchina.com/blog/levension/17504/message.aspx编程天地 软件开发Fri, 02 Mar 2007 10:22:09 GMThttp://blog.ednchina.com/blog/levension/17084/message.aspx<div style="MARGIN-LEFT: 100px"> <div class="article"_title><font size="2">C语言中的指针和内存泄漏 </font></div> <div class="article"_content> <table style="TABLE-LAYOUT: fixed" border="0"> <tbody> <tr> <td><font size="2">在使用 C 语言时，您是否对花时间调试指针和内存泄漏问题感到厌倦？如果是这样，那么本文就适合您。您将了解可能导致内存破坏的指针操作类型，您还将研究一些场景，了解要在使用动态内存分配时考虑什么问题。 <br>引言 <br><br>对于任何使用 C 语言的人，如果问他们 C 语言的最大烦恼是什么，其中许多人可能会回答说是指针和内存泄漏。这些的确是消耗了开发人员大多数调试时间的事项。指针和内存泄漏对某些开发人员来说似乎令人畏惧，但是一旦您了解了指针及其关联内存操作的基础，它们就是您在 C 语言中拥有的最强大工具。 <br><br>本文将与您分享开发人员在开始使用指针来编程前应该知道的秘密。本文内容包括： <br><br>导致内存破坏的指针操作类型 <br>在使用动态内存分配时必须考虑的检查点 <br>导致内存泄漏的场景 <br>如果您预先知道什么地方可能出错，那么您就能够小心避免陷阱，并消除大多数与指针和内存相关的问题。 <br>什么地方可能出错？ <br><br>有几种问题场景可能会出现，从而可能在完成生成后导致问题。在处理指针时，您可以使用本文中的信息来避免许多问题。 <br><br>未初始化的内存 <br><br>在本例中，p 已被分配了 10 个字节。这 10 个字节可能包含垃圾数据，如图 1 所示。 <br><br>char *p = malloc ( 10 ); <br><br>图 1. 垃圾数据 <br><br></font><a href="http://bbs.csai.cn/bbs/Uploadfiles/2006-11/1124_349592.gif" target=_blank><font size="2"><img alt="" src="http://bbs.csai.cn/bbs/Uploadfiles/2006-11/1124_349592.gif" target="_blank"><img alt="" src="http://bbs.csai.cn/bbs/Uploadfiles/2006-11/1124_532954.gif" target="_blank"><img alt="" src="http://bbs.csai.cn/bbs/Uploadfiles/2006-11/1124_295182.gif" target="_blank"><img alt="" src="http://bbs.csai.cn/bbs/Uploadfiles/2006-11/1124_538282.gif" target="_blank"><img alt="" src="http://bbs.csai.cn/bbs/Uploadfiles/2006-11/1124_503332.gif" target="_blank"><img alt="" src="http://bbs.csai.cn/bbs/Uploadfiles/2006-11/1124_478530.gif" border="0" (this);></font></a><br><br><font size="2">图 6. 动态分配的内存 <br><br>free(memoryArea) <br><br>如果通过调用 free 来释放了 memoryArea，则 newArea 指针也会因此而变得无效。newArea 以前所指向的内存位置无法释放，因为已经没有指向该位置的指针。换句话说，newArea 所指向的内存位置变为了孤立的，从而导致了内存泄漏。 <br><br>每当释放结构化的元素，而该元素又包含指向动态分配的内存位置的指针时，应首先遍历子内存位置（在此例中为 newArea），并从那里开始释放，然后再遍历回父节点。 <br><br>这里的正确实现应该为： <br><br>free( memoryArea-&gt;newArea); <br>free(memoryArea); <br><br><br>返回值的不正确处理 <br>有时，某些函数会返回对动态分配的内存的引用。跟踪该内存位置并正确地处理它就成为了 calling 函数的职责。 <br><br>char *func ( ) <br>{ <br>return malloc(20); // make sure to memset this location to ‘\0’… <br>} <br><br>void callingFunc ( ) <br>{ <br>func ( ); // Problem lies here <br>} <br><br>在上面的示例中，callingFunc() 函数中对 func() 函数的调用未处理该内存位置的返回地址。结果，func() 函数所分配的 20 个字节的块就丢失了，并导致了内存泄漏。 <br><br>归还您所获得的 <br><br>在开发组件时，可能存在大量的动态内存分配。您可能会忘了跟踪所有指针（指向这些内存位置），并且某些内存段没有释放，还保持分配给该程序。 <br><br>始终要跟踪所有内存分配，并在任何适当的时候释放它们。事实上，可以开发某种机制来跟踪这些分配，比如在链表节点本身中保留一个计数器（但您还必须考虑该机制的额外开销）。 <br><br>访问空指针 <br><br>访问空指针是非常危险的，因为它可能使您的程序崩溃。始终要确保您不是 在访问空指针。 <br><br>总结 <br><br>本文讨论了几种在使用动态内存分配时可以避免的陷阱。要避免内存相关的问题，良好的实践是： <br><br>始终结合使用 memset 和 malloc，或始终使用 calloc。 <br>每当向指针写入值时，都要确保对可用字节数和所写入的字节数进行交叉核对。 <br>在对指针赋值前，要确保没有内存位置会变为孤立的。 <br>每当释放结构化的元素（而该元素又包含指向动态分配的内存位置的指针）时，都应首先遍历子内存位置并从那里开始释放，然后再遍历回父节点。 <br>始终正确处理返回动态分配的内存引用的函数返回值。 <br>每个 malloc 都要有一个对应的 free。 <br>确保您不是在访问空指针。</font></td></tr></tbody></table></div></div>http://blog.ednchina.com/blog/levension/17084/message.aspx编程天地 软件开发