int(* foo())()
int(* foo())[]
int(* foo[])()

变态的：char * const *(*next)()

更变态的：char *(* c[10])(int **p)

int(* foo())()中，foo应该与右边的()先结合，后与左边的*结合，所以应该是:foo是个函数，它的返回值是个函数指针

int(* foo())[]  //返回值是整型数组的函数指针

int(* foo[])()  //一个返回值是整型的函数指针数组

char * const *(*next)()  //返回值是指向常量字符指针的指针的函数指针

char *(* c[10])(int **p) //一个有10个元素的返回值是字符指针、参数是指针指针的函数指针数组

void (*(*papf)[2])(int);

papf是一个指针，指向一个数组，该数组拥有两个元素，都是函数指针，其函数形式拥有一个int参数，无返回值。

void(*apf[20])(double);

apf是一个数组，拥有20个元素，每个元素都是函数指针，该函数有一个double参数，没有返回值。

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);

“右左法则”[重要！！！]

The right-left rule: Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole declaration has been parsed.

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

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

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

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

阅读步骤：
1. 从变量名开始 -------------------------------------------- fp1
2. 往右看，什么也没有，碰到了)，因此往左看，碰到一个* ------ 一个指针
3. 跳出括号，碰到了(int) ----------------------------------- 一个带一个int参数的函数
4. 向左看，发现一个* --------------------------------------- （函数）返回一个指针
5. 跳出括号，向右看，碰到[10] ------------------------------ 一个10元素的数组
6. 向左看，发现一个* --------------------------------------- 指针
7. 向左看，发现int ----------------------------------------- int类型

总结：fp1被声明成为一个函数的指针的指针的数组，这个数组有10个元素，函数的原型为带一个int类型的参数，返回值为一个指针？

再来看一个例子：

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.

　　考虑数组的指针的时候我们要同时考虑类型和维数这两个属性。换一句话，就是说一个数组排除在其中存储的数值，那么可以用类型和维数来位置表示他的种类。

A）一维数组
　　在c和c++中数组的指针就是数组的起始地址（也就第一个元素的地址），而且标准文档规定数组名代表数组的地址（这是地址数值层面的数组表示）。例如：

int a[10];int *p;

p=&a[0]//和p=a是等价的：

　　因为a是数组名，所以他是该数组的地址，同时因为第一个元素为a[0]，那么&a[0]也代表了该数组的地址。但是我们是不是就说一个数组名和该数组的第一个元素的&运算是一回事呢？在一维的时候当时是的，但是在高维的时候，我们要考虑到维数给数组带来的影响。
　　a[10]是一个数组，a是数组名，它是一个包含10个int类型的数组类型，不是一般的指针变量噢！（虽然标准文档规定在c++中从int[]到int*直接转换是可以的，在使用的时候似乎在函数的参数为指针的时候，我们将该数组名赋值没有任何异样），a代表数组的首地址，在数字层面和a[10]的地址一样。这样我们就可以使用指针变量以及a来操作这个数组了。
所以我们要注意以下问题：

（1） p[i]和a[i]都是代表该数组的第i+1个元素；
（2） p+i和a+i代表了第i+1个元素的地址，所以我们也可以使用　*（p+I）和*（a+I）来引用对象元素；
（3）p+1不是对于指针数量上加一，而是表示从当前的位置跳过当前指针指向类型长度的空间，对于win32的int为4byte；

B)多维数组
　　对于二维数组a[4][6];由于数组名代表数组的起始地址，所以a（第一层）和第一个元素a[0][0]地址的数字是相同的，但是意义却是不同的。对于该数组我们可以理解为：a的一维数组（第一层），它有四个元素a[0]、a[1]、a[2]、a[3]（第二层），而每个元素又含有6个元素a[0][0],a[0][1],a[0][2],a[0][3],a[0][4]，a[0][5]（第三层）,…到此我们终于访问到了每个元素了，这个过程我们经历了：a->a[0]->a[0][0]；
　　整体来讲：a是一个4行5列的二维数组，a表示它指向的数组的首地址（第一个元素地址&a[0]）,同时a[0]指向一行，它是这个行的名字（和该行的第一个元素的首地址相同（第一个元素为地址&a[0][0]））。所以从数字角度说：a、a[0]、&a[0][0]是相同的，但是他们所处的层次是不同的。
　　既然a代表二维数组，那么a+i就表示它的第i+1个元素*（a+i）的地址，而在二维数组中
*（a+i）又指向一个数组，*（a+i）+j表示这个数组的第j+1个元素的地址，所以要访问这个元素可以使用 *（*（a+i）+j）（也就是a[i][j]）。
他们的示意图为（虚线代表不是实际存在的）：

对照这个图，如下的一些说法都是正确的（对于a[4][6]）：

• a是一个数组类型，*a指向一个数组；
• a+i指向一个数组；
• a、*a和&a[0][0]数值相同；
• a[i]+j和*（a+i）+j是同一个概念；

　　总结一下就是：我们对于二维指针a，他指向数组a[0，1，2，3]，使用*，可以使他降级到第二层次，这样*a就指向了第一个真正的数组。对于其他的情况我们也可以采用相同的方式，对于其他维数和类型的数组我们可以采用相类似的思想。

说到指向数组的指针，我们还可以声明一个指针变量让它指向一个数组。例如：

int （*p）[5]；

这时p就是一个指针，要指向一个含有5个int类型元素的数组，指向其他的就会出现问题。
这个时候我们可以使用上面的什么东西来初始化呢？
我们可以使用*a,*(a+1)，a[2]等。
原因很简单：我们在一个二维的数组中，那么表达方式有上面的相互类似的意义呢？只有　*a,*(a+1)，a[2]等，

C)指针数组
　　一个指针数组是指一个数组中的每个元素都是一个指针，例如：

int *p[10];//而不能是int (*p)[10]

或者

char *p[10];

此时p是一个指针（数值上和&p[0]一样）；
在前面有int t[10]；

int * pt=t;//使用pt指向t

那么这里我们用什么指向int *t[10]中的t呢？我们要使用一个指针的指针：

int **pt=t;

　　这是因为：在int *t[10]中，每个元素是指针，那么同时t又指向这个数组，数组上和&t[0]相同，也就是指向t[0]，指向一个指针变量，可以说是一个指针的指针了，所以自然要用

int **pt;

D)指针的指针
　　一个指针变量内部可以存储一个值，这个值是另外一个对象的地址，所以我们说一个指针变量可以指向一个普通变量，同样这个指针变量也有一个地址，也就是说有一个东西可以指向这个指针变量，然后再通过这个指针变量指向这个对象。那么如何来指向这个指针变量呢？由于指针变量本身已经是一个指针了（右值），那么我们这里就不能用一般的指针了，需要在指针上体现出来这些特点，我们需要定义指针的指针（二重指针）。

int *p1=&i;int**p2=&p1；

综合以上的所有点，下面是我们常常看到一些匹配（也是经常出错的地方）：

int a[3],b[2][3],c,*d[3];void fun1(int *p)；void fun2(int (*p)[3]);void fun3(int **p);void fun4(int p[3]); void fun5(int p[]);void fun6(int p[2][3]);void fun7(int (&p)[3]);

函数 不会产生编译时刻的可能值（但逻辑上不一定都对）

为什么可以有这样的搭配，原因如下：

• 对于fun1 fun4 fun 5: 在编译器看来fun1,fun4,fun5的声明是一样，在编译时候，编译器把数组的大小舍去不考虑，只考虑它是一个指针，也就是说有没有大小说明是一样的，所以三者的形式都是fun1的形式（其实只要提供了int*指针就可以了）；
• 对于fun7 ：以上的解释对于引用是不适用的，如果变量被声明为数组的引用，那么编译器就要考虑数组的大小了，那么必须和声明一模一样（所以fun7就只有a合适）；
• 对于fun2：p是一个指向一个含有3个元素的数组，这样b和b+i正好合适，而a却不是（它是指向a[0]的，不是指向这个数组的）；
• 对于fun3：p是一个指针的指针，而d指向d[0]，同时d[0]又是一个指针，所以d就是一个指针的指针。但是b却不是（它是一个2*3的矩阵也就是年int [2][3]类型）；
• 对于fun6，p是一个2*3的数组类型，和b恰好完全匹配；
  

A) 函数指针
　　C++规定，一个函数的地址就是这个函数的名字。我们需要指出的就是一个指针需要指定类型是为了后来的指针解析时候使用，通过指针有效快速访问对象。那么对于函数的指针，它要表示出该函数的那些特性才能满足解析的唯一性呢？答案就是一个函数的特性有它的参数列表和返回类型。

下面是一个函数指针的例子：

int (*p)(int I,int j);

不能是

int *p(int I,int j)，

这样就变成了返回指针的函数声明了。

　　在C++中处于对安全性的考虑，指针和它指向的对象要类型一致，也就说上面的指针所指向的函数的特性要和它一模一样：例如指向int min(int I,int j)；是可以的。但是指向int min(double I ,double j);是不可以。函数指针也和其他的指针一样，在使用的时候很怕发生"悬空"，所以在使用的时候同样要判断有效性，或者在定义的时候就初始化。

int (*p)(int I,int j)=min;int (*p)(int I,int j)=&min;int (*p)(int I,int j)=0；

B) 函数的指针参数
　　函数指针可以作函数的参数：例如我们有一个积分的算法，对于不同的数学函数可以进行积分（我们这里假设函数都是一元的）；
那么我们的算法接口可以定义为：

template<class T>T integrate( T lower, T upper , T (*)(T)=0 )throw(integrated_exp);

　　这里的最后的参数是一个函数的指针，并且被设定缺省值为0。这个函数返回一个值，同时需要一个参数。假如加入我们有这样的一个函数：

double line(double x){ return a*x+b;}

那么我就可以使用了。

函数指针还可以作为返回类型（注意不是函数！！，某个特定的函数是不可以作为返回类型的。）假设：

typedef int (*PF)(int );PF getProcessMethod( );//true

C) 返回指针的函数
　　一个函数的返回是函数的重要接口之一，c++的一个重要的强大的功能就是能够设计足够复杂和好用的用户自定义类型。而同时处理和传递这些类型也是很麻烦的一件事情，我们不想把我们的时间都花在这些对于我们的实际工作没有很实质帮助的拷贝上，解决这个问题就要依赖我们的接口设计：c和c++都提供了相应的解决方案，在c++中我们可是使用引用，讲他们作为函数的实际参数，或者我们在函数的实际参数中使用一个指针等。同样我们还可以使用一个函数返回一个指针：但是这是一个很不好解决的问题！
我们首先容易出错的是：将一个局部变量的地址传出来！例如：

UserType * Process( ){　　UserType ut(param-list);　　//process ut;　　return &ut;//}

　　这个变量在我们的函数结束的时候就被销毁了，尽管地址可以传出去，但是这个地址已经不存在了，已经不能使用的东西，在这个函数之外却不知道，难免要出错！
同时我还会有一个比较麻烦的问题：使用new，又容易造成内存泄露

UserType * Process ( ){　　UserTpye *put=new UserType(param-list );　　//process put;　　return put;}

我们在函数内部使用了一个new，分配了一个空间，这样传出来也是可以！
　　就是说不会发生上面的问题了。但是用户通常都会忘记在程序的外面在把这个借来的空间还回去！内存空间就这样泄露了！
可能也是这些另人无奈的问题，所以很多程序员把函数的参数设定为指针或者引用，以此来代替这种向外传输吧！总之，使用这种返回指针的函数要小心！

三、类成员的指针

　　类成员和一般的外部变量相互比较，不同就是它所在的域不同，这个域很重要，它决定了该变量可以使用的范围。那么一个指针如果要指向类的成员函数或者成员变量，那么除了要表达它的返回类型、参数列表或者类型之外，那么还要说明它所指向的变量（或者函数）的域，为了说明该域我们要使用类域限定：

class NJUPT{　　static double money=20000000;　　int num;　　public:　　NJUPT():num(10){};　　int get(){return num;};　　double getMoney(){reuturn money;}}

我们定义成员的指针为

int NJUPT:: *p;//指向int型成员变量int (NJUPt::*)p()//指向int f()型成员函数。

为了使用这些指针，我们需要使用该类型的变量或者指针。

NJUPT s,*ps;

那么调用的方式为：

cout<<s.*p;cout<<(s->*p)();

　　这个看起来似乎很奇怪！但是只要你想到我们定义的指针被限定在了类域中了（我们在开始定义的使用使用了NJUPT:: ），这么使用也是很自然的。
　　如果一个类还有一些静态成员变量和静态成员函数，那么我是否也想这样使用呢？
答案是不用，静态成员我们就可以象使用外部的普通成员一样定义一个指针或者函数指针来访问就可以了，究其原因主要是这个成员的类型性质决定的。

关于函数指针和类型

C++语言本质上由两部分组成：数据和代码。编程语言主要关注于操作数据，它可以对数据进行最精细的调整，但一般并不关心生成什么样的代码。事实上代码的具体形式是由编译器控制的，编程语言只要求完成相应的功能。

数据分数据类型和数据实例，前者是数据的格式，后者是数据在内存中的实体。当我们定义了一个数据类型时，同时也自动生成了一个相应的指针类型，所以没有必要再显式的声明一个指针类型。而对于函数类型则并非如此。首先函数类型的数据类型的一个显著不同是：同一数据类型不同实例可以有不同的数据值，每一个实例的大小是确定的；而同一函数类型的不同实例是不同函数代码，它的大小是不确定的，甚至，C++并不关心函数的大小，编译器自动生成具体的代码。我们可以一下子声明一系列同一类型的数据（比如数组声明），然后再对实例进行操作。但我们无法一下子声明一系列的函数实例，必须对每一个函数实例一一定义。

C++的指针类型大小是固定的。指针就象实例对象的名字，每一个实例都有一个唯一的名字，这个名字其实就是实例在内存中的位置。因为对计算机而言，内存大小是有限制的，从而可以生成的实例数量也是有限制的，那么它们的名字是可以用一个固定长度的整数来表示的（这个值不会大于内存的最大值）。函数指针也不例外，它也是函数在内存中的位置，具有相同的内存长度。一般来说，我们调用的函数名就是这个函数实例的指针。我们可以声明一个函数的指针类型，它是由函数的参数和返回值构成的，也就是说，只要函数的参数和返回值相同，就可以看作相同类型的函数（这里先不考虑调用方式的区别）。

如果函数指针是函数的指针类型的实例，那么什么是函数的类型呢。本质上C++没有函数类型的概念，我们常说的函数类型是指函数的指针类型。但是一方面为了和数据类型保持一致，更重要的是实际的需要，我们确实应该定义函数的类型。

在提及函数类型的一个应用之前，我们不得不讨论一下类的成员函数。类（class或struct）本质上是一个数据类型，它的实例是一系列特定格式的数据。而它的成员函数并不纳入类的大小尺度的计算。因为不管是静态函数还是成员函数，它们都在内存中有固定的位置，这个位置和类的实例没有任何的关系。类的成员函数和普通的函数也没有任何的不同。当然，这是对编译器而言，对程序员来说，并非如此。C++语言中调用一个类的成员函数，意味着这个函数可以访问这个实例的成员变量，而且不用显式的在参数中传递这个实例的指针。但实际上，对编译器而言，调用一个类的成员函数，就是调用一个普通的函数，只不过多传递了一个实例指针。正如a.Func()和Func(&a)这两种形式，只不过书写形式不同而已（Func是一个普通函数，但比a.Func多一个参数）。换言之，即使C++没有成员函数的概念，我们几乎可以编出同样功能的程序，我们可以把一个类的成员函数以类名为前缀（容易识别），声明为一系列的普通函数，这些函数的第一个参数都是一个对应类的指针类型。当我们需要调用类的成员函数时，只要调用特定的函数，并且传递实例的指针作为第一个参数。

当然C++类的成员函数有它的方便之处，这就是我们使用它的原因。而且C++有类的成员函数指针的概念，但就C++本身来说，简直是多此一举。下面是一个类的成员函数的类型声明：

typedef int (A::FUNC)(int);

FUNC是A类的一个成员函数的指针类型，那么什么函数的指针可以是这个类型呢？首先它必须是A的成员函数（这正是问题的所在），然后它必须是一个有一个int类型参数且返回int类型的函数。假设Func是一个满足此条件的函数，

FUNC func = A::Func；

在VC 8.0中要求用以下格式:

FUNC func = &A::Func；

如何调用func呢？首先既然是类的成员函数，一定要指明是哪个实例在调用它，

A a;

A* pa = &a;

int i = (pa->*func)(3);

也就是说必须有类A的一个实例指针pa，但是，我们既然有pa，为什么不用(int i = pa->Func(3))这种形式呢？

如果仅限于此，我想类的成员指针是没有多大用处的。当然，C++允许对成员函数指针进行转换，这种转换必须是在成员函数指针之间，不能转换为普通函数的指针。如果我们使用类的成员函数指针，大多是因为调用者并不知道这个指针是哪个类型的，但是知道它的参数和返回值，并且有一个实例的指针。事实上，对于函数调用来说这就足够了。但是C++不这么认为，它一定要知道那个实例指针的类型，这是有原因的，指针的类型直接控制成员变量的访问方式。成员函数在执行时，可能会访问实例的数据成员，而这种访问是由实例指针传递的，如果传递了一个不正确的指针，就可能造成内存访问错误。

模拟Windows回调函数的机制，假设一个类Control需要把事件通知外部的一个A类。而且这个类(Control)是封装好了的，它要通知的类的类型是不确定的。我们不能在实际使用时，再回头更改代码。一种解决方案是声明一个通用类Common，它没有数据成员，甚至不必实例化，但是它有特定的成员函数正好符合要通知的信息的格式，但这些成员函数没有必要有代码，总之一切只是为了应对C++的类型检查，我们只是使用这个类的类型，不使用它的任何实际的东西。在封装类Control的内部声明一个Common指针pc，再声明一个Common的成员函数指针cf。这样，只要把要接收信息的类的指针传递给pc，再把相应格式的成员函数指针传递给cf，Control类只要调用(pc->*cf)(param)，就可以把信息传递给任何外部的类。对于静态函数，可以不必给pc赋值（或赋任何一个值），但C++不允许把一个静态函数的指针传递给cf，但是可以用一些技巧性的转换。实际情况比这要复杂，还要考虑虚函数，虚继承等。

这个解决方案还有一个重要的问题，就是如果pc和cf传递了错误的值，后果会非常严重。这有两方面：cf并不是pc的成员，cf不是一个对应类型的函数。以下是这个问题的一个解决方案：

template<typename R,typename T> void SetFuncPointer(R* pr,T func)

{

     typedef void (R::*FUNC)(TYPE1,TYPE2);

     FUNC Func = func;

     ………….

}

当func不是FUNC类型，或不是R类型(这个类型由pr参数确定)的成员函数时，这个函数一定会编译报错。而且省去了类型转换的麻烦。

但是在FUNC定义的那一行，对于不同函数，是不同的。我们希望有一个更通用的定义方式，把这个定义抽象化，公式化，而无须每一种函数都不得不写下定义式。比如以下的形式：

typedef R::*FUNCTYPE FT;(C++中并没有这个语法)

其中FUNCTYPE是代表函数参数和返回类型的标识，FT是与之对应的类的成员函数指针定义（格式相同的函数，但是是成员函数）。

事实上，是否定义函数的类型概念并不是根本的，对函数而言，指针类型完全可以代表函数的类型。数据需要数据类型和指针类型是因为我们需要定义相应类型的实例，而对函数来说，它的实例定义本身也就定义了一种隐含的类型（并不需要先有类型才可以定义）。这一方面省去了定义类型的麻烦，但在使用它的类型时，又不得不翻回头来重新定义。所以为了统一和方便，还是加入函数类型概念比较好，以下是一个示例语法：

typedef FUNC (void,int);//第一个参数表示返回类型。

FUNC就是定义的函数类型，它是一个返回void类型，有一个int类型参数的函数。关于函数的返回类型，事实上并不规范。函数的返回值，本质上是一个out参数，也就是一个无须初始化，无须定义的参数。它与其它参数没有本质区别，它不需声明，是因为编译器只是把这个值存在eax寄存器中。函数没有返回值机制，仍然会工作的很好。不过鉴于函数的返回值是数学和其它领域的普遍规范，还是保留这种形式。

允许函数的类型定义自然有一个问题。如果两个函数类型定义参数相同，那么它们是否是一种类型呢？现在的C++对于函数类型指针的规定是可以自由的赋值无须显示转换。这一点和数据类型是不一致的，对于数据结构完全相同的类，事实上是可以通用的，尽管这时，它们的成员的名称可能不同。出现这种规定是自然而然的，但不是必须的。至少它们是可以直接相互赋值的。

程序员常常需要实现回调。本文将讨论函数指针的基本原则并说明如何使用函数指针实现回调。注意这里针对的是普通的函数，不包括完全依赖于不同语法和语义规则的类成员函数（类成员指针将在另文中讨论）。

声明函数指针

   回调函数是一个程序员不能显式调用的函数；通过将回调函数的地址传给调用者从而实现调用。要实现回调，必须首先定义函数指针。尽管定义的语法有点不可思议，但如果你熟悉函数声明的一般方法，便会发现函数指针的声明与函数声明非常类似。请看下面的例子：

void f()；// 函数原型

上面的语句声明了一个函数，没有输入参数并返回void。那么函数指针的声明方法如下：

void (*) ();

   让我们来分析一下，左边圆括弧中的星号是函数指针声明的关键。另外两个元素是函数的返回类型（void）和由边圆括弧中的入口参数（本例中参数是空）。注意本例中还没有创建指针变量-只是声明了变量类型。目前可以用这个变量类型来创建类型定义名及用sizeof表达式获得函数指针的大小：

// 获得函数指针的大小
unsigned psize = sizeof (void (*) ());

// 为函数指针声明类型定义
typedef void (*pfv) ();

pfv是一个函数指针，它指向的函数没有输入参数，返回类行为void。使用这个类型定义名可以隐藏复杂的函数指针语法。

指针变量应该有一个变量名：

void (*p) (); //p是指向某函数的指针

   p是指向某函数的指针，该函数无输入参数，返回值的类型为void。左边圆括弧里星号后的就是指针变量名。有了指针变量便可以赋值，值的内容是署名匹配的函数名和返回类型。例如：

void func()
{
/* do something */
}
p = func;

p的赋值可以不同，但一定要是函数的地址，并且署名和返回类型相同。

传递回调函数的地址给调用者

   现在可以将p传递给另一个函数（调用者）- caller()，它将调用p指向的函数，而此函数名是未知的：

void caller(void(*ptr)())
{
ptr(); /* 调用ptr指向的函数 */
}
void func();
int main()
{
p = func;
caller(p); /* 传递函数地址到调用者 */
}

   如果赋了不同的值给p（不同函数地址），那么调用者将调用不同地址的函数。赋值可以发生在运行时，这样使你能实现动态绑定。

调用规范

   到目前为止，我们只讨论了函数指针及回调而没有去注意ANSI C/C++的编译器规范。许多编译器有几种调用规范。如在Visual C++中，可以在函数类型前加_cdecl，_stdcall或者_pascal来表示其调用规范（默认为_cdecl）。C++ Builder也支持_fastcall调用规范。调用规范影响编译器产生的给定函数名，参数传递的顺序（从右到左或从左到右），堆栈清理责任（调用者或者被调用者）以及参数传递机制（堆栈，CPU寄存器等）。

   将调用规范看成是函数类型的一部分是很重要的；不能用不兼容的调用规范将地址赋值给函数指针。例如：

// 被调用函数是以int为参数，以int为返回值
__stdcall int callee(int);

// 调用函数以函数指针为参数
void caller( __cdecl int(*ptr)(int));

// 在p中企图存储被调用函数地址的非法操作
__cdecl int(*p)(int) = callee; // 出错


   指针p和callee()的类型不兼容，因为它们有不同的调用规范。因此不能将被调用者的地址赋值给指针p，尽管两者有相同的返回值和参数列。

自己总结的，觉得能帮助初学者看透一些纷繁复杂的语法规则，理解C语言的真谛
第一次发布，不一定正确，欢迎讨论、指正、补充

1. 表达式定律

任何能产生数值结果的运算、操作都可以作为表达式，并可以放到任何需要数值结果的地方，只要数值类型能够匹配

常见的可以产生数值结果的运算和操作

• 算术、逻辑、位运算等
• ? :
• &、*等操作
• 有返回值的函数

 常见的需要数值的地方有：

• 赋值
• 条件判断
• 函数调用

2. 类型定律

任何类型都可以在任何需要类型的地方使用；用任何类型定义的变量都要占用内存

已知特例

• 函数返回值不能定义为数组类型

常用类型

• 基本数据类型、指针、数组、结构……

常见的需要类型的地方

• 定义变量
• 定义指针、数组和结构
• 函数参数和返回值
• sizeof

3. 参数传递定律

函数调用时的参数传递永远都是传值调用，把实参的值拷贝给形参

• 实参：调用者提供的参数
• 形参：函数定义的参数
• 基本数据类型无容置疑
• struct也无容置疑
• 指针作为参数时，把指针变量的内容（就是其指向的内存地址）做了拷贝
• 数组名作为参数时，把它等同于指针看待了

原文：
http://www.codeproject.com/cpp/complex_declarations.asp
作者：Vikram A Punathambekar

介绍

曾经碰到过让你迷惑不解、类似于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型变量的指针。我想在这里展开讨论一下：我觉得在声明一个指针（或引用）类型的变量时，最好将*（或&）写在紧靠变量之前，而不是紧跟基本类型之后。这样可以避免一些理解上的误区，比如：

int*   p,q;

第一眼看去，好像是p和q都是int*类型的，但事实上，只有p是一个指针，而q是一个最简单的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);

“右左法则”[重要！！！]

The right-left rule: Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole declaration has been parsed.

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

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

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

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

阅读步骤：
1. 从变量名开始 -------------------------------------------- fp1
2. 往右看，什么也没有，碰到了)，因此往左看，碰到一个* ------ 一个指针
3. 跳出括号，碰到了(int) ----------------------------------- 一个带一个int参数的函数
4. 向左看，发现一个* --------------------------------------- （函数）返回一个指针
5. 跳出括号，向右看，碰到[10] ------------------------------ 一个10元素的数组
6. 向左看，发现一个* --------------------------------------- 指针
7. 向左看，发现int ----------------------------------------- int类型

总结：fp1被声明成为一个函数的指针的指针的数组，这个数组有10个元素，函数的原型为带一个int类型的参数，返回值为一个指针？

再来看一个例子：

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.

掌握了方法之后,对与一门新语言的学习,就只剩下该语言区别于你所熟悉的语言的一些特殊语法和这门语言的一些特殊机制而已.


一、英语对于编程重要吗？

有些人问：英语对于编程重要吗？那你就看看下面的例子就知道了：

6d61696e(){
	7072696e7466("你好啊，世界！");
}

好吧，这是一个C语言Hello world! 但它不能用TC或者BC等编绎器编绎----会出错。为了能把它编绎，你再请一个“用英语”编程的人帮你编个程序，将上面的程序转为TC和BC可以认识的 源代码。转换过程很简单，因为在ASCII码中，m=6d, a=61, n=6e, p=70, r=72, i=69, t=74, f=66， 以上都是十六进制数值。

这种“程序”，就算你不会英语也会编出来吧？就算你不会英语也不会妨碍你成为高手吧？因为所有人都能轻易学会0-9和a-e。

我曾经看到有人用中文“编写”C语言程序----把main换为“主函数”，把int换为“整型”，把printf换为“打印”......，就是：

主函数(){
	打印("你好啊，世界！");
}

我认为这种方法不比我的方法好，因为别人还得学习汉字。我的方法即使是中文文盲也能很容易学习。

我的意思是，中文编程不是简单的将英文单词“一一对应”地翻译为中文名词就行了，而应该是发明出一种符合“汉语思维”的编程方法。这种“一一对应” 的中文编程只不过是一种无聊的作法。在各种编程语言的函数库和类库中，都是以英文词汇（或者26个英文字母，数字，下划线的组合）命名，当然你也可以把它 们全都翻译为表示中文意思的中文词汇，或者按照我所说的方法翻译，然后就可以“使用中文（或者不使用英语）编程”了，可是，这有什么意义？

所以，结论是：英语对编程很重要。

二、编程语言和编程思想

这么多年来，我学过和使用过的开发语言也不少了，可真正用得好一点的就只有 C 。有一段话很流行，直到现在类似的想法还影响了很多人。“做程序员 , 学习程序语言最重要的是学习编程思想 , 而不是学习那种语言”。我曾经把这段话奉为经典。在做程序员的初期，频繁更换编程语言，这是一个重要原因，另一个重要原因是，如果不会新的语言，就显得落后了。因此流行的语言基本都涉及过，买书的钱都以千计。随着代码数量的增加，经验的增长以及对于业务了解程度的深入，自然产生了一些想法、思路和设计。

我举的一个例子，开发过数据库的人大概都有所体会。数据库应用中常常需要构造 SQL 语句，但在程序中写 SQL 语言以及对返回结果集的处理，这往往是个体力活，特别是在嵌入式 SQL 的编程中。重复地拷贝一段颇长代码，再修改一点点，整个程序大量的篇幅都耗在这上面了，维护起来也比较困难。我想很多人都针对此想过了很多的方法来简化这些甚是无趣的操作。我也想过好些方法，其中一个方法比较有趣。在 C 语言中有一个很常用的函数是 int sscanf(const char *str, const char *format, ...) ，用起来颇为简便。我想仿照这个函数的来处理 SQL 语言的 select ，因此就定义了一个获得一条记录的函数： ifx_select(const char* sql,…); 使用起来非常简便：

int id;

char name[16];

…

if(ifx_select(“select id,name from users where id=10”,&id,name)==0)

…

这是一个很好的点子，也是很好的编程思想。但开工后，我发现我实现不了。虽然这段代码看上去很简单，但它包含的东西却不少：变参数的处理，指针及其内容的赋值，错误处理，数据类型判断与分析等等。这些东东都学过，但在实际工作中却不能灵活运用，想法和思路自然实现不了。类似的现象不仅仅大量出现在程序设计中，在现实生活中也比比皆是。

由此，下决心好好补了补课。把教科书又翻了几遍、阅读了很多开放源码的程序、在平时的编程中投入一部分精力到 C 本身的研究中，经常感叹，原来 C 语言还可以这样用。随着对语言本身（语法、技巧、组合等等）的越来越熟悉，自己的很多思路和想法也得以顺利实现。到目前语言和思想已经密不可分了，以上的代码自然搞定了。当然这是一个长期的过程，不可一蹴而就。时间一般以年计算。

讲了这么多，我的观点也很明确，编程的语言和编程的思想同样重要，扎实的编程语言功底是编程思想得以顺利的实现的基础，二者缺一不可，相互制约也相互促进。就象人的灵魂和肉体。对于一个人来说，若只管灵魂而不管肉体，那是“鬼”；如只管肉体而不管灵魂，则会被称为“行尸走肉”。基本工具都用得不好，用得不熟，很难期待会出现一个好产品；有一个好的编程想法，却因为编程语言的能力不够而不能实现，那么这个好的想法就只是“空想”，开发者容易被划归到“眼高手低”、“不切实际”、“不踏实”的一类中去。

另外在选择和学习编程语言上，最好根据需要选择一门主流的、应用广泛又有强大生命力的编程语言，例如 BASIC 、 FORTRAN 、 C/C++ 、 JAVA 等。语法学习相对容易，关键在于熟练应用。理想境界是达到卖油翁的程度：“无它，唯手熟而”。

三、编程高手谈编程

编程并非高深莫测

　　李晓东 e－BOOK 电子小说阅读器作者（http://eb.126.com)
　　要想学好编程，没有什么捷径可走，只有多动手，敢于动手，看完一本厚厚的编程书，学习效果也肯定比不上亲自上机设计一个简单的程序。就拿我来说吧，其实我很早就想学VB了，在我的电脑中也多次安装过VB4和VB5，可我一直没有动手，也许是因为缺乏某种紧迫感吧。直到去年10月份，我在用VFP设计一个文本阅读器（e－BOOK的前身）时，越来越感到VFP无法满足我的一些特殊要求，于是我又想到了VB，终于，我捧起一本VB3的编程手册（当时我只能找到这本VB编程书了），在VB5中敲下了第一个键。半个多月过后，e－BOOK1.01版诞生了！在此，我要对想学编程的朋友说一句：编程并非高深莫测，只要你敢于迈出关键的第一步，你就入门了。
　　另外，编程书还是要看的，但不必强求最新、最全、最多，够用、适用就行。就我个人来说，我有汇编基础（当然也是自学的），这对我现在的编程有很大帮助（尽管在Windows时代汇编语言已无用武之地）。对广大编程爱好者来说，则要系统地掌握一些底层的东西，比如显卡显示图像的原理、硬盘存储文件的方式、内存管理机制等，这些知识尽管不能直接用到程序中去，但对你理解程序的运行流程、找出发生问题的原因等方面还是很有好处的。我编程的长处在于界面设计（e－BOOK就是明证）。我觉得，在Windows中编程，最容易体现个性的就是界面设计，在千篇一律的灰色窗口＋菜单栏＋工具条＋状态条＋滚动条的模式下，只要你敢于打破这个框框，你的程序就很容易脱颖而出（当然内在的东西也要足够好）。
选择方便快捷的方案

　　杨延哲 E－port软件小组成员 http://e－port.yeah.net
　　我从学习编程到现在不多不少三年半，这期间学的东西很杂，首先是从QBASIC开始，后来学上了VisualBasic，再后来学校里教了TurboPascal。现在我才认定了Pascal，跟了Delphi。其他的语言像C＋＋我也学过，但没人教再加上已经弄懂了Pascal，所以就放弃了。
　　Delphi编程的最大好处就是它的控件，它将编程变成了一件快乐的事。因为在编程过程中唯一的快感就是看到自己的程序在运作了，而Delphi就给了编程者这个感觉。这对于我们这些写小程序的人来说特别有帮助，可以将编程时间降到最低。
　　我的编程忠告就是：如果你遇到了大的问题，解决方法有许多种。为了避免走弯路，先选择最方便的快捷方案，这样即使无法执行也不会太浪费时间。用专业的讲法就是Shortest Job First。
创意是软件的灵魂

　　张研 Update NOW!的软件作者 (http://nowsof.yeah.net ，thttp://www.ourchina.net/)
　　1.基础比语言更重要
　　以前有一句很有名的话：“算法＋数据结构=程序"，后来有人批评这种说法，但不管怎样，算法和数据结构的重要性可见一斑。而语言则显得不那么重要了。语言只是算法的表达方式，就拿排序来说吧，C语言用的是那些方法，Pascal也是，Java也一样。只是表达的方法不同。“万变不离其宗"，所以说要想成为一个好的程序员，算法和数据结构是最基础的。
　　2.精通一门适合自己的语言
　　现在流行的语言很多，Visual Basic、Visual C＋＋、JAVA、 Delphi等。同时新语言层出不穷。谁也不可能都会。怎么办?最好只选择一门语言，集中精力钻研，精通它。没有一门语言是万能的，有算法和你精通的那门语言做基础，学一门新的语言是件轻松的事。
　　3.熟悉你使用的操作系统
　　同一种语言在不同操作系统中，会略有不同。比如Windows 下的C和Unix 下的C是都是C语言的超集。这些不同，正是我们所关心和应该潜心研究的。只有这样才能写出有特色的程序。
　　4.熟悉你使用的硬件系统
　　不了解硬件系统，很难写出好的程序。所以好的程序员，对硬件的了解都很深。
　　5.容错是很重要的
　　容错性能的好坏是评价一个程序是否专业的重要标志。好的程序员会写大量的代码让程序更“坚固"。Update NOW!的核心代码中有20％～30％是用于容错的。
　　6.好的程序书写风格是必要的
　　书写程序按照语法的层次缩进，是衡量程序员是否专业的一个标准。当然，还要有必要的注释。否则，过了几个月，你都很难读懂自己的程序了。
　　7.创意是软件的灵魂
　　好了，如果你作到了上面那几点，那你差不多是个好程序员了。最后要说的就是创意。没有创意的软件，只是重复劳动。即使容错再好，风格再好也没有用。回头看看，那些出色的软件都有独到之处。如果你既是个好程序员又能写出有创意的软件，那你差不多就是大师了。　　　　　　　　　
语言只是工具

　　梁肇新《超级解霸》的作者（http://www.herosoft.com/）
　　1.如何成为程序员
　　要成为高手程序员首先必须有丰富的计算机知识，包括软件系统知识和硬件系统知识，掌握一种高级编程语言如C/C＋＋和掌握汇编语言，这是成为程序员高手的必备条件。一般人都会认为语言最重要，其实语言只是工具而已，重要的是如何使用工具做自己想做的事，
　　2.如何学习编程
　　我的建议是从API入手，因为API是操作系统提供的直接接口，其他的任何东西都是在这之上，像VB和Delphi这样的开发工具尽量隐含API的内容，同时也阻隔了成为高手的机会，因为编出来的“程序”无法了解它的执行过程也就使编程中最重要的“可预测”性变得很低。
　　编程序的重点不是“编”，而是调试程序，理论上的完美在实现的时候会遇到很多细节问题，这些问题必须调试才能解决。我的编程习惯是一天写五天调试，《超级解霸》就是调试出来的，而不是写出来的。调试就涉及到汇编的问题，不进行汇编级的调试是不彻底的，也不能让人放心。
　　3.编程忠告
　　我的编程经验是，编程时除了调试外还应该测试，测试是指把要完成的程序的单个功能写一个测试实验，成功后再加到软件中来。任何软件都是小功能组成的，因此不要像课本所说的那样先写个程序框图来浪费时间，而是先单个实现局部功能再组装在一起。编程时千万不要盲目使用不了解的代码，否则会增加程序的出错机会。了解底层会增加编程思路。

四、编程语言学习随笔

近来一直在学习c++，原因很简单，就是喜欢编程！！！
学习之余，若有所思，记录在此，或许N年后回首，会有更多感触！！
编程最重要的是什么？－－－－－是解决问题的思路和方法！
那么编程语言在这里扮演一个什么角色呢？－－扮演的是把你的思想和方法转化为现实的一种工具！！仅仅是工具而已！
学习编程语言，就像我们学习认字、写字一般。解决问题的思路和方法，我们活到这个年岁上，都肯定有一些了，只不过是多少、优庸之分而已！但是并非每个人都能用程序来体现，因为很多人没有掌握这个工具，就好像会说话当不会写字的人，虽然有很多话要说，但是不会写字，从而不能把想法写下来，让更多的人分享。掌握了编程语言，就可以和机器交流，，让机器懂得我们要想做什么。但是，，并非每个会写字的人都能写出好文章来！！！
     我想说的，其实只有一点，，工具的东西是必须掌握的，但是工具仅仅是工具，不要沉迷于工具而忘了最重要的东西！！！

五、闲言碎语话编程

     有人说：编程高手==游戏高手。如果这是真的话，我早就成高手了，因为在游戏里，我早已成为宇宙总管、富甲天下、仗剑走天涯了。可是我还是一个菜鸟：）闲来无事，随便贴点文章。
    程序员不应依赖开发工具，程序员更应该拥有的是一种思维、一种精神、一种观念。就像Richard.M.Stallman一样，有自己的精神，为自由软件而奋斗。就像求伯君，为民族软件的振兴而奋斗。这才是真正的程序员。
    应该说，他们更注重的不是技术，而是软件的思维，软件的灵魂！！
    真正在编写程序到达一定时候，语言的使用并不是最大的障碍，对整个项目的把握、软件工程的把握、数据库的设计以及执行效果的分析等等才是需要进一步考虑的东东！
    学习编程其实与学习其它东西一样,要想掌握它,就要实践,实践,再实践.当你学到了一种新的技术或知识时,多实践是巩固学习的一种最好最有效的方法。
    这个实践不是照著书上的例子做一遍,而是根据自己的能力,给自己出题,然后去完成 它.只有这样,你才能发现自己的不足,同时又增加了自己的编程经验. 但要成为合格的程序员,光会写代码是远远不够的,更重要的和学习其他知识一样，重要的是获得提出问题，分析问题，解决问题的能力，不是为编程而学习，你具有什么样的思想，就会写出什样的程序。学一门语言，不能仅仅是语言，要注重语言背后的思想方法是思考.谋定而后动,是 不变的真理。