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

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

　　　　　　有关说明：

　　　　　　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.      菜单命令消息路由的具体过程

当点击某个菜单项时，最先接收到这个菜单命令消息的是框架类。框架类将把接收到的这个消息交给它的子窗口，即视类，由视类首先进行处理。视类首先根据命令消息映射机制查找自身是否对此消息进行了响应，如果响应了，就调用响应函数对这个消息进行处理，消息路由过程结束；如果视类没有对此命令消息做处响应，就交由文档类，文档类同样查找自身是否对这个菜单命令进行了响应，如果响应了，就由文档类的命令消息响应函数进行处理，路由过程结束。如果文档类也未做出响应，就把这个命令消息交还给视类，后者又把该消息交还给框架类。框架类查看自己是否对这个命令消息进行了响应，如果它也没有作处响应，就把这个菜单命令消息交换给应用程序类，由后者来进行处理。

4.      菜单操作

要想获得某个菜单资源，需使用下面的函数调用：

CMenu* GetMenu() const ;

该函数调用者是CWnd的对象。返回值为CMenu类对象的指针。

通过获得的菜单指针便可以获得其上的某个菜单栏的指针了。调用方式为：

   CMenu* GetSubMenu(int nPos) const;

调用者是菜单资源的类对象指针，或者是某个菜单栏的对象指针。

如果某个菜单栏下面还有子菜单项，通过可以通过GetSubMenu函数来获得其子菜单项的操作指针。子菜单项的索引都是从0开始的，同时分割栏也是要占据索引值的。

5.      CASE：

在资源编辑器中编辑Popup Menu资源: IDR_SENSOR_DRAW_MENU。

Grids Style子菜单中的各个选项是相互排斥的。要求选择其中的一个时，需在其菜单前面标志选择它”·”，其它都为为选中。也就是说Style中只能选中一个。

可采用两种方式：

（1）映射消息：ON_WM_CONTEXTMENU()

void ..::OnContextMenu(CWnd* /*pWnd*/, CPoint point)

（2）映射消息：ON_WM_RBUTTONDOWN()

void ..::OnRightBtnDown(.. ..)

响应函数实现代码：

{

CMenu menu;

       menu.LoadMenu(IDR_SENSOR_DRAW_MENU); // 装载菜单资源

       CMenu* pMenu = menu.GetSubMenu(0);   // 获得Sensor Menu菜单栏的对象指针

       CMenu* pSubMenu = pMenu->GetSubMenu(0); // 获得Grids Style子菜单项的对象指针

       // 以此类推，如果是Edit Structure字菜单项的对象指针，参数应该是1

       int idxsel = 0;

       switch (m_GridStyle) {

              case GRIDSOFF:

                     idxsel = 0;

                     break;

              case GRIDS10X:

                     idxsel = 2;           // separator is one resource, so take it into account.

                     break;

              case GRIDS20X:

                     idxsel = 3;

                     break;

              case GRIDS30X:

                     idxsel = 4;

                     break;

       }

// Grids Style子菜单项又有N个子菜单项，根据索引值位置来设置其状态。

       pSubMenu->CheckMenuRadioItem(0, 4, idxsel, MF_BYPOSITION);

// 如果是WM_RBUTTONDOWN响应，则需要调用函数

ClientToScreen(&point); // 将客户坐标转化为屏幕坐标。

// 以下函数的参数x,y是屏幕坐标值。

       pMenu->TrackPopupMenu(TPM_RIGHTBUTTON,point.x,point.y,this,NULL);

}

Author: Yevgeny Menaker


下载代码
原文出处：Five Steps to Writing Windows Services in C

摘要

　　Windows 服务被设计用于需要在后台运行的应用程序以及实现没有用户交互的任务。为了学习这种控制台应用程序的基础知识，C（不是C++）是最佳选择。本文将建立并实现一个简单的服务程序，其功能是查询系统中可用物理内存数量，然后将结果写入一个文本文件。最后，你可以用所学知识编写自己的 Windows 服务。
　　当初我写第一个 NT 服务时，我到 MSDN 上找例子。在那里我找到了一篇 Nigel Thompson 写的文章：“Creating a Simple Win32 Service in C++”，这篇文章附带一个 C++ 例子。虽然这篇文章很好地解释了服务的开发过程，但是，我仍然感觉缺少我需要的重要信息。我想理解通过什么框架，调用什么函数，以及何时调用，但 C++ 在这方面没有让我轻松多少。面向对象的方法固然方便，但由于用类对底层 Win32 函数调用进行了封装，它不利于学习服务程序的基本知识。这就是为什么我觉得 C 更加适合于编写初级服务程序或者实现简单后台任务的服务。在你对服务程序有了充分透彻的理解之后，用 C++ 编写才能游刃有余。当我离开原来的工作岗位，不得不向另一个人转移我的知识的时候，利用我用 C 所写的例子就非常容易解释 NT 服务之所以然。
　　服务是一个运行在后台并实现勿需用户交互的任务的控制台程序。Windows NT/2000/XP 操作系统提供为服务程序提供专门的支持。人们可以用服务控制面板来配置安装好的服务程序，也就是 Windows 2000/XP 控制面板|管理工具中的“服务”（或在“开始”|“运行”对话框中输入 services.msc /s——译者注）。可以将服务配置成操作系统启动时自动启动，这样你就不必每次再重启系统后还要手动启动服务。
　　本文将首先解释如何创建一个定期查询可用物理内存并将结果写入某个文本文件的服务。然后指导你完成生成，安装和实现服务的整个过程。


第一步：主函数和全局定义

首先，包含所需的头文件。例子要调用 Win32 函数（windows.h）和磁盘文件写入（stdio.h）：

#include <windows.h>
            #include <stdio.h>

接着，定义两个常量：

#define SLEEP_TIME 5000
            #define LOGFILE "C:\\MyServices\\memstatus.txt"

SLEEP_TIME 指定两次连续查询可用内存之间的毫秒间隔。在第二步中编写服务工作循环的时候要使用该常量。
LOGFILE 定义日志文件的路径，你将会用 WriteToLog 函数将内存查询的结果输出到该文件，WriteToLog 函数定义如下：

int WriteToLog(char* str)
            {
            FILE* log;
            log = fopen(LOGFILE, "a+");
            if (log == NULL)
            return -1;
            fprintf(log, "%s\n", str);
            fclose(log);
            return 0;
            }

声明几个全局变量，以便在程序的多个函数之间共享它们值。此外，做一个函数的前向定义：

SERVICE_STATUS ServiceStatus;
            SERVICE_STATUS_HANDLE hStatus;
            void ServiceMain(int argc, char** argv);
            void ControlHandler(DWORD request);
            int InitService();

　　现在，准备工作已经就绪，你可以开始编码了。服务程序控制台程序的一个子集。因此，开始你可以定义一个 main 函数，它是程序的入口点。对于服务程序来说，main 的代码令人惊讶地简短，因为它只创建分派表并启动控制分派机。

void main()
            {
            SERVICE_TABLE_ENTRY ServiceTable[2];
            ServiceTable[0].lpServiceName = "MemoryStatus";
            ServiceTable[0].lpServiceProc = (LPSERVICE_MAIN_FUNCTION)ServiceMain;
            ServiceTable[1].lpServiceName = NULL;
            ServiceTable[1].lpServiceProc = NULL;
            // 启动服务的控制分派机线程
            StartServiceCtrlDispatcher(ServiceTable);
            }

　　一个程序可能包含若干个服务。每一个服务都必须列于专门的分派表中（为此该程序定义了一个 ServiceTable 结构数组）。这个表中的每一项都要在 SERVICE_TABLE_ENTRY 结构之中。它有两个域：

• lpServiceName: 指向表示服务名称字符串的指针；当定义了多个服务时，那么这个域必须指定；
• lpServiceProc: 指向服务主函数的指针（服务入口点）；

　　分派表的最后一项必须是服务名和服务主函数域的 NULL 指针，文本例子程序中只宿主一个服务，所以服务名的定义是可选的。
　　服务控制管理器（SCM：Services Control Manager）是一个管理系统所有服务的进程。当 SCM 启动某个服务时，它等待某个进程的主线程来调用 StartServiceCtrlDispatcher 函数。将分派表传递给 StartServiceCtrlDispatcher。这将把调用进程的主线程转换为控制分派器。该分派器启动一个新线程，该线程运行分派表中每个服务的 ServiceMain 函数（本文例子中只有一个服务）分派器还监视程序中所有服务的执行情况。然后分派器将控制请求从 SCM 传给服务。

注意：如果 StartServiceCtrlDispatcher 函数30秒没有被调用，便会报错，为了避免这种情况，我们必须在 ServiceMain 函数中（参见本文例子）或在非主函数的单独线程中初始化服务分派表。本文所描述的服务不需要防范这样的情况。

　　分派表中所有的服务执行完之后（例如，用户通过“服务”控制面板程序停止它们），或者发生错误时。StartServiceCtrlDispatcher 调用返回。然后主进程终止。


第二步：ServiceMain 函数

　　Listing 1 展示了 ServiceMain 的代码。该函数是服务的入口点。它运行在一个单独的线程当中，这个线程是由控制分派器创建的。ServiceMain 应该尽可能早早为服务注册控制处理器。这要通过调用 RegisterServiceCtrlHadler 函数来实现。你要将两个参数传递给此函数：服务名和指向 ControlHandlerfunction 的指针。
　　它指示控制分派器调用 ControlHandler 函数处理 SCM 控制请求。注册完控制处理器之后，获得状态句柄（hStatus）。通过调用 SetServiceStatus 函数，用 hStatus 向 SCM 报告服务的状态。
Listing 1 展示了如何指定服务特征和其当前状态来初始化 ServiceStatus 结构，ServiceStatus 结构的每个域都有其用途：

• dwServiceType：指示服务类型，创建 Win32 服务。赋值 SERVICE_WIN32；
• dwCurrentState：指定服务的当前状态。因为服务的初始化在这里没有完成，所以这里的状态为 SERVICE_START_PENDING；
• dwControlsAccepted：这个域通知 SCM 服务接受哪个域。本文例子是允许 STOP 和 SHUTDOWN 请求。处理控制请求将在第三步讨论；
• dwWin32ExitCode 和 dwServiceSpecificExitCode：这两个域在你终止服务并报告退出细节时很有用。初始化服务时并不退出，因此，它们的值为 0；
• dwCheckPoint 和 dwWaitHint：这两个域表示初始化某个服务进程时要30秒以上。本文例子服务的初始化过程很短，所以这两个域的值都为 0。

　　调用 SetServiceStatus 函数向 SCM 报告服务的状态时。要提供 hStatus 句柄和 ServiceStatus 结构。注意 ServiceStatus 一个全局变量，所以你可以跨多个函数使用它。ServiceMain 函数中，你给结构的几个域赋值，它们在服务运行的整个过程中都保持不变，比如：dwServiceType。
　　在报告了服务状态之后，你可以调用 InitService 函数来完成初始化。这个函数只是添加一个说明性字符串到日志文件。如下面代码所示：

// 服务初始化
            int InitService()
            {
            int result;
            result = WriteToLog("Monitoring started.");
            return(result);
            }

　　在 ServiceMain 中，检查 InitService 函数的返回值。如果初始化有错（因为有可能写日志文件失败），则将服务状态置为终止并退出 ServiceMain：

error = InitService();
            if (error)
            {
            // 初始化失败，终止服务
            ServiceStatus.dwCurrentState = SERVICE_STOPPED;
            ServiceStatus.dwWin32ExitCode = -1;
            SetServiceStatus(hStatus, &ServiceStatus);
            // 退出 ServiceMain
            return;
            }

如果初始化成功，则向 SCM 报告状态：

// 向 SCM 报告运行状态
            ServiceStatus.dwCurrentState = SERVICE_RUNNING;
            SetServiceStatus (hStatus, &ServiceStatus);

接着，启动工作循环。每五秒钟查询一个可用物理内存并将结果写入日志文件。

如 Listing 1 所示，循环一直到服务的状态为 SERVICE_RUNNING 或日志文件写入出错为止。状态可能在 ControlHandler 函数响应 SCM 控制请求时修改。
 

第三步：处理控制请求

　　在第二步中，你用 ServiceMain 函数注册了控制处理器函数。控制处理器与处理各种 Windows 消息的窗口回调函数非常类似。它检查 SCM 发送了什么请求并采取相应行动。
　　每次你调用 SetServiceStatus 函数的时候，必须指定服务接收 STOP 和 SHUTDOWN 请求。Listing 2 示范了如何在 ControlHandler 函数中处理它们。
　　STOP 请求是 SCM 终止服务的时候发送的。例如，如果用户在“服务”控制面板中手动终止服务。SHUTDOWN 请求是关闭机器时，由 SCM 发送给所有运行中服务的请求。两种情况的处理方式相同：

• 写日志文件，监视停止；
• 向 SCM 报告 SERVICE_STOPPED 状态；

　　由于 ServiceStatus 结构对于整个程序而言为全局量，ServiceStatus 中的工作循环在当前状态改变或服务终止后停止。其它的控制请求如：PAUSE 和 CONTINUE 在本文的例子没有处理。
　　控制处理器函数必须报告服务状态，即便 SCM 每次发送控制请求的时候状态保持相同。因此，不管响应什么请求，都要调用 SetServiceStatus。


图一 显示 MemoryStatus 服务的服务控制面板


第四步：安装和配置服务

　　程序编好了，将之编译成 exe 文件。本文例子创建的文件叫 MemoryStatus.exe，将它拷贝到 C:\MyServices 文件夹。为了在机器上安装这个服务，需要用 SC.EXE 可执行文件，它是 Win32 Platform SDK 中附带的一个工具。（译者注：Visaul Studio .NET 2003 IDE 环境中也有这个工具，具体存放位置在：C:\Program Files\Microsoft Visual Studio .NET 2003\Common7\Tools\Bin\winnt）。使用这个实用工具可以安装和移除服务。其它控制操作将通过服务控制面板来完成。以下是用命令行安装 MemoryStatus 服务的方法：

sc create MemoryStatus binpath= c:\MyServices\MemoryStatus.exe

　　发出此创建命令。指定服务名和二进制文件的路径（注意 binpath= 和路径之间的那个空格）。安装成功后，便可以用服务控制面板来控制这个服务（参见图一）。用控制面板的工具栏启动和终止这个服务。


图二 MemoryStatus 服务的属性窗口

　　MemoryStatus 的启动类型是手动，也就是说根据需要来启动这个服务。右键单击该服务，然后选择上下文菜单中的“属性”菜单项，此时显示该服务的属性窗口。在这里可以修改启动类型以及其它设置。你还可以从“常规”标签中启动/停止服务。以下是从系统中移除服务的方法：

sc delete MemoryStatus

指定 “delete” 选项和服务名。此服务将被标记为删除，下次西通重启后，该服务将被完全移除。


第五步：测试服务

　　从服务控制面板启动 MemoryStatus 服务。如果初始化不出错，表示启动成功。过一会儿将服务停止。检查一下 C:\MyServices 文件夹中 memstatus.txt 文件的服务输出。在我的机器上输出是这样的：

Monitoring started.
            273469440
            273379328
            273133568
            273084416
            Monitoring stopped.

　　为了测试 MemoryStatus 服务在出错情况下的行为，可以将 memstatus.txt 文件设置成只读。这样一来，服务应该无法启动。
　　去掉只读属性，启动服务，在将文件设成只读。服务将停止执行，因为此时日志文件写入失败。如果你更新服务控制面板的内容，会发现服务状态是已经停止。
 

开发更大更好的服务程序

　　理解 Win32 服务的基本概念，使你能更好地用 C++ 来设计包装类。包装类隐藏了对底层 Win32 函数的调用并提供了一种舒适的通用接口。修改 MemoryStatus 程序代码，创建满足自己需要的服务！为了实现比本文例子所示范的更复杂的任务，你可以创建多线程的服务，将作业划分成几个工作者线程并从 ServiceMain 函数中监视它们的执行。
　

结合ACE大略的看了POSA1， POSA2。

对设计模式的理解还是很肤浅， 突然想深入地学习设计模式， 对每一种模式

都辅助相关的code来理解， 并把设计模式和MFC， ACE， cppunit等框架联系起来，

更好地理解和应用这些编程的框架（还有log4plus等）

今天总结一下简单的单件模式：

Singleton(单件)——对象创建型模式

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

1·典型Singleton类：

class Singleton

{

public:

     static Singleton* Instance();

protected:

     Singleton();

private:

     static Singleton* _instance;

};

Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance()

{

     if(_instance == 0)

     {

         _instance = new Singleton;

     }

     return _instance;

}

客户仅通过Instance成员函数访问这个单件。变量_instance初始化为0，而静态成员函数Instance返回该变量值。注意：构造器是保护型的，保证了仅有一个实例被创建。

这种方式的实现对于线程来说并不是安全的，因为在多线程的环境下有可能得到Singleton类的多个实例。如果同时有两个线程去判断（_instance == null），并且得到的结果为真，这时两个线程都会创建类Singleton的实例，这样就违背了Singleton模式的原则。实际上在上述代码中，有可能在计算出表达式的值之前，对象实例已经被创建，但是内存模型并不能保证对象实例在第二个线程创建之前被发现。

 该实现方式主要有两个优点：·由于实例是在 Instance 属性方法内部创建的，因此类可以使用附加功能（例如，对子类进行实例化），即使它可能引入不想要的依赖性。·  直到对象要求产生一个实例才执行实例化；这种方法称为“惰性实例化”。惰性实例化避免了在应用程序启动时实例化不必要的 singleton

2·线程安全的singleton

class Singleton

{

public:

     static Singleton* Instance();

protected:

     Singleton();

private:

     static Singleton* _instance;

     static Cmutext _mutex;

};

Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance()

{

     _mutex.acque();

     if(_instance == 0)

     {

         _instance = new Singleton;

     }

     _mutex.release();

     return _instance;

}

 这种方式的实现对于线程来说是安全的。我们首先创建了一个进程辅助对象，线程在进入时先对辅助对象加锁然后再检测对象是否被创建，这样可以确保只有一个实例被创建，因为在同一个时刻加了锁的那部分程序只有一个线程可以进入。这种情况下，对象实例由最先进入的那个线程创建，后来的线程在进入时（_instence == null）为假，不会再去创建对象实例了。但是这种实现方式增加了额外的开销，损失了性能。

3．双重锁定

 这种实现方式对多线程来说是安全的，同时线程不是每次都加锁，只有判断对象实例没有被创建时它才加锁，有了我们上面第一部分的里面的分析，我们知道，加锁后还得再进行对象是否已被创建的判断。它解决了线程并发问题，同时避免在每个 Instance 属性方法的调用中都出现独占锁定。它还允许您将实例化延迟到第一次访问对象时发生。实际上，应用程序很少需要这种类型的实现。大多数情况下我们会用静态初始化。这种方式仍然有很多缺点：无法实现延迟初始化。

class Singleton

{

public:

     static Singleton* Instance();

protected:

     Singleton();

private:

     static Singleton* _instance;

     static CMutex _mutex;

};

Singleton* Singleton::_instance = 0;

Singleton* Singleton::Instance()

{

     if(_instance == 0)

     {

         _mutex.acque();

         _instance = new Singleton;

         _mutex.release

     }

     return _instance;

}

实现要点

 ·Singleton模式是限制而不是改进类的创建。

 ·Singleton类中的实例构造器可以设置为Protected以允许子类派生。

 ·Singleton模式一般不要支持Icloneable接口，因为这可能导致多个对象实例，与Singleton模式的初衷违背。

 · Singleton模式一般不要支持序列化，这也有可能导致多个对象实例，这也与Singleton模式的初衷违背。

 · Singleton只考虑了对象创建的管理，没有考虑到销毁的管理，就支持垃圾回收的平台和对象的开销来讲，我们一般没必要对其销毁进行特殊的管理。

 ·理解和扩展Singleton模式的核心是“如何控制用户使用new对一个类的构造器的任意调用”。

总结： Singleton设计模式是一个非常有用的机制，可用于在面向对象的应用程序中提供单个访问点。

应该注意的几点:
    1,我们不应该来序列化和反序列化用单件模式实现的对象,否则多次反序列化则可以创建多的实例,这与单件模式是相矛盾的.
    2,我们不应该克隆用单件模式实现的对象,否则多次克隆则可以创建多的实例,这与单件模式是相矛盾的.
    3,在多线程环境中使用单件模式时要小心.

关于ACE中单件模式ACE_Singleton的设计和应用可以参考一博友的文章， 感觉写的很好

http://blog.csdn.net/joise/archive/2006/09/29/1305849.aspx

参考网站：http://www.oonumerics.org/blitz/

Blitz++ 是一个高效率的数值计算函数库，它的设计目的是希望建立一套既具像C++ 一样方便，同时又比Fortran速度更快的数值计算环境。通常，用C++所写出的数值程序，比 Fortran慢20%左右，因此Blitz++正是要改掉这个缺点。方法是利用C++的template技术，程序执行甚至可以比Fortran更快。Blitz++目前仍在发展中，对于常见的SVD，FFTs，QMRES等常见的线性代数方法并不提供，不过使用者可以很容易地利用Blitz++所提供的函数来构建。

POOMA

参考网站：http://www.c'>http://www.c'>http://www.c'>http://www.codesourcery.com/pooma/pooma

POOMA是一个免费的高性能的C++库，用于处理并行式科学计算。POOMA的面向对象设计方便了快速的程序开发，对并行机器进行了优化以达到最高的效率，方便在工业和研究环境中使用。

MTL

参考网站：http://www.osl.iu.edu/research/mtl/'>http://www.osl.iu.edu/research/mtl/

Matrix Template Library(MTL)是一个高性能的泛型组件库，提供了各种格式矩阵的大量线性代数方面的功能。在某些应用使用高性能编译器的情况下，比如Intel的编译器，从产生的汇编代码可以看出其与手写几乎没有两样的效能。

CGAL

参考网站：www.cgal.org

Computational Geometry Algorithms Library的目的是把在计算几何方面的大部分重要的解决方案和方法以C++库的形式提供给工业和学术界的用户。

Thread 线程，当线程结束时，线程对象即被激发。当线程还在进行时，则对象处于未激发状态。

Process 进程，当进程结束时，进程对象即被激发。当进程还在进行时，则对象处于未激发状态。

Change Notification ，当一个特定的磁盘子目录中发生一件特别的变化时，此对象即被激发。此对象系由 FindFirstChangeNotification() 产生

Console Input ，当 console 窗口的输入缓冲区中有数据可用时，此对象将处于激发状态。 CreateFile （）和 GetStdFile （）两函数可以获得 console handle 。

Event ， Event 对象的状态直接受控于应用程序所使用的三个 Win32 函数： SetEvent （）， PulseEvent （）， ResetEvent （）。 CreateEvent （）和 OpenEvent （）都可以传回一个 event object handle 。 Event 对象的状态也可以被操作系统设定——如果使用于“ overlapped ”操作时。

Mutex ，如果 mutex 没有被任何线程拥有，他就是处于激发状态。一旦一个等待 mutex 的函数返回了， mutex 也就自动重置为未激发状态。 CreateMutex （）和 OpenMutex （）都可以获得一个 Mutext 的 handle 。

Semaphore ， Semaphore 有点像 mutex ，但他有个计数器，可以约束其拥有者（线程）的个数。当计数器内容大于 0 时， semaphore 处于激发状态，当计数器内容等于 0 时， semaphore 处于未激发状态。 CreateSemaphore （）和 OpenSemaphore （）可以传回一个 semaphore handle 。

从1到N(100000)中任意拿掉两个数，把剩下的99998个数顺序打乱，并且放入数组A中。要求只扫描一遍数组，把这两个数找出来。可以使用最到不超过5个局部变量，不能用数组变量，并且不能改变原数组的值。

        在函数的声明中用数组的引用定义，就不怕数组退化了。如下
        for_each( int (&int_ref)[10] )
        {
                 for( int i=0; i<10; ++i )
                         std::cout << int_ref[i] << std::endl;
         }

         int main( int argc, char* argv[] )
         {
                 int int_array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
        
                 for_each( int_array );
                 return 0;
          }

          在上面的代码中，如果你传入不是10个尺寸的数组，是编译通不过的。代码的安全性提高了。  

         想要定义一个数组引用类型，方法如下
         typedef 类型明 (&数组引用类型明)[N];

         实例
         typedef int (&Array_Ref)[10];
         Array_Ref就是一个数组的引用类型了。

我们需要做的是通过我们自己编写的应用程序去拦截别人写好的应用程序消息，实际上这是在两个进程之间进行的，难度就在这里，如果是同一个进程什么都好办，只要将系统响应WINDOWS消息的处理函数修改为我们自己编写的函数就可以，但现在不能这么做，因为两个进程有各自的进程地址空间，理论上你没有办法直接去访问别的进程的地址空间，那么怎么办来？办法还是很多的，这里仅仅介绍通过HOOK来达到目的。

需要拦截别的应用程序的消息，需要利用将自己编写的DLL注入到别人的DLL地址空间中才可以达到拦截别人消息的目的。只有将我们的DLL插入到别的应用程序的地址空间中才能够对别的应用程序进行操作，HOOK帮助我们完成了这些工作，我们只需要使用HOOK来拦截指定的消息，并提供必要的处理函数就行了。我们这里介绍拦截在MSN聊天对话框上的鼠标消息，对应的HOOK类型是WH_MOUSE。

首先我们要建立一个用来HOOK的DLL。这个DLL的建立和普通的DLL建立没有什么具体的区别，不过我们这里提供的方法有写不同。这里使用隐式导入DLL的方法。代码如下：

头文件

#pragma once
#ifndef MSNHOOK_API
#define MSNHOOK_API __declspec(dllimport)
#endif

MSNHOOK_API BOOL WINAPI SetMsnHook(DWORD dwThreadId);//安装MSN钩子函数
MSNHOOK_API void WINAPI GetText(int &x,int &y,char ** ptext);//安装MSN钩子函数
MSNHOOK_API HWND WINAPI GetMyHwnd();//安装MSN钩子函数

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

DLL 的CPP文件

#include "stdafx.h"
#include "MSNHook.h"
#include <stdio.h>

// 下面几句的含义是告诉编译器将各变量放入它自己的数据共享节中

#pragma data_seg("Shared")
HHOOK g_hhook = NULL;
DWORD g_dwThreadIdMsn = 0;
POINT MouseLoc={0,0};
char text[256]={0};
HWND g_Hwnd = NULL;
#pragma data_seg()

//告诉编译器设置共享节的访问方式为：读，写，共享

#pragma comment(linker,"/section:Shared,rws")

HINSTANCE g_hinstDll = NULL;

BOOL APIENTRY DllMain( HANDLE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
g_hinstDll = (HINSTANCE)hModule;
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}

LRESULT WINAPI GetMsgProc(int nCode,WPARAM wParam, LPARAM lParam);

BOOL WINAPI SetMsnHook(DWORD dwThreadId)
{
OutputDebugString("SetMsnHook");
BOOL fOK = FALSE;
if(dwThreadId != 0)
{
OutputDebugString("SetMsnHook dwThreadId != 0");
g_dwThreadIdMsn = GetCurrentThreadId();

//安装WM_MOUSE钩子和处理函数GetMsgProc
g_hhook = SetWindowsHookEx(WH_MOUSE,GetMsgProc,g_hinstDll,dwThreadId);
fOK = (g_hhook != NULL);
if(fOK)
{
fOK = PostThreadMessage(dwThreadId,WM_NULL,0,0);
}
else
{
fOK = UnhookWindowsHookEx(g_hhook);
g_hhook = NULL;
}
}
return(fOK);
}

LRESULT WINAPI GetMsgProc(int nCode,WPARAM wParam, LPARAM lParam)
{

char temp[20];
sprintf(temp,"%dn",nCode);
OutputDebugString("temp");
if (nCode==HC_ACTION)
{
MOUSEHOOKSTRUCT *l=(MOUSEHOOKSTRUCT *)lParam;
MouseLoc=l->pt; //送鼠标位置

//char text[256] = "";
HWND hWnd = WindowFromPoint(l->pt);
if(hWnd)
{
//GetWindowText(hWnd,text,256);
SendMessage(hWnd,WM_GETTEXT,256,(LPARAM)(LPCTSTR)text);
// strcpy(text,"123455555");
SendMessage(hWnd,WM_SETTEXT,256,(LPARAM)(LPCTSTR)text);
g_Hwnd = hWnd;
}
//SendMessage(WindowFromPoint(l->pt),WM_GETTEXT,256,(LPARAM)(LPCTSTR)psw);
}

return(CallNextHookEx(g_hhook,nCode,wParam,lParam));
}

void WINAPI GetText(int &x,int &y,char ** ptext)
{
x = MouseLoc.x;
y = MouseLoc.y;
*ptext = text;
}

HWND WINAPI GetMyHwnd()
{
return g_Hwnd;
}

上面是处理钩子的DLL代码，下面我们要让这个DLL起作用还需要一个启动部分，通过这个启动部分我们才能让我们的钩子函数真正的注入到系统其他函数中。我们这里使用个对话框的程序，程序非常简单：一个按钮用来启动钩子，一个用来停止，一个TIMER用来刷新显示，还有一个EDITBOX用来接受信息。

程序如下：

//包含DLL函数导出的头文件
#include "MSNHook.h"

//隐式导入

#pragma comment(lib,"MSNHook.lib")

//声明导入函数

__declspec(dllimport) BOOL WINAPI SetMsnHook(DWORD dwThreadId);
__declspec(dllimport) void WINAPI GetText(int &x,int &y,char ** ptext);
__declspec(dllimport) HWND WINAPI GetMyHwnd();//安装MSN钩子函数

void CTestMSNHookDlg::OnBnClickedOk()
{

//通过SPY++可以看到MSN聊天对话框窗口类是IMWindowClass，通过这个得到该窗口句柄
CWnd *pMsnWin = FindWindow(TEXT("IMWindowClass"),NULL);
if(pMsnWin == NULL) return ;

//通过窗口句柄得到对应的线程的ID
SetMsnHook(GetWindowThreadProcessId(pMsnWin->GetSafeHwnd(),NULL));
MSG msg;
GetMessage(&msg,NULL,0,0);
SetTimer(101,100,NULL);

}

void CTestMSNHookDlg::OnTimer(UINT_PTR nIDEvent)
{

//刷新消息
char * pText = NULL;
int x = 0,y = 0;
GetText(x,y,&pText);
if(x ==0 && y ==0) return ;
m_Edit.Format("%d:%d:%s",x,y,pText);
//m_Edit = pText;
UpdateData(FALSE);

HWND hWnd = GetMyHwnd();
CWnd * pWnd = CWnd::FromHandle(hWnd);
pWnd->GetWindowText(m_Edit);
CDialog::OnTimer(nIDEvent);
}

void CTestMSNHookDlg::OnBnClickedButton1()
{

//关闭
KillTimer(101);
SetMsnHook(0);
OnCancel();
}

好了，基本上就这些了。这里有个问题，我本想得到MSN用户聊天时输入的聊天信息，这里通过WM_GETTEXT消息的不到，如果有知道的朋友告诉一声。