一个函数在编译时被分配一个入口地址，将这个入口地址称为函数的指针，可

　　　　　　以用一个指针变量指向该函数指针，然后通过该变量来调用函数。

　　　　　　有关说明：

　　　　　　1、函数指针的声明格式：

　　　　　　　 函数返回值类型（＊指针变量名）（参数类型列表）

　　　　　　   或者是：

　　　　　　   typedef　函数返回值类型　（＊指针变量名）（参数类型列表）

            2、一个函数指针只能指向一种类型的函数，即具有相同的返回值和相同的参　　　　　　　　　　　　

　　　　　　　 数的函数

　　　　　　３、关于函数指针的加减运算没有意义

　　　　　　 函数指针数组定义：

             函数定义：

             void fun1(void *p);

             void fun2(void *p);

             void fun3(void *p);

　　　　　　 函数指针数组定义：

　　　　　　 void(*fun[3])(void*);//typedef void(*pfun)(void*);pfun fun[3];

　　　　　　 指针赋值：

             fun[0] = fun1;

             fun[1] = fun2;

             fun[2] = fun3;

             函数调用：

　　　　　　 fun[0](&a);         //int a;

             fun[1](&b);         //int b;

             fun[3](&c);         //int c;

          声明一个指向成员函数的指针

一个指向成员函数的指针包括成员函数的返回类型，带::符号的类名称，函数参数表。虽然这一语法看似复杂，其实它和普通的指针是一样的。指向外部函数的指针可如下声明：

void (*pf)(char *, const char *);
void strcpy(char * dest, const char * source);
pf=strcpy;

相应指向类A的成员函数的指针如下表示：

void (A::*pmf)(char *, const char *);

以上pmf是指向类A的一个成员函数的指针，传递两个变量char *和 const char *，没有返回值。注意星号前面的A::符号，这和前面的声明是一致的。

赋值

为了给一个指向成员函数的指针赋值，可以采用成员函数名并再其前面加一个&的方式

使用typedef

你可以使用typedef来隐藏一些指向成员函数的复杂指针。例如，下面的代码定义了一个类A中的成员函数的指针PMA，并传递char *和const char *参数。

typedef void(A::*PMA)(char *, const char *);
PMA pmf= &A::strcat; // use a typedef to define a pointer to member

使用typedef特别有用，尤其是对于指向成员函数的数组指针。

■       void类型的指针

void含义：

void是“无类型”，void*则为无类型指针，void*可以指向任何类型的数据。

void a；//此变量没有任何实际意义，无法编译通过“illegal use of type”

void 的作用：

     1、对程序返回的限定

     2、对函数参数的限定

我们知道，如何指针p1和p2的类型相同，那么我们可以直接在p1和p2间赋值，如果不同，必须使用强制类型转换。

如：float *p1;   int *p2;

若：p1 = p2; 编译出错：“can not covert from int* to float*”

必须为：p1 = (float*)p2;

            而void*不同，任何类型的指针都可以直接赋为它，不需要强制类型转换：

            如：void *p1;   int *p2;

                可作：p1 =p2;

                无类型可以包容有类型，有类型不能包容无类型：

                必须为：p2 = (int*)p1;

            viod 和 void*使用规则总结：

●     如果函数没有返回值，那么应声明为void类型

在C语言中，凡不加返回值类型限定的函数，就会被编译器作为返回整型值处理。但是许多程序员却误以为其为void类型. 林锐博士《高质量C/C++编程》中提到：“C++语言有很严格的类型安全检查，不允许上述情况（指函数不加类型声明）发生”。可是编译器并不一定这么认定，譬如在Visual C++6.0中上述add函数的编译无错也无警告且运行正确，所以不能寄希望于编译器会做严格的类型检查。

因此，为了避免混乱，我们在编写C/C++程序时，对于任何函数都必须一个不漏地指定其类型。如果函数没有返回值，一定要声明为void类型。这既是程序良好可读性的需要，也是编程规范性的要求。另外，加上void类型声明后，也可以发挥代码的“自注释”作用。代码的“自注释”即代码能自己注释自己。

             ● 如果函数无参数，那么应声明其参数为void

             ● 小心使用void指针类型

                按照ANSI的标准，不能对void指针进行算法操作，即下列操作是不合法的：

                void *pvoid;

                pvoid ++;         //ansi错误

                pvoid += 1;        //ansi 错误

                ansi标准之所以这样认定，是因为它坚持，进行算法操作的指针必须是确定知道其指向数据类型的大小的。

                但GUN（GUN’s  Not  Unix）则不这么认为，它指定void*的算法操作与char*一致。因此在GUN编译器中上述语句是正确的。

                在实际的程序中，为了迎合ansi标准，并提高程序的可移植性，我们可以这样实现同样功能的代码：

                void *pvoid;

                (char*)pvoid++;

                (char*)pvoid += 1;

             ● 如果函数的参数可以是任意类型指针，那么应声明其参数为void *

                典型的如内存操作函数memcpy和memset的函数原型分别为：

                void* memcpy(void *dest, const void *src, size_t len);

                void* memset(void *buffer,int c, size_t num);

                这样，任何类型的指针都可以传入memcpy和memset中，这也真实地体现了内存操作函数的意义，因为它操作的对象仅仅是一片内存，而不论内存是什类型。

             ● void不能代表一个真实的变量

                void a; //错误

                function(void a); //错误

■       this指针

《深入浅出MFC》中解释：

 定义类CRect，定义两个对象rect1、rect2，各有自己的m_color成员变量，但rect1.setcolor和rect2.setcolor却都是通往唯一的CRect::setcolor成员函数，那么CRect::setcolor如何处理不同对象的m_color？答案是由一个隐藏参数，名为this指针。当你调用：

rect1.setcolro(2);

rect2.setcolor(3);

时，编译器实际上为你做出来一下的代码：

CRect::setcolor(2,(CRect*)&rect1);

CRect::setcolor(3,(CRect*)&rect2);

多出来的参数，就是所谓的this指针。

class CRect

{

……

public:

  void setcolor(int color){m_color = color};

};

被编译后，其实为：

class CRect

{

……

public:

  void setcolor(int color,(CRect*)this){this->m_color = color};

};

 pDC = this->GetDC();
 ::BeginPath(pDC->m_hDC);
 
 //设置为透明模式 
 ::SetBkMode(pDC->m_hDC, TRANSPARENT);  
 //
 RECT rect;
 this->GetClientRect(&rect);
 /*三角型
 int TopCenterPoint=rect.left + (rect.right - rect.left) /2;
 pDC->MoveTo(TopCenterPoint, rect.top);
 pDC->LineTo(rect.left, rect.bottom - GLOBAL_OVERLEN);
 pDC->LineTo(rect.right, rect.bottom - GLOBAL_OVERLEN);
 pDC->LineTo(TopCenterPoint,rect.top);
 */

 /*比较奇怪的矩形
 pDC->MoveTo(rect.left, rect.top);
 pDC->LineTo(rect.right, rect.top);

 pDC->LineTo(rect.right, rect.bottom - GLOBAL_OVERLEN);

 pDC->LineTo(rect.left + (rect.right - rect.left) / 2, rect.bottom - GLOBAL_OVERLEN);
 pDC->LineTo(rect.left + (rect.right - rect.left) / 2, rect.bottom);
 pDC->LineTo(rect.left + (rect.right - rect.left) / 2 - GLOBAL_OVERWIDTH, rect.bottom - GLOBAL_OVERLEN);

 pDC->LineTo(rect.left, rect.bottom - GLOBAL_OVERLEN);
 pDC->LineTo(rect.left, rect.top);
 */
 //
 
 ::EndPath(pDC->m_hDC);
 hRgn = ::PathToRegion(pDC->m_hDC);
 this->SetWindowRgn(hRgn, TRUE);

=============================================================

0.      磁盘文件数据存储方式

在介绍各种操作文件方式之前，需要先介绍磁盘上文件数据的组织方式。

实际上，文件是在计算机内存中以二进制表示的数据在外部存储介质上的另一种存放形式。文件通常分为二进制文件和文本文件。二进制文件是包含在ASCII及扩展ASCII字符中编写的数据或程序指令的文件。一般是可执行文件(Exe)、图形、图像、声音等文件。而文本文件(通常也成为ASCII文件)，它的每一字节存放的是可表示为一个字符的ASCII代码的文件。这里把文件区分为二进制文件和文本文件，但实际上它们都是以二进制数据的方式来存储的。文本文件里所存储的每一个字节都可以转化为一个可读的字符。譬如’a’,’b’，但在内存中并不会存储'a', 'b'，而是存储它们的ASCII码：61和62。

1.      C语言对文件操作的支持

在C语言中，对于文件的操作都是利用FILE结构体来进行的。包括文件的打开、文件的读写、文件的关闭、文件指针的定位等。

(1)   文件的打开

文件的打开需要用fopen函数。该函数带2个参数，返回值为指向之前定义的FILE结构体指针。语法定义为

FILE* fopen(const char* filename, const char* mod);

参数1：表示要打开文件的完整路径，例如: “C:\\Test\\Zero_Test.txt”.

参数2：打开文件的方式。取值为下表所示。

在上表中，没有带b的模式表示打开的是文本文件，而带b的模式表示打开的是二进制文件。

通常在定义结构FILE时会将其初始化为NULL。在打开文件将函数fopen的返回值赋值给它。之后需要判断文件是否成功打开，可采用如下方式：

if ((pFile = fopen(“C:\\Test\\Zero_Test.txt”, “w”) == NULL)

   Print(“Opening File Error.”);    // FILE* pFile = NULL;

else

   正常写入数据到文件…

（2）文件的关闭

在使用完一个文件之后应该关闭它，以防止它再被误用。“关闭”就是使文件指针变量不再指向该文件，使其脱钩。函数使用方式:

fclose(pFile);

需要注意的是fclose的参数必须是有效的文件指针变量，否则运行时会挂掉。

应该养成在文件数据操作完成后关闭文件的习惯，如果不关闭文件将会丢失数据。同时，在向文件写数据时，是现将数据输出到缓冲区，待缓冲区充满后才正式输出给文件。如果程序运行结束而缓冲区并未充满，则缓冲区中的数据将会丢失。因此利用函数fclose来关闭文件可以避免这个问题。

当然，还有另外一个函数fflush，也可以用来将缓冲区里的数据输出到文件中。函数调用方式:

fflush(pFile);

 （3）文件的读写

当涉及到大量数据的读写时，可以采用函数fread和fwrite。这两个函数通常用于二进制文件的读写。函数调用方式如下：

fread(buffer, size, count, fp);

fwrite(buffer, size, count, fp);

buffer是一个指针，是用来存放数据的变量指针，例如内置类型变量的指针，结构体变量指针等。

size是要读写的字节数。特别要注意的是，此处并不是数组的大小，结构体内变量的个数等。最好采用sizeof操作符来求得buffer的内存字节数。

count是size大小的重复次数。

fp是文件指针。

对于这样的结构体：

typedef struct {

    int clr_sel;             // color mode的选择

    int fixval_sel;          // fixed value的选择

    float thres_val;         // threshold value的确定

    float thres_scrlbar_pos; // threshold scroll bar位置的确定

    int method_sel;          // analysis method的选择

    int usediff_sel;         // use difference of MSA/TSE方式的选择

    int usescat_sel;         // use MSA/TSE of scatter signal 方式的选择

    int remxtalk_sel;        // remove crosstalk 方式的选择

    float timewin_scrlbar_pos; // time window scroll bar位置的确定

    int timewin_sel;         // time window模式的选择

    int freq_sel;            // frequency selection模式的选择

    int path_sel;            // path selection模式的选择  

} IMG_SETTINGS;    

       IMG_SETTINGS m_img_settings;

文件读写操作时，可采用如下方式：

fwrite(&m_img_settings, sizeof(m_img_settings), 1, pwFile);

fread(&m_img_settings, sizeof(m_img_settings), 1, prFile);

====================================================

如果想读写特定格式的文件，可采用fprintf和fscanf函数。这两个函数通常是针对文本文件进行操作。

函数调用方式如下：

fprintf(pFile, “%d…”, i, j, k …);

fscanf(pFile, “%d…”, i j, k…);

格式化时可以规定读写数据的精度，类型，以及数据之间的分割符等。

例如：

fprintf(pFile, " %d %d %d %d %d %d %d %d \n", sigSize, samp_points, samp_rate,40, avrag_num, 0, 0, 0);

fprintf(pFile, "%d %.2f %s %d %d %d %d \n", vpathdef[i].frequency1/1000,

                                   vpathdef[i].amplitude, sig_type.c_str(),     psnset->sensorArray[vpathdef[i].actuator-1].channel-tol,

                     psnset->sensorArray[vpathdef[i].sensor-1].channel-tol,  vpathdef[i].gain, 30);  

特别需要注意的是，如果写入的数据的类型相同时，不可为了简便，将格式化的字符串写成如此形式(.., ”%d”,i,j,k…); // i,j,k…同整型类型。

如果这样操作的话，读写的数据便只有数据i了。

最后针对一个面试题来对C语言操作文件的方式作一个总结.

面试题：给你一个整数，例如12345，将这个整数保存到文件中，要求在以记事本打开该文件时，显示的是:12345。

给出三种代码：

（1）    代码1

FILE* pwFile = NULL;

pwFile = fopen(“c:\\Test.txt”, “w”); // create and open file with text mode.

int i = 12345;                       // However, write number with binary mode.

fwrite(&i, 4, 1, pwFile);      // sizeof(int) = 4.

fclose(fwFile);

========================

（2）    代码2

FILE* pwFile = NULL;

pwFile = fopen(“c:\\Test.txt”, “w”);

char ch[5] = {1+48, 2+48, 3+48, 4+48, 5+48 };

fwrite(ch, 1, 5, pwFile);      // sizeof(char) = 1, 5*sizeof(char) = 5

fclose(pwFile);

=======================

（3）    代码3

FILE* pwFile = NULL;

pwFile = fopen(“c:\\Test.txt”, “w”);

int i = 12345;

char ch[5];

itoa(i, ch, 10);        // transform int number to string

fwrite(ch, 1, 5, fwFile);

fclose(pFile);

==============================

（4）    代码4

FILE* pwFile = NULL;

pwFile = fopen(“c:\\Test.txt”, “w”);

int i = 12345;

fprintf(pwFile, “%d”, i);   // write number with specified format.

fclose(pwFile);

==============================

将4种代码在vc中进行编译运行，可以发现只有方式（1）不满足题目要求。

依次是视类、文档类、框架类，最后才是应用程序类。

2.      Windows消息的分类

实际上，菜单命令也是一种消息。在Windows中，消息分为以下3种：

（1）    标准消息

除了WM_COMMAND之外，所有以WM_开头的消息都是标准消息。从CWnd派生的类，都可以接收到该类消息。

（2）    命令消息

   来自菜单、加速键或工具栏按钮的消息。这类消息都是以WM_COMMAND形式呈现。在MFC中，通过菜单项的标识(ID)来区分不同的命令消息；在SDK中，通过消息的wParam参数来标识。从CCmdTarget派生的类，都可以接收到这类消息。

（3）    通告消息

   由控件产生的消息，例如按钮的单击、列表框的选择等都会产生这类消息，目的是为了向其父窗口通知事件的发生。这类消息也是以WM_COMMAND形式呈现的。从CCmdTarget派生的类，都可以接收到这类消息。

由于CWnd是从CCmdTarget派生的，故从CWnd派生的类，它们既可以接收标准消息，也可以接收命令消息和通告消息。而对于那些从CCmdTarget派生的类，则只能接收命令消息和通告消息，不能接收标准消息。

3.      �