1、什么是const?

常类型是指使用类型修饰符const说明的类型，常类型的变量或对象的值是不能被更新的。（当然，我们可以偷梁换柱进行更新：）

2、为什么引入const？

　 const 推出的初始目的，正是为了取代预编译指令，消除它的缺点，同时继承它的优点。

3、cons有什么主要的作用？

（1）可以定义const常量，具有不可变性。

例如：

const int Max="100";

int Array[Max];

（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。

例如：

void f(const int i) { .........}

编译器就会知道i是一个常量，不允许修改；

（3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。

同宏定义一样，可以做到不变则已，一变都变！如（1）中，如果想修改Max的内容，只需要：const int Max="you" want;即可！

（4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。

还是上面的例子，如果在函数体内修改了i，编译器就会报错；

例如：

void f(const int i) { i="10";//error! }

(5) 为函数重载提供了一个参考。

class A

{

......

void f(int i) {......} //一个函数

void f(int i) const {......} //上一个函数的重载

......

};

(6) 可以节省空间，避免不必要的内存分配。

例如：

#define PI 3.14159 //常量宏

const doulbe Pi="3".14159; //此时并未将Pi放入ROM中

......

double i="Pi"; //此时为Pi分配内存，以后不再分配！

double I="PI"; //编译期间进行宏替换，分配内存

double j="Pi"; //没有内存分配

double J="PI"; //再进行宏替换，又一次分配内存！

const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过

程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。

（7） 提高了效率。

编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，

使得它的效率也很高。

3、如何使用const？

（1）修饰一般常量

　　 一般常量是指简单类型的常量。这种常量在定义时，修饰符const可以用在类型说明符前，也可以用在类型说明符后。

例如：

int const x="2";　　或　　const int x="2";

（2）修饰常数组

　　 定义或说明一个常数组可采用如下格式：

　　 int const a[5]={1, 2, 3, 4, 5};　

const int a[5]={1, 2, 3, 4, 5};

（3）修饰常对象

　常对象是指对象常量，定义格式如下：

class A;

　　 const A a;

A const a;

　　 定义常对象时，同样要进行初始化，并且该对象不能再被更新，修饰符const可以放在类名后面，也可以放在类名前面。　

（4）修饰常指针

const int *A;    //const/修饰指向的对象，A可变，A指向的对象不可变

int const *A; 　 //const修饰指向的对象，A可变，A指向的对象不可变

int *const A;    //const修饰指针A， A不可变，A指向的对象可变

const int *const A; //指针A和A指向的对象都不可变

（5）修饰常引用

　使用const修饰符也可以说明引用，被说明的引用为常引用，该引用所引用的对象不能被更新。其定义格式如下：

　　 const double & v;

　 （6）修饰函数的常参数

const修饰符也可以修饰函数的传递参数，格式如下：

void Fun(const int Var);

告诉编译器Var在函数体中的无法改变，从而防止了使用者的一些无意的或错误的修改。

（7）修饰函数的返回值：

const修饰符也可以修饰函数的返回值，是返回值不可被改变，格式如下：

const int Fun1();

const MyClass Fun2();

（8）修饰类的成员函数：

const修饰符也可以修饰类的成员函数，格式如下：

class ClassName

{

public:

　 　int Fun() const;

　 .....

}；

这样，在调用函数Fun时就不能修改类里面的数据

（9）在另一连接文件中引用const常量

extern const int i; //正确的引用

extern const int j="10"; //错误！常量不可以被再次赋值

另外，还要注意，常量必须初始化！

例如：

const int i="5";

4、几点值得讨论的地方：

（1）const究竟意味着什么？

说了这么多，你认为const意味着什么？一种修饰符？接口抽象？一种新类型？

也许都是，在Stroustup最初引入这个关键字时，只是为对象放入ROM做出了一种可能，对于const对象，C++既允许对其进行静态初始化，也允

许对他进行动态初始化。理想的const对象应该在其构造函数完成之前都是可写的，在析够函数执行开始后也都是可写的，换句话说，const对

象具有从构造函数完成到析够函数执行之前的不变性，如果违反了这条规则，结果都是未定义的！虽然我们把const放入ROM中，但这并不能够

保证const的任何形式的堕落，我们后面会给出具体的办法。无论const对象被放入ROM中，还是通过存储保护机制加以保护，都只能保证，对于

用户而言这个对象没有改变。

（2）位元const V.S. 抽象const?

对于关键字const的解释有好几种方式，最常见的就是位元const 和 抽象const。下面我们看一个例子：

class A

{

public:

......

A f(const A& a);

......

};

如果采用抽象const进行解释，那就是f函数不会去改变所引用对象的抽象值，如果采用位元const进行解释，那就成了f函数不会去改变所引用

对象的任何位元。

我们可以看到位元解释正是c++对const问题的定义，const成员函数不被允许修改它所在对象的任何一个数据成员。

为什么这样呢？因为使用位元const有2个好处：

最大的好处是可以很容易地检测到违反位元const规定的事件：编译器只用去寻找有没有对数据成员的赋值就可以了。另外，如果我们采用了位

元const，那么，对于一些比较简单的const对象，我们就可以把它安全的放入ROM中，对于一些程序而言，这无疑是一个很重要的优化方式。

当然，位元const也有缺点，要不然，抽象const也就没有产生的必要了。

首先，位元const的抽象性比抽象const的级别更低！实际上，大家都知道，一个库接口的抽象性级别越低，使用这个库就越困难。

其次，使用位元const的库接口会暴露库的一些实现细节，而这往往会带来一些负面效应。所以，在库接口和程序实现细节上，我们都应该采用

抽象const。

有时，我们可能希望对const做出一些其它的解释，那么，就要注意了，目前，大多数对const的解释都是类型不安全的，这里我们就不举例子

了，你可以自己考虑一下，总之，我们尽量避免对const的重新解释。

（3）放在类内部的常量有什么限制？

看看下面这个例子：

class A

{

private:

const int c3 = 7; // ???

static int c4 = 7; // ???

static const float c5 = 7; // ???

......

};

你认为上面的3句对吗？呵呵，都不对！使用这种类内部的初始化语法的时候，常量必须是被一个常量表达式初始化的整型或枚举类型，而且必

须是static和const形式。这显然是一个很严重的限制！

那么，我们的标准委员会为什么做这样的规定呢？一般来说，类在一个头文件中被声明，而头文件被包含到许多互相调用的单元去。但是，为

了避免复杂的编译器规则，C++要求每一个对象只有一个单独的定义。如果C++允许在类内部定义一个和对象一样占据内存的实体的话，这种规

则就被破坏了。

（4）如何初始化类内部的常量？

一种方法就是static 和 const 并用，在内部初始化，如上面的例子；

另一个很常见的方法就是初始化列表：

class A

{

public:

A(int i="0"):test(i) {}

private:

const int test;

}；

还有一种方式就是在外部初始化，例如：

class A

{

public:

A() {}

private:

static const int i; //注意必须是静态的！

}；

const int A::i=3;

（5）常量与数组的组合有什么特殊吗？

我们给出下面的代码：

const int size[3]={10,20,50};

int array];

有什么问题吗？对了，编译通不过！为什么呢？

const可以用于集合，但编译器不能把一个集合存放在它的符号表里，所以必须分配内存。在这种情况下，const意味着“不能改变的一块存储

”。然而，其值在编译时不能被使用，因为编译器在编译时不需要知道存储的内容。自然，作为数组的大小就不行了：）

（6）this指针是不是const类型的？

this指针是一个很重要的概念，那该如何理解她呢？也许这个话题太大了，那我们缩小一些：this指针是个什么类型的？这要看具体情况：如

果在非const成员函数中，this指针只是一个类类型的；如果在const成员函数中，this指针是一个const类类型的；如果在volatile成员函数中

,this指针就是一个volatile类类型的。

（7）const到底是不是一个重载的参考对象？

先看一下下面的例子：

class A

{

......

void f(int i) {......} //一个函数

void f(int i) const {......} //上一个函数的重载

......

};

上面是重载是没有问题的了，那么下面的呢？

class A

{

......

void f(int i) {......} //一个函数

void f(const int i) {......} //？？？？？/

......

};

这个是错误的，编译通不过。那么是不是说明内部参数的const不予重载呢？再看下面的例子：

class A

{

......

void f(int& ) {......} //一个函数

void f(const int& ) {......}//？？？？？/

......

};

这个程序是正确的，看来上面的结论是错误的。为什么会这样呢？这要涉及到接口的透明度问题。按值传递时，对用户而言，这是透明的，用

户不知道函数对形参做了什么手脚，在这种情况下进行重载是没有意义的，所以规定不能重载！当指针或引用被引入时，用户就会对函数的操

作有了一定的了解，不再是透明的了，这时重载是有意义的，所以规定可以重载。

（8）什么情况下为const分配内存？

以下是我想到的可能情况，当然，有的编译器进行了优化，可能不分配内存。

A、作为非静态的类成员时；

B、用于集合时；

C、被取地址时；

D、在main函数体内部通过函数来获得值时；

E、const的 class或struct有用户定义的构造函数、析构函数或基类时；。

F、当const的长度比计算机字长还长时；

G、参数中的const；

H、使用了extern时。

不知道还有没有其他情况，欢迎高手指点：）

（9）临时变量到底是不是常量？

很多情况下，编译器必须建立临时对象。像其他任何对象一样，它们需要存储空间而且必须被构造和删除。区别是我们从来看不到编译器负责

决定它们的去留以及它们存在的细节。对于C++标准草案而言：临时对象自动地成为常量。因为我们通常接触不到临时对象，不能使用与之相关

的信息，所以告诉临时对象做一些改变有可能会出错。当然，这与编译器有关，例如：vc6、vc7都对此作了扩展，所以，用临时对象做左值，

编译器并没有报错。

（10）与static搭配会不会有问题？

假设有一个类：

class A

{

public:

......

static void f() const { ......}

......

};

我们发现编译器会报错，因为在这种情况下static不能够与const共存！

为什么呢？因为static没有this指针，但是const修饰this指针，所以...

（11）如何修改常量？

有时候我们却不得不对类内的数据进行修改，但是我们的接口却被声明了const，那该怎么处理呢？我对这个问题的看法如下：

1）标准用法：mutable

class A

{

public:

A(int i="0"):test(i) { }

void Setvalue(int i)const { test="i"; }

private:

mutable int test;//这里处理！

}；

2）强制转换：const_cast

class A

{

public:

A(int i="0"):test(i) { }

void Setvalue(int i)const

{ const_cast <int>(test)=i; }//这里处理！

private:

int test;

}；

3）灵活的指针：int*

class A

{

public:

A(int i="0"):test(i) { }

void Setvalue(int i)const

{ *test=i; }

private:

int* test; //这里处理！

}；

4）未定义的处理

class A

{

public:

A(int i="0"):test(i) { }

void Setvalue(int i)const

{ int *p=(int*)&test; *p=i; }//这里处理！

private:

int test;

}；

注意，这里虽然说可以这样修改，但结果是未定义的，避免使用！

5）内部处理：this指针

class A

{

public:

A(int i="0"):test(i) { }

void Setvalue(int i)const

{ ((A*)this)->test=i; }//这里处理！

private:

int test;

}；

6）最另类的处理：空间布局

class A

{

public:

A(int i="0"):test(i),c('a') { }

private:

char c;

const int test;

};

int main()

{

A a(3);

A* pa=&a;

char* p=(char*)pa;

int* pi=(int*)(p+4）；//利用边缘调整

*pi=5; file://此处改变了test的值！

return 0;

}

虽然我给出了6中方法，但是我只是想说明如何更改，但出了第一种用法之外，另外5种用法，我们并不提倡，

（12）最后我们来讨论一下常量对象的动态创建。

既然编译器可以动态初始化常量，就自然可以动态创建，例如：

const int* pi="new" const int(10);

这里要注意2点：

1）const对象必须被初始化！所以(10)是不能够少的。

2）new返回的指针必须是const类型的。

那么我们可不可以动态创建一个数组呢？

答案是否定的，因为new内置类型的数组，不能被初始化。

曾经碰到过让你迷惑不解、类似于int * (* (*fp1) (int) ) [10];这样的变量声明吗？本文将由易到难，一步一步教会你如何理解这种复杂的C/C++声明。

　　我们将从每天都能碰到的较简单的声明入手，然后逐步加入const修饰符和typedef，还有函数指针，最后介绍一个能够让你准确地理解任何C/C++声明的“右左法则”。

　　需要强调一下的是，复杂的C/C++声明并不是好的编程风格；我这里仅仅是教你如何去理解这些声明。注意：为了保证能够在同一行上显示代码和相关注释，本文最好在至少1024x768分辨率的显示器上阅读。
让我们从一个非常简单的例子开始，如下：

int n;

这个应该被理解为“declare n as an int”（n是一个int型的变量）。接下去来看一下指针变量，如下：

int *p;

这个应该被理解为“declare p as an int *”（p是一个int *型的变量），或者说p是一个指向一个int型变量的指针。我想在这里展开讨论一下：我觉得在声明一个指针（或引用）类型的变量时，最好将*（或&）写在紧靠变量之前，而不是紧跟基本类型之后。这样可以避免一些理解上的误区，比如：
再来看一个指针的指针的例子：

char **argv;

理论上，对于指针的级数没有限制，你可以定义一个浮点类型变量的指针的指针的指针的指针，再来看如下的声明：

int RollNum[30][4]; int (*p)[4]=RollNum; int *q[5];

这里，p被声明为一个指向一个4元素（int类型）数组的指针，而q被声明为一个包含5个元素（int类型的指针）的数组。另外，我们还可以在同一个声明中混合实用*和&，如下：

int **p1; // p1 is a pointer  to a pointer  to an int. int *&p2; // p2 is a reference to a pointer  to an int. int &*p3; // ERROR: Pointer  to a reference is illegal. int &&p4; // ERROR: Reference to a reference is illegal.

注：p1是一个int类型的指针的指针；p2是一个int类型的指针的引用；p3是一个int类型引用的指针（不合法！）；p4是一个int类型引用的引用（不合法！）。

const修饰符

当你想阻止一个变量被改变，可能会用到const关键字。在你给一个变量加上const修饰符的同时，通常需要对它进行初始化，因为以后的任何时候你将没有机会再去改变它。例如：

const int n="5"; int const m="10";

上述两个变量n和m其实是同一种类型的——都是const int（整形恒量）。因为C++标准规定，const关键字放在类型或变量名之前等价的。我个人更喜欢第一种声明方式，因为它更突出了const修饰符的作用。当const与指针一起使用时，容易让人感到迷惑。例如，我们来看一下下面的p和q的声明：

const int *p; int const *q;

他们当中哪一个代表const int类型的指针（const直接修饰int），哪一个代表int类型的const指针（const直接修饰指针）？实际上，p和q都被声明为const int类型的指针。而int类型的const指针应该这样声明：

int * const r= &n; // n has been declared as an int

这里，p和q都是指向const int类型的指针，也就是说，你在以后的程序里不能改变*p的值。而r是一个const指针，它在声明的时候被初始化指向变量n（即r=&n;）之后，r的值将不再允许被改变（但*r的值可以改变）。

组合上述两种const修饰的情况，我们来声明一个指向const int类型的const指针，如下：

const int * const p=&n // n has been declared as const int

下面给出的一些关于const的声明，将帮助你彻底理清const的用法。不过请注意，下面的一些声明是不能被编译通过的，因为他们需要在声明的同时进行初始化。为了简洁起见，我忽略了初始化部分；因为加入初始化代码的话，下面每个声明都将增加两行代码。

char ** p1; //    pointer to    pointer to    char const char **p2; //    pointer to    pointer to const char char * const * p3; //    pointer to const pointer to    char const char * const * p4; //    pointer to const pointer to const char char ** const p5; // const pointer to    pointer to    char const char ** const p6; // const pointer to    pointer to const char char * const * const p7; // const pointer to const pointer to    char const char * const * const p8; // const pointer to const pointer to const char

注：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指针。

typedef的妙用

typedef给你一种方式来克服“*只适合于变量而不适合于类型”的弊端。你可以如下使用typedef：

typedef char * PCHAR; PCHAR p,q;

这里的p和q都被声明为指针。（如果不使用typedef，q将被声明为一个char变量，这跟我们的第一眼感觉不太一致！）下面有一些使用typedef的声明，并且给出了解释：

typedef char * a; // a is a pointer to a char typedef a b(); // b is a function that returns // a pointer to a char typedef b *c; // c is a pointer to a function // that returns a pointer to a char typedef c d(); // d is a function returning // a pointer to a function // that returns a pointer to a char typedef d *e; // e is a pointer to a function // returning a pointer to a // function that returns a // pointer to a char e var[10]; // var is an array of 10 pointers to // functions returning pointers to // functions returning pointers to chars.

typedef经常用在一个结构声明之前，如下。这样，当创建结构变量的时候，允许你不使用关键字struct（在C中，创建结构变量时要求使用struct关键字，如struct tagPOINT a；而在C++中，struct可以忽略，如tagPOINT b）。

typedef struct tagPOINT {   int x;   int y; }POINT; POINT p; /* Valid C code */

函数指针

函数指针可能是最容易引起理解上的困惑的声明。函数指针在DOS时代写TSR程序时用得最多；在Win32和X-Windows时代，他们被用在需要回调函数的场合。当然，还有其它很多地方需要用到函数指针：虚函数表，STL中的一些模板，Win NT/2K/XP系统服务等。让我们来看一个函数指针的简单例子：

int (*p)(char);

这里p被声明为一个函数指针，这个函数带一个char类型的参数，并且有一个int类型的返回值。另外，带有两个float类型参数、返回值是char类型的指针的指针的函数指针可以声明如下：

char ** (*p)(float, float);

那么，带两个char类型的const指针参数、无返回值的函数指针又该如何声明呢？参考如下：

void * (*a[5])(char * const, char * const);

“右左法则”是一个简单的法则，但能让你准确理解所有的声明。这个法则运用如下：从最内部的括号开始阅读声明，向右看，然后向左看。当你碰到一个括号时就调转阅读的方向。括号内的所有内容都分析完毕就跳出括号的范围。这样继续，直到整个声明都被分析完毕。

对上述“右左法则”做一个小小的修正：当你第一次开始阅读声明的时候，你必须从变量名开始，而不是从最内部的括号。

下面结合例子来演示一下“右左法则”的使用。

int * (* (*fp1) (int) ) [10];

阅读步骤：

1. 从变量名开始——fp1

2. 往右看，什么也没有，碰到了)，因此往左看，碰到一个*——一个指针

3. 跳出括号，碰到了(int)——一个带一个int参数的函数

4. 向左看，发现一个*——（函数）返回一个指针

5. 跳出括号，向右看，碰到[10]——一个10元素的数组

6. 向左看，发现一个*——指针

7. 向左看，发现int——int类型

总结：fp1被声明成为一个函数的指针,该函数返回指向指针数组的指针.

再来看一个例子：

int *( *( *arr[5])())();

阅读步骤：

1. 从变量名开始——arr

2. 往右看，发现是一个数组——一个5元素的数组

3. 向左看，发现一个*——指针

4. 跳出括号，向右看，发现()——不带参数的函数

5. 向左看，碰到*——（函数）返回一个指针

6. 跳出括号，向右发现()——不带参数的函数

7. 向左，发现*——（函数）返回一个指针

8. 继续向左，发现int——int类型

还有更多的例子：

float ( * ( *b()) [] )(); // b is a function that returns a // pointer to an array of pointers // to functions returning floats. void * ( *c) ( char, int (*)()); // c is a pointer to a function that takes // two parameters: // a char and a pointer to a // function that takes no // parameters and returns // an int // and returns a pointer to void. void ** (*d) (int &, char **(*)(char *, char **)); // d is a pointer to a function that takes // two parameters: // a reference to an int and a pointer // to a function that takes two parameters: // a pointer to a char and a pointer // to a pointer to a char // and returns a pointer to a pointer // to a char // and returns a pointer to a pointer to void float ( * ( * e[10])   (int &) ) [5]; // e is an array of 10 pointers to // functions that take a single // reference to an int as an argument // and return pointers to // an array of 5 floats.

诠释C指针操作

第一章。指针的概念

指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。 要搞清一个指针需要搞清指

针的四方面的内容：指针的类型，指针所指向的类型，指针的值或者叫指针所指向的内存区，还有指针

本身所占据的内存区。让我们分别说明。 先声明几个指针放着做例子： 例一： (1)int *ptr; (2)char

*ptr; (3)int **ptr; (4)int (*ptr)[3]; (5)int *(*ptr)[4]; 如果看不懂后几个例子的话，请参阅我

前段时间贴出的文?lt;<如何理解c和c ++的复杂类型声明>>。 1。 指针的类型。 从语法的角度看，你

只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型

。让我们看看例一中各个指针的类型： (1)int *ptr; //指针的类型是int * (2)char *ptr; //指针的

类型是char * (3)int **ptr; //指针的类型是 int ** (4)int (*ptr)[3]; //指针的类型是 int(*)[3]

(5)int *(*ptr)[4]; //指针的类型是 int *(*)[4] 怎么样？找出指针的类型的方法是不是很简单？ 2

。指针所指向的类型。 当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将

把那片内存区里的内容当做什么来看待。 从语法上看，你只须把指针声明语句中的指针名字和名字左边

的指针声明符*去掉，剩下的就是指针所指向的类型。例如： (1)int *ptr; //指针所指向的类型是int

(2)char *ptr; //指针所指向的的类型是char (3)int **ptr; //指针所指向的的类型是 int * (4)int

(*ptr)[3]; //指针所指向的的类型是 int()[3] (5)int *(*ptr)[4]; //指针所指向的的类型是 int *

()[4] 在指针的算术运算中，指针所指向的类型有很大的作用。 指针的类型(即指针本身的类型)和指针

所指向的类型是两个概念。当你对C越来越熟悉时，你会发现，把与指针搅和在一起的"类型"这个概念分

成"指针的类型"和"指针所指向的类型"两个概念，是精通指针的关键点之一。我看了不少书，发现有些

写得差的书中，就把指针的这两个概念搅在一起了，所以看起书来前后矛盾，越看越糊涂。 3。 指针的

值，或者叫指针所指向的内存区或地址。 指针的值是指针本身存储的数值，这个值将被编译器当作一个

地址，而不是一个一般的数值。在32位程序里，所有类型的指针的值都是一个32位整数，因为32位程序

里内存地址全都是32位长。 指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为

sizeof(指针所指向的类型)的一片内存区。以后，我们说一个指针的值是XX，就相当于说该指针指向了

以XX为首地址的一片内存区域；我们说一个指针指向了某块内存区域，就相当于说该指针的值是这块内

存区域的首地址。 指针所指向的内存区和指针所指向的类型是两个完全不同的概念。在例一中，指针所

指向的类型已经有了，但由于指针还未初始化，所以它所指向的内存区是不存在的，或者说是无意义的

。 以后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指向的类型是什么？该指针指向

了哪里？ 4。 指针本身所占据的内存区。 指针本身占了多大的内存？你只要用函数sizeof(指针的类型

)测一下就知道了。在32位平台里，指针本身占据了4个字节的长度。 指针本身占据的内存这个概念在判

断一个指针表达式是否是左值时很有用。

第二章。指针的算术运算

指针可以加上或减去一个整数。指针的这种运算的意义和通常的数值的加减运算的意义是不一样的。例

如： 例二： 1。 char a[20]; 2。 int *ptr=a; ... ... 3。 ptr++; 在上例中，指针ptr的类型是

int*,它指向的类型是int，它被初始化为指向整形变量a。接下来的第3句中，指针ptr被加了1，编译器

是这样处理的：它把指针ptr的值加上了sizeof(int)，在32位程序中，是被加上了4。由于地址是用字节

做单位的，故ptr所指向的地址由原来的变量a的地址向高地址方向增加了4个字节。 由于char类型的长

度是一个字节，所以，原来ptr是指向数组a的第 0号单元开始的四个字节，此时指向了数组a中从第4号

单元开始的四个字节。 我们可以用一个指针和一个循环来遍历一个数组，看例子： 例三： int array

[20]; int *ptr=array; ... //此处略去为整型数组赋值的代码。 ... for(i=0;i<20;i++) { (*ptr)

++; ptr++； } 这个例子将整型数组中各个单元的值加1。由于每次循环都将指针 ptr加1，所以每次循

环都能访问数组的下一个单元。再看例子： 例四： 1。 char a[20]; 2。 int *ptr=a; ... ... 3。

ptr+=5; 在这个例子中，ptr被加上了5，编译器是这样处理的：将指针ptr 的值加上5乘sizeof(int)，

在32位程序中就是加上了5乘4=20。由于地址的单位是字节，故现在的ptr所指向的地址比起加5后的ptr

所指向的地址来说，向高地址方向移动了20个字节。在这个例子中，没加5前的ptr指向数组a的第0号单

元开始的四个字节，加5后，ptr已经指向了数组a的合法范围之外了。虽然这种情况在应用上会出问题，

但在语法上却是可以的。这也体现出了指针的灵活性。 如果上例中，ptr是被减去5，那么处理过程大同

小异，只不过ptr 的值是被减去5乘sizeof(int)，新的ptr指向的地址将比原来的ptr所指向的地址向低

地址方向移动了20个字节。 总结一下，一个指针ptrold加上一个整数n后，结果是一个新的指针ptrnew

，ptrnew的类型和ptrold的类型相同，ptrnew所指向的类型和ptrold所指向的类型也相同。ptrnew的值

将比ptrold的值增加了n乘sizeof(ptrold所指向的类型)个字节。就是说，ptrnew所指向的内存区将比

ptrold所指向的内存区向高地址方向移动了n乘sizeof (ptrold所指向的类型)个字节。 a一个指针

ptrold减去一个整数n后，结果是一个新的指针ptrnew， ptrnew的类型和ptrold的类型相同，ptrnew所

指向的类型和ptrold所指向的类型也相同。 ptrnew的值将比ptrold的值减少了n乘sizeof(ptrold所指向

的类型)个字节，就是说， ptrnew所指向的内存区将比ptrold所指向的内存区向低地址方向移动了n乘

sizeof(ptrold 所指向的类型)个字节。

第三章。

运算?amp;和* 这里&是取地址运算符，*是...书上叫做"间接运算符"。 &a的运算结果是一个指针，指针

的类型是a的类型加个*，指针所指向的类型是a的类型，指针所指向的地址嘛，那就是a的地址。 *p的运

算结果就五花八门了。总之*p的结果是p所指向的东西，这个东西有这些特点：它的类型是p指向的类型

，它所占用的地址是p所指向的地址。 例五： int a="12"; int b; int *p; int **ptr; p=&a;//&a的结

果是一个指针，类型是int*，指向的类型是int，指向的地址是a的地址。 *p=24;//*p的结果，在这里它

的类型是int，它所占用的地址是p所指向的地址，显然，*p就是变量a。 ptr=&p;//&p的结果是个指针，

该指针的类型是p的类型加个*，在这里是int**。该指针所指向的类型是p的类型，这里是int*。该指针

所指向的地址就是指针p自己的地址。 *ptr=&b;//*ptr是个指针，&b的结果也是个指针，且这两个指针

的类型和所指向的类型是一样的，所以用&b来给*ptr赋值就是毫无问题的了。 **ptr=34;//*ptr的结果

是ptr所指向的东西，在这里是一个指针，对这个指针再做一次*运算，结果就是一个int类型的变量。

 
第四章。

指针表达式。 一个表达式的最后结果如果是一个指针，那么这个表达式就叫指针表达式。 下面是一些

指针表达式的例子： 例六： int a,b; int array[10]; int *pa; pa=&a;//&a是一个指针表达式。 int

**ptr=&pa;//&pa也是一个指针表达式。 *ptr=&b;//*ptr和&b都是指针表达式。 pa="array"; pa++;//这

也是指针表达式。 例七： char *arr[20]; char **parr=arr;//如果把arr看作指针的话，arr也是指针

表达式 char *str; str=*parr;//*parr是指针表达式 str=*(parr+1);//*(parr+1)是指针表达式

str=*(parr+2);//*(parr+2)是指针表达式 由于指针表达式的结果是一个指针，所以指针表达式也具有

指针所具有的四个要素：指针的类型，指针所指向的类型，指针指向的内存区，指针自身占据的内存。

好了，当一个指针表达式的结果指针已经明确地具有了指针自身占据的内存的话，这个指针表达式就是

一个左值，否则就不是一个左值。 在例七中，&a不是一个左值，因为它还没有占据明确的内存。*ptr

是一个左值，因为*ptr这个指针已经占据了内存，其实*ptr就是指针pa，既然pa已经在内存中有了自己

的位置，那么*ptr当然也有了自己的位置。
 

第五章。

数组和指针的关系
如果对声明数组的语句不太明白的话，请参阅我前段时间贴出的文?lt;<如何理解c和c++的复杂类型声明

>>。 数组的数组名其实可以看作一个指针。看下例： 例八： int array[10]=

{0,1,2,3,4,5,6,7,8,9},value; ... ... value="array"[0];//也可写成：value=*array; value="array"

[3];//也可写成：value=*(array+3); value="array"[4];//也可写成：value=*(array+4); 上例中，一般

而言数组名array代表数组本身，类型是int [10]，但如果把array看做指针的话，它指向数组的第0个单

元，类型是int *，所指向的类型是数组单元的类型即int。因此*array等于0就一点也不奇怪了。同理，

array+3是一个指向数组第3个单元的指针，所以*(array+3)等于3。其它依此类推。 例九： char *str

[3]={ "Hello,this is a sample!","Hi,good morning.","Hello world" }; char s[80]； strcpy

(s,str[0]);//也可写成strcpy(s,*str); strcpy(s,str[1]);//也可写成strcpy(s,*(str+1)); strcpy

(s,str[2]);//也可写成strcpy(s,*(str+2)); 上例中，str是一个三单元的数组，该数组的每个单元都

是一个指针，这些指针各指向一个字符串。把指针数组名str当作一个指针的话，它指向数组的第0 号单

元，它的类型是char**，它指向的类型是char *。 *str也是一个指针，它的类型是char*，它所指向的

类型是char，它指向的地址是字符串"Hello,this is a sample!"的第一个字符的地址，即'H'的地址。

str+1也是一个指针，它指向数组的第1号单元，它的类型是 char**，它指向的类型是char *。 *

(str+1)也是一个指针，它的类型是char*，它所指向的类型是 char，它指向"Hi,good morning."的第一

个字符'H'，等等。 下面总结一下数组的数组名的问题。声明了一个数组TYPE array [n]，则数组名称

array就有了两重含义：第一，它代表整个数组，它的类型是TYPE [n]；第二，它是一个指针，该指针的

类型是TYPE*，该指针指向的类型是TYPE，也就是数组单元的类型，该指针指向的内存区就是数组第0号

单元，该指针自己占有单独的内存区，注意它和数组第0号单元占据的内存区是不同的。该指针的值是不

能修改的，即类似array++的表达式是错误的。 在不同的表达式中数组名array可以扮演不同的角色。

在表达式sizeof(array)中，数组名array代表数组本身，故这时 sizeof函数测出的是整个数组的大小。

在表达式*array中，array扮演的是指针，因此这个表达式的结果就是数组第0号单元的值。sizeof

(*array)测出的是数组单元的大小。 表达式array+n（其中n=0，1，2，....。）中，array扮演的是指

针，故array+n的结果是一个指针，它的类型是TYPE*，它指向的类型是TYPE，它指向数组第n号单元。故

sizeof(array+n)测出的是指针类型的大小。 例十： int array[10]; int (*ptr)[10]; ptr=&array;

上例中ptr是一个指针，它的类型是int (*)[10]，他指向的类型是 int [10]，我们用整个数组的首地址

来初始化它。在语句ptr=&array中，array代表数组本身。 本节中提到了函数sizeof()，那么我来问一

问，sizeof(指针名称) 测出的究竟是指针自身类型的大小呢还是指针所指向的类型的大小？答案是前者

。例如： int (*ptr)[10]; 则在32位程序中，有： sizeof(int(*)[10])==4 sizeof(int [10])==40

sizeof(ptr)==4 实际上，sizeof(对象)测出的都是对象自身的类型的大小，而不是别的什么类型的大小

。

第六章。

指针和结构类型的关系
 可以声明一个指向结构类型对象的指针。 例十一： struct MyStruct { int a; int b; int c; }

MyStruct ss={20,30,40};//声明了结构对象ss，并把ss的三个成员初始化为20，30和40。 MyStruct

*ptr=&ss;//声明了一个指向结构对象ss的指针。它的类型是MyStruct*,它指向的类型是MyStruct。 int

*pstr=(int*)&ss;//声明了一个指向结构对象ss的指针。但是它的类型和它指向的类型和ptr是不同的。

请问怎样通过指针ptr来访问ss的三个成员变量？ 答案： ptr->a; ptr->b; ptr->c; 又请问怎样通过指

针pstr来访问ss的三个成员变量？ 答案： *pstr；//访问了ss的成员a。 *(pstr+1);//访问了ss的成员

b。 *(pstr+2)//访问了ss的成员c。 呵呵，虽然我在我的MSVC++6.0上调式过上述代码，但是要知道，

这样使用pstr来访问结构成员是不正规的，为了说明为什么不正规，让我们看看怎样通过指针来访问数

组的各个单元：
例十二：
int array[3]={35,56,37};
int *pa=array;
通过指针pa访问数组array的三个单元的方法是：

*pa;//访问了第0号单元
*(pa+1);//访问了第1号单元
*(pa+2);//访问了第2号单元
从格式上看倒是与通过指针访问结构成员的不正规方法的格式一
样。
所有的C/C++编译器在排列数组的单元时，总是把各个数组单元存
放在连续的存储区里，单元和单元之间没有空隙。但在存放结构对象的各个成员时，在某
种编译环境下，可能会需要字对齐或双字对齐或者是别的什么对齐，需要在相邻两个成员
之间加若干"填充字节"，这就导致各个成员之间可能会有若干个字节的空隙。

所以，在例十二中，即使*pstr访问到了结构对象ss的第一个成员
变量a，也不能保证*(pstr+1)就一定能访问到结构成员b。因为成员a和成员b之间可能会有
若干填充字节，说不定*(pstr+1)就正好访问到了这些填充字节呢。这也证明了指针的灵活
性。要是你的目的就是想看看各个结构成员之间到底有没有填充字节，嘿，这倒是个不错
的方法。
通过指针访问结构成员的正确方法应该是象例十二中使用指针ptr
的方法。

第七章。指针和函数的关系

可以把一个指针声明成为一个指向函数的指针。
int fun1(char*,int);
int (*pfun1)(char*,int);
pfun1=fun1;
....
....
int a=(*pfun1)("abcdefg",7);//通过函数指针饔煤?

可以把指针作为函数的形参。在函数调用语句中，可以用指针表达
式来作为 实参。
例十三：
int fun(char*);
int a;
char str[]="abcdefghijklmn";
a=fun(str);
...
...
int fun(char*s)
{
int num="0";
for(int i="0";i
{
num+=*s;s++;
}
return num;
}
这个例子中的函数fun统计一个字符串中各个字符的ASCII码值之
和。前面说了，数组的名字也是一个指针。在函数调用中，当把str作为实参传递给形参s
后，实际是把str的值传递给了s，s所指向的地址就和str所指向的地址一致，但是str和s
各自占用各自的存储空间。在函数体内对s进行自加1运算，并不意味着同时对str进行了自
加1运算。

第八章。指针类型转换

当我们初始化一个指针或给一个指针赋值时，赋值号的左边是一个
指针，赋值号的右边是一个指针表达式。在我们前面所举的例子中，绝大多数情况下，指
针的类型和指针表达式的类型是一样的，指针所指向的类型和指针表达式所指向的类型是
一样的。

例十四：

1。 float f="12".3;
2。 float *fptr=&f;
3。 int *p;
在上面的例子中，假如我们想让指针p指向实数f，应该怎么搞？是
用下面的 语句吗？
p=&f;
不对。因为指针p的类型是int*，它指向的类型是int。表达式&f的
结果是一个指针，指针的类型是float*,它指向的类型是float。两者不一致，直接赋值的
方法是不行的。至少在我的MSVC++6.0上，对指针的赋值语句要求赋值号两边的类型一致，
所指向的类型也一致，其它的编译器上我没试过，大家可以试试。为了实现我们的目的，
需要进行"强制类型转换"：
p=(int*)&f;
如果有一个指针p，我们需要把它的类型和所指向的类型改为TYEP*
和TYPE，那么语法格式是：
(TYPE*)p；
这样强制类型转换的结果是一个新指针，该新指针的类型是
TYPE*，它指向的类型是TYPE，它指向的地址就是原指针指向的地址。而原来的指针p的一
切属性都没有被修改。
一个函数如果使用了指针作为形参，那么在函数调用语句的实参和
形参的结合过程中，也会发生指针类型的转换。
例十五：
void fun(char*);
int a="125",b;
fun((char*)&a);
...
...
void fun(char*s)
{
char c;
c=*(s+3);*(s+3)=*(s+0);*(s+0)=c;
c=*(s+2);*(s+2)=*(s+1);*(s+1)=c;
}
}
注意这是一个32位程序，故int类型占了四个字节，char类型占一
个字节。函数fun的作用是把一个整数的四个字节的顺序来个颠倒。注意到了吗？在函数调
用语句中，实参&a的结果是一个指针，它的类型是int *，它指向的类型是int。形参这个
指针的类型是char*，它指向的类型是char。这样，在实参和形参的结合过程中，我们必须
进行一次从int*类型到char*类型的转换。结合这个例子，我们可以这样来想象编译器进行
转换的过程：编译器先构造一个临时指针 char*temp，然后执行temp=(char*)&a，最后再
把temp的值传递给s。所以最后的结果是：s的类型是char*,它指向的类型是char，它指向
的地址就是a的首地址。

我们已经知道，指针的值就是指针指向的地址，在32位程序中，指
针的值其实是一个32位整数。那可不可以把一个整数当作指针的值直接赋给指针呢？就象
下面的语句：

unsigned int a;

TYPE *ptr;//TYPE是int，char或结构类型等等类型。

...
...
a=20345686;
ptr=20345686;//我们的目的是要使指针ptr指向地址20345686（十
进制）
ptr=a;//我们的目的是要使指针ptr指向地址20345686（十进制）

编译一下吧。结果发现后面两条语句全是错的。那么我们的目的就
不能达到了吗？不，还有办法：
unsigned int a;
TYPE *ptr;//TYPE是int，char或结构类型等等类型。

...
...
a=某个数，这个数必须代表一个合法的地址；
ptr=(TYPE*)a；//呵呵，这就可以了。
严格说来这里的(TYPE*)和指针类型转换中的(TYPE*)还不一样。这
里的(TYPE*)的意思是把无符号整数a的值当作一个地址来看待。

上面强调了a的值必须代表一个合法的地址，否则的话，在你使用
ptr的时候，就会出现非法操作错误。

想想能不能反过来，把指针指向的地址即指针的值当作一个整数取
出来。完全可以。下面的例子演示了把一个指针的值当作一个整数取出来，然后再把这个
整数当作一个地址赋给一个指针：

例十六：

int a="123",b;
int *ptr=&a;
char *str;
b=(int)ptr;//把指针ptr的值当作一个整数取出来。

str=(char*)b;//把这个整数的值当作一个地址赋给指针str。

好了，现在我们已经知道了，可以把指针的值当作一个整数取出
来，也可以把一个整数值当作地址赋给一个指针。
第九章。指针的安全问题
看下面的例子：
例十七：
char s='a';
int *ptr;
ptr=(int*)&s;
*ptr=1298；
指针ptr是一个int*类型的指针，它指向的类型是int。它指向的地
址就是s的首地址。在32位程序中，s占一个字节，int类型占四个字节。最后一条语句不但
改变了s所占的一个字节，还把和s相临的高地址方向的三个字节也改变了。这三个字节是
干什么的？只有编译程序知道，而写程序的人是不太可能知道的。也许这三个字节里存储
了非常重要的数据，也许这三个字节里正好是程序的一条代码，而由于你对指针的马虎应
用，这三个字节的值被改变了！这会造成崩溃性的错误。

让我们再来看一例：

例十八：

1。 char a;
2。 int *ptr=&a;
...
...
3。 ptr++;
4。 *ptr=115;
该例子完全可以通过编译，并能执行。但是看到没有？第3句对指
针ptr进行
自加1运算后，ptr指向了和整形变量a相邻的高地址方向的一块存
储区。这块存储区里是什么？我们不知道。有可能它是一个非常重要的数据，甚至可能是
一条代码。而第4句竟然往这片存储区里写入一个数据！这是严重的错误。所以在使用指针
时，程序员心里必须非常清楚：我的指针究竟指向了哪里。

在用指针访问数组的时候，也要注意不要超出数组的低端和高端界
限，否则也会造成类似的错误。
在指针的强制类型转换：ptr1=(TYPE*)ptr2中，如果sizeof(ptr2
的类型)大于sizeof(ptr1的类型)，那么在使用指针ptr1来访问ptr2所指向的存储区时是安
全的。如果sizeof(ptr2的类型)小于sizeof(ptr1的类型)，那么在使用指针ptr1来访问
ptr2所指向的存储区时是不安全的。至于为什么，读者结合例十七来想一想，应该会明白
的。

C语言宏定义技巧（常用宏定义） 
 
写好C语言，漂亮的宏定义很重要，使用宏定义可以防止出错，提高可移植性，可读性，方便性 等等。下面列举一些成熟软件中常用得宏定义。。。。。。

 

1，防止一个头文件被重复包含

#ifndef COMDEF_H

#define COMDEF_H

  //头文件内容

#endif

2，重新定义一些类型，防止由于各种平台和编译器的不同，而产生的类型字节数差异，方便移植。

typedef  unsigned char      boolean;     /* Boolean value type. */

 

typedef  unsigned long int  uint32;      /* Unsigned 32 bit value */

typedef  unsigned short     uint16;      /* Unsigned 16 bit value */

typedef  unsigned char      uint8;       /* Unsigned 8  bit value */

 

typedef  signed long int    int32;       /* Signed 32 bit value */

typedef  signed short       int16;       /* Signed 16 bit value */

typedef  signed char        int8;        /* Signed 8  bit value */

 

 

//下面的不建议使用

typedef  unsigned char     byte;         /* Unsigned 8  bit value type. */

typedef  unsigned short    word;         /* Unsinged 16 bit value type. */

typedef  unsigned long     dword;        /* Unsigned 32 bit value type. */

 

typedef  unsigned char     uint1;        /* Unsigned 8  bit value type. */

typedef  unsigned short    uint2;        /* Unsigned 16 bit value type. */

typedef  unsigned long     uint4;        /* Unsigned 32 bit value type. */

 

typedef  signed char       int1;         /* Signed 8  bit value type. */

typedef  signed short      int2;         /* Signed 16 bit value type. */

typedef  long int          int4;         /* Signed 32 bit value type. */

 

typedef  signed long       sint31;       /* Signed 32 bit value */

typedef  signed short      sint15;       /* Signed 16 bit value */

typedef  signed char       sint7;        /* Signed 8  bit value */

 

3，得到指定地址上的一个字节或字

#define  MEM_B( x )  ( *( (byte *) (x) ) )

#define  MEM_W( x )  ( *( (word *) (x) ) )

4，求最大值和最小值

   #define  MAX( x, y ) ( ((x) > (y)) ? (x) : (y) )

   #define  MIN( x, y ) ( ((x) < (y)) ? (x) : (y) )

5，得到一个field在结构体(struct)中的偏移量

#define FPOS( type, field ) \

/*lint -e545 */ ( (dword) &(( type *) 0)-> field ) /*lint +e545 */

6,得到一个结构体中field所占用的字节数

#define FSIZ( type, field ) sizeof( ((type *) 0)->field )

7，按照LSB格式把两个字节转化为一个Word

#define  FLIPW( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] )

8，按照LSB格式把一个Word转化为两个字节

#define  FLOPW( ray, val ) \

  (ray)[0] = ((val) / 256); \

  (ray)[1] = ((val) & 0xFF)

9，得到一个变量的地址（word宽度）

#define  B_PTR( var )  ( (byte *) (void *) &(var) )

#define  W_PTR( var )  ( (word *) (void *) &(var) )

10，得到一个字的高位和低位字节

#define  WORD_LO(xxx)  ((byte) ((word)(xxx) & 255))

#define  WORD_HI(xxx)  ((byte) ((word)(xxx) >> 8))

11，返回一个比X大的最接近的8的倍数

#define RND8( x )       ((((x) + 7) / 8 ) * 8 )

12，将一个字母转换为大写

#define  UPCASE( c ) ( ((c) >= 'a' && (c) <= 'z') ? ((c) - 0x20) : (c) )

13，判断字符是不是10进值的数字

#define  DECCHK( c ) ((c) >= '0' && (c) <= '9')

14，判断字符是不是16进值的数字

#define  HEXCHK( c ) ( ((c) >= '0' && (c) <= '9') ||\

                       ((c) >= 'A' && (c) <= 'F') ||\

((c) >= 'a' && (c) <= 'f') )

15，防止溢出的一个方法

#define  INC_SAT( val )  (val = ((val)+1 > (val)) ? (val)+1 : (val))

16，返回数组元素的个数

#define  ARR_SIZE( a )  ( sizeof( (a) ) / sizeof( (a[0]) ) )

17，返回一个无符号数n尾的值MOD_BY_POWER_OF_TWO(X,n)=X%(2^n)

#define MOD_BY_POWER_OF_TWO( val, mod_by ) \

           ( (dword)(val) & (dword)((mod_by)-1) )

18，对于IO空间映射在存储空间的结构，输入输出处理

  #define inp(port)         (*((volatile byte *) (port)))

  #define inpw(port)        (*((volatile word *) (port)))

  #define inpdw(port)       (*((volatile dword *)(port)))

  

  #define outp(port, val)   (*((volatile byte *) (port)) = ((byte) (val)))

  #define outpw(port, val)  (*((volatile word *) (port)) = ((word) (val)))

  #define outpdw(port, val) (*((volatile dword *) (port)) = ((dword) (val)))

[2005-9-9添加] 

19,使用一些宏跟踪调试

A N S I标准说明了五个预定义的宏名。它们是：

_ L I N E _

_ F I L E _

_ D A T E _

_ T I M E _

_ S T D C _

如果编译不是标准的，则可能仅支持以上宏名中的几个，或根本不支持。记住编译程序

也许还提供其它预定义的宏名。

_ L I N E _及_ F I L E _宏指令在有关# l i n e的部分中已讨论，这里讨论其余的宏名。

_ D AT E _宏指令含有形式为月/日/年的串，表示源文件被翻译到代码时的日期。

源代码翻译到目标代码的时间作为串包含在_ T I M E _中。串形式为时：分：秒。

如果实现是标准的，则宏_ S T D C _含有十进制常量1。如果它含有任何其它数，则实现是

非标准的。

可以定义宏，例如:

当定义了_DEBUG，输出数据信息和所在文件所在行

#ifdef _DEBUG

#define DEBUGMSG(msg,date) printf(msg);printf(“%d%d%d”,date,_LINE_,_FILE_)

#else

      #define DEBUGMSG(msg,date) 

#endif

 

20，宏定义防止使用是错误

用小括号包含。

例如：#define ADD(a,b) （a+b）

用do{}while(0)语句包含多语句防止错误

例如：#difne DO(a,b) a+b;\

                   a++;

应用时：if(….)

          DO(a,b); //产生错误

        else

        

解决方法: #difne DO(a,b) do{a+b;\

                   a++;}while(0)

 

　宏中"#"和"##"的用法
一、一般用法
我们使用#把宏参数变为一个字符串,用##把两个宏参数贴合在一起.
用法:
#include<cstdio>
#include<climits>
using namespace std;

#define STR(s)     #s
#define CONS(a,b)  int(a##e##b)

int main()
{
    printf(STR(vck));           // 输出字符串"vck"
    printf("%d\n", CONS(2,3));  // 2e3 输出:2000
    return 0;
}

二、当宏参数是另一个宏的时候
需要注意的是凡宏定义里有用'#'或'##'的地方宏参数是不会再展开.

1, 非'#'和'##'的情况
#define TOW      (2)
#define MUL(a,b) (a*b)

printf("%d*%d=%d\n", TOW, TOW, MUL(TOW,TOW));
这行的宏会被展开为：
printf("%d*%d=%d\n", (2), (2), ((2)*(2)));
MUL里的参数TOW会被展开为(2).

2, 当有'#'或'##'的时候
#define A          (2)
#define STR(s)     #s
#define CONS(a,b)  int(a##e##b)

printf("int max: %s\n",  STR(INT_MAX));    // INT_MAX #include<climits>
这行会被展开为：
printf("int max: %s\n", "INT_MAX");

printf("%s\n", CONS(A, A));               // compile error 
这一行则是：
printf("%s\n", int(AeA));

INT_MAX和A都不会再被展开, 然而解决这个问题的方法很简单. 加多一层中间转换宏.
加这层宏的用意是把所有宏的参数在这层里全部展开, 那么在转换宏里的那一个宏(_STR)就能得到正确的宏参数.

#define A           (2)
#define _STR(s)     #s
#define STR(s)      _STR(s)          // 转换宏
#define _CONS(a,b)  int(a##e##b)
#define CONS(a,b)   _CONS(a,b)       // 转换宏

printf("int max: %s\n", STR(INT_MAX));          // INT_MAX,int型的最大值，为一个变量 #include<climits>
输出为: int max: 0x7fffffff
STR(INT_MAX) -->  _STR(0x7fffffff) 然后再转换成字符串；

printf("%d\n", CONS(A, A));
输出为：200
CONS(A, A)  -->  _CONS((2), (2))  --> int((2)e(2))

三、'#'和'##'的一些应用特例
1、合并匿名变量名
#define  ___ANONYMOUS1(type, var, line)  type  var##line
#define  __ANONYMOUS0(type, line)  ___ANONYMOUS1(type, _anonymous, line)
#define  ANONYMOUS(type)  __ANONYMOUS0(type, __LINE__)
例：ANONYMOUS(static int);  即: static int _anonymous70;  70表示该行行号；
第一层：ANONYMOUS(static int);  -->  __ANONYMOUS0(static int, __LINE__);
第二层：                        -->  ___ANONYMOUS1(static int, _anonymous, 70);
第三层：                        -->  static int  _anonymous70;
即每次只能解开当前层的宏，所以__LINE__在第二层才能被解开；

2、填充结构
#define  FILL(a)   {a, #a}

enum IDD{OPEN, CLOSE};
typedef struct MSG{
  IDD id;
  const char * msg;
}MSG;

MSG _msg[] = {FILL(OPEN), FILL(CLOSE)};
相当于：
MSG _msg[] = {{OPEN, "OPEN"},
              {CLOSE, "CLOSE"}};

3、记录文件名
#define  _GET_FILE_NAME(f)   #f
#define  GET_FILE_NAME(f)    _GET_FILE_NAME(f)
static char  FILE_NAME[] = GET_FILE_NAME(__FILE__);

4、得到一个数值类型所对应的字符串缓冲大小
#define  _TYPE_BUF_SIZE(type)  sizeof #type
#define  TYPE_BUF_SIZE(type)   _TYPE_BUF_SIZE(type)
char  buf[TYPE_BUF_SIZE(INT_MAX)];
     -->  char  buf[_TYPE_BUF_SIZE(0x7fffffff)];
     -->  char  buf[sizeof "0x7fffffff"];
这里相当于：
char  buf[11];

括号下标最优先，指向结构体成员；

逻辑非后按位反，自增自减负类型；

指针地址与长度，乘除求余加减法；

左移右移找关系，等不等于按位与；

异或之后按位或，逻辑与或有条件；

赋值号多辈分低，最不优先数逗号。

只要功率足够，砖头也能飞起来！

                                                                                  

函数可重入性及编写规范

使用可重入函数进行更安全的信号处理

如果要对函数进行并发访问，不管是通过线程还是通过进程，您都可能会遇到函数不可重入所导致的问题。在本文中，通过示例代码了解如果可重入性不能得到保证会产生何种异常，尤其要注意信号。引入了五条可取的编程经验，并对提出的编译器模型进行了讨论，在这个模型中，可重入性由编译器前端处理。 在早期的编程中，不可重入性对程序员并不构成威胁；函数不会有并发访问，也没有中断。在很多较老的 C 语言实现中，函数被认为是在单线程进程的环境中运行。 不过，现在，并发编程已普遍使用，您需要意识到这个缺陷。本文描述了在并行和并发程序设计中函数的不可重入性导致的一些潜在问题。信号的生成和处理尤其增加了额外的复杂性。由于信号在本质上是异步的，所以难以找出当信号处理函数触发某个不可重入函数时导致的 bug。 本文： 定义了可重入性，并包含一个可重入函数的 POSIX 清单。 给出了示例，以说明不可重入性所导致的问题。 指出了确保底层函数的可重入性的方法。 讨论了在编译器层次上对可重入性的处理。 什么是可重入性？ 可重入（reentrant）函数可以由多于一个任务并发使用，而不必担心数据错误。相反， 不可重入（non-reentrant）函数不能由超过一个任务所共享，除非能确保函数的互斥（或者使用信号量，或者在代码的关键部分禁用中断）。可重入函数可以在任意时刻被中断，稍后再继续运行，不会丢失数据。可重入函数要么使用本地变量，要么在使用全局变量时保护自己的数据。 可重入函数： 不为连续的调用持有静态数据。 不返回指向静态数据的指针；所有数据都由函数的调用者提供。 使用本地数据，或者通过制作全局数据的本地拷贝来保护全局数据。 绝不调用任何不可重入函数。 不要混淆可重入与线程安全。在程序员看来，这是两个独立的概念：函数可以是可重入的，是线程安全的，或者二者皆是，或者二者皆非。不可重入的函数不能由多个线程使用。另外，或许不可能让某个不可重入的函数是线程安全的。 IEEE STd 1003.1 列出了 118 个可重入的 UNIX? 函数，在此没有给出副本。参见 参考资料 中指向 unix.org 上此列表的链接。 出于以下任意某个原因，其余函数是不可重入的： 它们调用了 malloc 或 free。 众所周知它们使用了静态数据结构体。 它们是标准 I/O 程序库的一部分。 信号和不可重入函数 信号（signal） 是软件中断。它使得程序员可以处理异步事件。为了向进程发送一个信号，内核在进程表条目的信号域中设置一个位，对应于收到的信号的类型。信号函数的 ANSI C 原型是： void (*signal (int sigNum, void (*sigHandler)(int))) (int); 或者，另一种描述形式： typedef void sigHandler(int); SigHandler *signal(int, sigHandler *); 当进程处理所捕获的信号时，正在执行的正常指令序列就会被信号处理器临时中断。然后进程继续执行，但现在执行的是信号处理器中的指令。如果信号处理器返回，则进程继续执行信号被捕获时正在执行的正常的指令序列。 现在，在信号处理器中您并不知道信号被捕获时进程正在执行什么内容。如果当进程正在使用 malloc 在它的堆上分配额外的内存时，您通过信号处理器调用 malloc，那会怎样？或者，调用了正在处理全局数据结构的某个函数，而在信号处理器中又调用了同一个函数。如果是调用 malloc，则进程会被严重破坏，因为 malloc 通常会为所有它所分配的区域维持一个链表，而它又可能正在修改那个链表。 甚至可以在需要多个指令的 C 操作符开始和结束之间发送中断。在程序员看来，指令可能似乎是原子的（也就是说，不能被分割为更小的操作），但它可能实际上需要不止一个处理器指令才能完成操作。例如，看这段 C 代码： temp += 1; 在 x86 处理器上，那个语句可能会被编译为： mov ax,[temp] inc ax mov [temp],ax 这显然不是一个原子操作。 这个例子展示了在修改某个变量的过程中运行信号处理器可能会发生什么事情： 清单 1. 在修改某个变量的同时运行信号处理器 #include #include struct two_int { int a, b; } data; void signal_handler(int signum){ printf ("%d, %d ", data.a, data.b); alarm (1); } int mAIn (void){ static struct two_int zeros = { 0, 0 }, onES = { 1, 1 }; signal (SIGALRM, signal_handler); data = zeros; alarm (1); while (1) {data = zeros; data = ones;} } 这个程序向 data 填充 0，1，0，1，一直交替进行。同时，alarm 信号处理器每一秒打印一次当前内容（在处理器中调用 printf 是安全的，当信号发生时它确实没有在处理器外部被调用）。您预期这个程序会有怎样的输出？它应该打印 0,0 或者 1,1。但是实际的输出如下所示： 0, 0 1, 1 (Skipping some output...) 0, 1 1, 1 1, 0 1, 0 ... 在大部分机器上，在 data 中存储一个新值都需要若干个指令，每次存储一个字。如果在这些指令期间发出信号，则处理器可能发现 data.a 为 0 而 data.b 为 1，或者反之。另一方面，如果我们运行代码的机器能够在一个不可中断的指令中存储一个对象的值，那么处理器将永远打印 0,0 或 1,1。 使用信号的另一个新增的困难是，只通过运行测试用例不能够确保代码没有信号 bug。这一困难的原因在于信号生成本质上异步的。 不可重入函数和静态变量 假定信号处理器使用了不可重入的 gethostbynAMe。这个函数将它的值返回到一个静态对象中： static struct hostent host; /* result stored here*/ 它每次都重新使用同一个对象。在下面的例子中，如果信号刚好是在 main 中调用 gethostbyname 期间到达，或者甚至在调用之后到达，而程序仍然在使用那个值，则它将破坏程序请求的值。 清单 2. gethostbyname 的危险用法 main(){ struct hostent *hostPtr; ... signal(SIGALRM, sig_handler); ... hostPtr = gethostbyname(hostNameOne); ... } void sig_handler(){ struct hostent *hostPtr; ... /* call to gethostbyname may clobber the value stored during the call insIDE the main() */ hostPtr = gethostbyname(hostNameTwo); ... } 不过，如果程序不使用 gethostbyname 或者任何其他在同一对象中返回信息的函数，或者如果它每次使用时都会阻塞信号，那么就是安全的。 很多库函数在固定的对象中返回值，总是使用同一对象，它们全都会导致相同的问题。如果某个函数使用并修改了您提供的某个对象，那它可能就是不可重入的；如果两个调用使用同一对象，那么它们会相互干扰。 当使用流（stream）进行 I/O 时会出现类似的情况。假定信号处理器使用 fprintf 打印一条消息，而当信号发出时程序正在使用同一个流进行 fprintf 调用。信号处理器的消息和程序的数据都会被破坏，因为两个调用操作了同一数据结构：流本身。 如果使用第三方程序库，事情会变得更为复杂，因为您永远不知道哪部分程序库是可重入的，哪部分是不可重入的。对标准程序库而言，有很多程序库函数在固定的对象中返回值，总是重复使用同一对象，这就使得那些函数不可重入。 近来很多提供商已经开始提供标准 C 程序库的可重入版本，这是一个好消息。对于任何给定程序库，您都应该通读它所提供的文档，以了解其原型和标准库函数的用法是否有所变化。 确保可重入性的经验 理解这五条最好的经验将帮助您保持程序的可重入性。 经验 1 返回指向静态数据的指针可能会导致函数不可重入。例如，将字符串转换为大写的 strToUpper 函数可能被实现如下： 清单 3. strToUpper 的不可重入版本 char *strToUpper(char *str) { /*Returning pointer to static data makes it non-reentrant */ static char buffer[STRING_SIZE_LIMIT]; int index; for (index = 0; str[index]; index++) buffer[index] = toupper(str[index]); buffer[index] = '