C和C++编程和学习文档
C和C++编程和学习文档
1 :指针变量名称以p为首字符，这是程序员通常在定义指针时的一个习惯
2 :har * p; (int *)p 把p强制转换为int型
3.1 :指针的问题：指针应用时最好给予定义(初始化)这样可以保证指针的指向是程序员自己能够把握的。
3.2 :指针的越界，这恐怕是最难查出的吧！
3.3 :指针的局部变量问题。局部的指针变量会被程序自动释放，若程序员引用此类指针就会出错。 2007-9-1
4．二维指针的应用实例：
#include
#include
void sort(char (*client)[10]);
void main()
{
int temp;
char client[3][10];
char (*pClient)[10] = NULL;
for( temp = 0; temp < 3; temp++ )
{
gets(client[temp]);
}
pClient = client;
sort(pClient);
for( temp = 0; temp < 3; temp++ )
{
puts(*(pClient + temp));
}
}
void sort(char (*client)[10])
{
//冒泡算法的明了写法
int temp1, temp2;
char temp[10];
for( temp1 = 2; temp1 > 0; temp1-- )//控制每一步的比较次数
{
for( temp2 = 0; temp2 < temp1; temp2++ )//比较指针
{
if( strcmp (*(client + temp2), *(client + temp2 + 1)) )//比较过程
{
strcpy(temp, *(client + temp2));
strcpy(*(client + temp2), *(client + temp2 + 1));
strcpy(*(client + temp2 + 1), temp);
}
}
}
}
5．类型转换中的结构体：如p = (struct student * )stu[0].name 将p指向结构体的内部元素的地址，要进行类型转换，先转换为p的类型。
6.定义在函数内部的指针结构体是不会被系统释放的。例程：猫和老鼠。
void Insert(struct student *pHeadGet, int numInsert)
{
struct student *pOne, *pTwo, *pInsert;
int temp;
pTwo = pOne = pHeadGet;
for( temp = 0; temp < numInsert - 1; temp++ )
{
pTwo = pTwo->pNext;
}
pOne = pTwo->pNext;
printf("Please into the number and the score:/n");
pInsert = (struct student *) malloc(LEN);//这个在函数内部开辟的空间在函数调用后还是保留在内存
scanf("%d%d", &pInsert->number, &pInsert->score);
pTwo->pNext = pInsert;
pInsert->pNext = pOne;
}
7:连接字符的错误写法：
#include
main()
{
char a[]="wo shi libingbing", b[] = "li jiang ye shi wo";
char *p1, *p2;
p1 = a;
p2 = b;
//*(p1 + 17) = *(p2 +0);
//(p1 +17) = p2;此处在尝试改变数组的值，这是不允许的
printf("%s", p1);
}
8．指针中赋值和修改的一些容易错误和注意的地方
#include
void main()
{
char amessage[] = "now is the time";
char *pmessage = "now is the time";
int *pInt = {2, 3, 6, 23};//这样的定义是不允许的
*(amessage + 3) = 'H';
// *(pmessage +3) = 'H'; 不能尝试修改指针定义的字符数组
printf("%s/n%s/n", amessage, pmessage);
pmessage = amessage;
*(pmessage +3) = 'h';
printf("%s/n%s/n", amessage, pmessage);//从执行结果可以知道指针只是一种指向，不能达到引用并修改字符串的能力
// *(pInt + 3) = 8;
// printf("%d", pInt);
}
9．字符串的操作：
stringDepart()
//讲字符串进行分解成单个单词的形式
//返回打印结果
while (tempChar = GETCHAR != EOF)
{
if (tempChar == (‘ ’ || ‘/n’ || ‘/t’))
{
if (STATE == IN)
{
// 得到一个单词
STATE == OUT;
}
else if (STATE == OUT)
{
STATE == IN;
//操作字符
}
else
{
//操作字符
}/
}//end if (tempChar == (‘ ’ || ‘/n’ || ‘/t’))
}///stringDepart
10．Stract函数：
/*strcat function*/
//函数将字符串t接到s中
void strcat(char *s, char *t)
{
while (*s)
s++;
while(*s++ = *t++)
;
}
11．标准的冒泡排序：
for( times = length - 1; times > 0; times--) //排序的次数
for( client = 0; client < times; client++) //控制比较
if (item[client] > item[client + 1]) //比较交换
{
//交换client和client + 1的值
}
12．用户控制的程序结束：
while(1)
{
//操作代码
if(checkChar = ‘q’ || ‘Q’) return;
//操作代码
}
13．用堆栈实现的表达式的计算：
函数算法：
float getnumber(void)
//提取表达式中的一个几位数字，也要判断其格式的正确与否
//输入为void，返回是一个float型数
//用于学习的目的编写的
{
if (point > strLen -1) //假如没有任何字符
return NULL;
if (*(string + point) == ‘－’)
return NULL;
while (string[point] == '(')
{
if (string[point+1] == '-')
{ //负号
point++;
return 0;
}
else if (*(string + point+1) == '(')
push(0); //压入栈中，
else
break;
}
}
14．Main函数的规范写法：
int
main(int argc, char **argv)
15．C学习的难易：
学习c有一个学期了，对于c语言这样的一个词汇，有人会发帖问这语言如何？好学？不好学？对于语言本身没有好学与不好学的，而真正主导编程的不是语言而是语言和数据的搭配——数据结构；最这看来我们可能可以得到这样的结论：语言和数据结构没有必要有先后，可以同时学啊，是的这样就使语言有难易之分。
16．C++是c的优化：
1.在c++中我们提倡使用const char * const authorName = "Scott Meyers";这样的方式，对于指针我们要使指针本身常量化，也要使指针所指的变量常量化。这就是上面这样做的原因。
2.对于define所造成的混乱：
#define max(a,b) ((a) > (b) ? (a) : (b))
int a = 5, b = 0;
max(++a, b);// a 的值增加了2次
max(++a, b+10); // a 的值只增加了1次
内联函数解决了这个问题：
template
inline const T& max(const T& a, const T& b)
{ return a > b ? a : b; }
3. string *stringarray1 =static_cast
string *stringarray2 = new string[10];
其结果是，stringarray1确实指向的是可以容纳10个string对象的足够空间，但内存里并没有创建这些对象。而且，如果你不从这种晦涩的语法怪圈(详见条款m4和m8的描述)里跳出来的话，你没有办法来初始化数组里的对象。换句话说，stringarray1其实一点用也没有。相反，stringarray2指向的是一个包含10个完全构造好的string对象的数组,每个对象可以在任何读取string的操作里安全使用。
把new和delete与malloc和free混在一起用也是个坏想法。对一个用new获取来的指针调用free，或者对一个用malloc获取来的指针调用delete，其后果是不可预测的。大家都知道“不可预测”的意思：它可能在开发阶段工作良好，在测试阶段工作良好，但也可能会最后在你最重要的客户的脸上爆炸。
如果你调用new时用了[]，调用delete时也要用[]。如果调用new时没有用[]，那调用delete时也不要用[]。
17．Malloc的一个问题
对于malloc在ANSI C之前的C版本中，还需要用类型转换运算符。
18．预处理问题
C++语法接受#define int INT, integer
19．“，”运算符问题
在c的编译器中”，”运算符是不能做为左值的，但是在c++中解决了这个问题，她可以做左值。
20．关于运算符的一个例子
在不同的编译器下，有些表达式得到的结果是不尽相同的，比如下面的表达式：a = 1 , b = 1;(a * b + ++b);在vc中得到是3, 而在bc中得到的却是1×2＋2 ＝ 4。从这个例子可以看出来，运算符之间的优先级是没有特别必要去区分的，像这样的题目要得到不同的运算方式可以采用讲语句分成两个语句，实现起来没什么不爽的。
就如在这样的一个表达式中，++a*(a + b).一般我们会认为括号的运算级别最高，但是错了，先是++a.然后再进入括号运算。呜呼！累，没必要啊，可是有些题目就是这样，悲哉！
21．把二进制转换为十进制的算法表示（用位运算实现）
//以字符型来表示二进制数字，对其进行检测，得到unsign型的int型数据输出。
unsigned long BtoD(char *str)
{
int i;
unsigned long m;
unsigned long n = 0;
int len = strlen(str);
if (len > 32)
len = 32;
m = 0x80000000 >> (32 - len);
for(i = 0; i < len; ++i)
{
if (str[i] == '1') // 非法字符认作 0
n |= m;
m >>= 1;
}
return n;
}
22．一道经典题目：关键是速度。
有五位小姐排成一列，所有的小姐姓不同、穿的衣服颜色不同、喝不同的饮料、养不同的宠物、吃不同的水果。
钱小姐穿红色衣服；翁小姐养了一只狗；陈小姐喝茶；穿绿衣服的站在穿
白衣服的左边；穿绿衣服的小姐喝咖啡；吃西瓜的小姐养鸟；穿黄衣服的小姐吃
梨；站在中间的小姐喝牛奶；赵小姐站在最左边；吃橘子的小姐站在养猫的旁边；
养鱼的小姐旁边的那位吃梨；吃苹果的小姐喝香槟；江小姐吃香蕉；赵小姐站在
穿蓝衣服的小姐旁边；喝开水的小姐站在吃橘子的小姐旁边；请问哪位小姐养蛇？
答案和解析：
本题是柏林大学的一次考试题，要求在30分钟内做出，不过只有少于10%的人完成了要求。计分是这样的，共150分，从1到30分钟，每加1分钟减2分,那么30分钟答出就是90分，是及格分；从30分钟以后每加1分钟减1分。我当时用了22分钟，大家也试试，看自己能得多少分。
赵小姐穿黄色衣服，喝白开水，吃梨，奍猫
陈小姐穿蓝色衣服，喝茶，吃橘子，奍鱼
钱小姐穿红色衣服，喝牛奶，吃西瓜，奍鸟
江小姐穿绿色衣服，喝咖啡，吃香蕉，奍蛇
翁小姐穿白色衣服，喝香槟，吃苹果，奍狗
22．C++中的重载函数的实现：
使用名字粉碎的方式，对不同的函数加以区分。如：int f(char a, int b, float c);编译后就是f_cif()；
23．关于临时变量中使用i的看法：
对于代码规范来说使用i作为临时变量也是可取的，用此作为循环变量是可以的。
24．一个字符串常量定义的应用错误：
#include
#include
void main()
{
//这样定义就是指getSource，source指向的是一组字符串常量
char *source = "China";//改为这样的定义方式就对了：source[] = “China”;
char *getSource = "Republic of";
printf("%s %s ",getSource, source); //可以引用常量，但是不能改变常量
printf("%s", strcpy(getSource, source)); //执行错误
printf("%s", strncpy(getSource, source, sizeof(source))); //执行错误
}
25．一个不明白的执行错误：
nafxcwd.lib(thrdcore.obj) : error LNK2001: unresolved external symbol __endthreadex
nafxcwd.lib(thrdcore.obj) : error LNK2001: unresolved external symbol __beginthreadex
26．匈牙利命名法：
windows API的命名法则是匈牙利籍微软专家：查尔斯西蒙尼在博士论文里提出的。
1． 标示符的名字以一个或者多个小写字母开头，用这些字母来指定数据类型：
| 前缀 |
数据类型
|
| c |
字符 |
| s |
字符串 |
| cb |
用于定义对象(一般为一个结构)尺寸的整数 |
| n |
整数 |
| by |
字节 |
| i |
Int（整数） |
| x |
短整数(坐标x) |
| y |
短整数(坐标Y) |
| b |
Boolean（布尔值） |
| w |
字（Word， 焐符号短整数） |
| l |
长整数(long) |
| g |
HANDLE(无符号int) |
| m |
类成员变量 |
| fn |
函数(function) |
| dw |
双字(double word，无符号长整形) |
2．其他则从第二个字符起采用“驼峰”命名规则。
27．Cstring转换LPBYTE格式:
//
// 将CString转换为LPBYTE
//
LPBYTE lpb = new BYTE[name.GetLength()+1];
for(int i = 0; i< name.GetLength();i++)
lpb[i] = name[i];
lpb[name.GetLength()] = 0;
//
28．网络编程用的基本函数：
本文所谈到的Socket函数如果没有特别说明，都是指的Windows Socket API。
一、WSAStartup函数
int WSAStartup(
WORD wVersionRequested,
LPWSADATA lpWSAData
);
使用Socket的程序在使用Socket之前必须调用WSAStartup函数。该函数的第一个参数指明程序请求使用的Socket版本，其中高位字节指明副版本、低位字节指明主版本；操作系统利用第二个参数返回请求的Socket的版本信息。当一个应用程序调用WSAStartup函数时，操作系统根据请求的Socket版本来搜索相应的Socket库，然后绑定找到的Socket库到该应用程序中。以后应用程序就可以调用所请求的Socket库中的其它Socket函数了。该函数执行成功后返回0。
例：假如一个程序要使用2.1版本的Socket,那么程序代码如下
wVersionRequested = MAKEWORD( 2, 1 );
err = WSAStartup( wVersionRequested, &wsaData );
二、WSACleanup函数
int WSACleanup (void);
应用程序在完成对请求的Socket库的使用后，要调用WSACleanup函数来解除与Socket库的绑定并且释放Socket库所占用的系统资源。
三、socket函数
SOCKET socket(
int af,
int type,
int protocol
);
应用程序调用socket函数来创建一个能够进行网络通信的套接字。第一个参数指定应用程序使用的通信协议的协议族，对于TCP/IP协议族，该参数置PF_INET;第二个参数指定要创建的套接字类型，流套接字类型为SOCK_STREAM、数据报套接字类型为SOCK_DGRAM；第三个参数指定应用程序所使用的通信协议。
该函数如果调用成功就返回新创建的套接字的描述符，如果失败就返回INVALID_SOCKET。套接字描述符是一个整数类型的值。每个进程的进程空间里都有一个套接字描述符表，该表中存放着套接字描述符和套接字数据结构的对应关系。该表中有一个字段存放新创建的套接字的描述符，另一个字段存放套接字数据结构的地址，因此根据套接字描述符就可以找到其对应的套接字数据结构。每个进程在自己的进程空间里都有一个套接字描述符表但是套接字数据结构都是在操作系统的内核缓冲里。下面是一个创建流套接字的例子：
struct protoent *ppe;
ppe=getprotobyname("tcp");
SOCKET ListenSocket=socket(PF_INET,SOCK_STREAM,ppe->p_proto);
四、closesocket函数
int closesocket(
SOCKET s
);
closesocket函数用来关闭一个描述符为s套接字。由于每个进程中都有一个套接字描述符表，表中的每个套接字描述符都对应了一个位于操作系统缓冲区中的套接字数据结构，因此有可能有几个套接字描述符指向同一个套接字数据结构。套接字数据结构中专门有一个字段存放该结构的被引用次数，即有多少个套接字描述符指向该结构。当调用closesocket函数时，操作系统先检查套接字数据结构中的该字段的值，如果为1，就表明只有一个套接字描述符指向它，因此操作系统就先把s在套接字描述符表中对应的那条表项清除，并且释放s对应的套接字数据结构；如果该字段大于1，那么操作系统仅仅清除s在套接字描述符表中的对应表项，并且把s对应的套接字数据结构的引用次数减1。
closesocket函数如果执行成功就返回0，否则返回SOCKET_ERROR。
五、send函数
int send(
SOCKET s,
const char FAR *buf,
int len,
int flags
);
不论是客户还是服务器应用程序都用send函数来向TCP连接的另一端发送数据。客户程序一般用send函数向服务器发送请求，而服务器则通常用send函数来向客户程序发送应答。该函数的第一个参数指定发送端套接字描述符；第二个参数指明一个存放应用程序要发送数据的缓冲区；第三个参数指明实际要发送的数据的字节数；第四个参数一般置0。这里只描述同步Socket的send函数的执行流程。当调用该函数时，send先比较待发送数据的长度len和套接字s的发送缓冲区的长度，如果len大于s的发送缓冲区的长度，该函数返回SOCKET_ERROR；如果len小于或者等于s的发送缓冲区的长度，那么send先检查协议是否正在发送s的发送缓冲中的数据，如果是就等待协议把数据发送完，如果协议还没有开始发送s的发送缓冲中的数据或者s的发送缓冲中没有数据，那么send就比较s的发送缓冲区的剩余空间和len，如果len大于剩余空间大小send就一直等待协议把s的发送缓冲中的数据发送完，如果len小于剩余空间大小send就仅仅把buf中的数据copy到剩余空间里（注意并不是send把s的发送缓冲中的数据传到连接的另一端的，而是协议传的，send仅仅是把buf中的数据copy到s的发送缓冲区的剩余空间里）。如果send函数copy数据成功，就返回实际copy的字节数，如果send在copy数据时出现错误，那么send就返回SOCKET_ERROR；如果send在等待协议传送数据时网络断开的话，那么send函数也返回SOCKET_ERROR。要注意send函数把buf中的数据成功copy到s的发送缓冲的剩余空间里后它就返回了，但是此时这些数据并不一定马上被传到连接的另一端。如果协议在后续的传送过程中出现网络错误的话，那么下一个Socket函数就会返回SOCKET_ERROR。（每一个除send外的Socket函数在执行的最开始总要先等待套接字的发送缓冲中的数据被协议传送完毕才能继续，如果在等待时出现网络错误，那么该Socket函数就返回SOCKET_ERROR）
注意：在Unix系统下，如果send在等待协议传送数据时网络断开的话，调用send的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。
六、recv函数
int recv(
SOCKET s,
char FAR *buf,
int len,
int flags
);
不论是客户还是服务器应用程序都用recv函数从TCP连接的另一端接收数据。该函数的第一个参数指定接收端套接字描述符；第二个参数指明一个缓冲区，该缓冲区用来存放recv函数接收到的数据；第三个参数指明buf的长度；第四个参数一般置0。这里只描述同步Socket的recv函数的执行流程。当应用程序调用recv函数时，recv先等待s的发送缓冲中的数据被协议传送完毕，如果协议在传送s的发送缓冲中的数据时出现网络错误，那么recv函数返回SOCKET_ERROR，如果s的发送缓冲中没有数据或者数据被协议成功发送完毕后，recv先检查套接字s的接收缓冲区，如果s接收缓冲区中没有数据或者协议正在接收数据，那么recv就一直等待，只到协议把数据接收完毕。当协议把数据接收完毕，recv函数就把s的接收缓冲中的数据copy到buf中（注意协议接收到的数据可能大于buf的长度，所以在这种情况下要调用几次recv函数才能把s的接收缓冲中的数据copy完。recv函数仅仅是copy数据，真正的接收数据是协议来完成的），recv函数返回其实际copy的字节数。如果recv在copy时出错，那么它返回SOCKET_ERROR；如果recv函数在等待协议接收数据时网络中断了，那么它返回0。
注意：在Unix系统下，如果recv函数在等待协议接收数据时网络断开了，那么调用recv的进程会接收到一个SIGPIPE信号，进程对该信号的默认处理是进程终止。
七、bind函数
int bind(
SOCKET s,
const struct sockaddr FAR *name,
int namelen
);
当创建了一个Socket以后，套接字数据结构中有一个默认的IP地址和默认的端口号。一个服务程序必须调用bind函数来给其绑定一个IP地址和一个特定的端口号。客户程序一般不必调用bind函数来为其Socket绑定IP地址和断口号。该函数的第一个参数指定待绑定的Socket描述符；第二个参数指定一个sockaddr结构，该结构是这样定义的：
struct sockaddr {
u_short sa_family;
char sa_data[14];
};
sa_family指定地址族，对于TCP/IP协议族的套接字，给其置AF_INET。当对TCP/IP协议族的套接字进行绑定时，我们通常使用另一个地址结构：
struct sockaddr_in {
short sin_family;
u_short sin_port;
struct in_addr sin_addr;
char sin_zero[8];
};
其中sin_family置AF_INET；sin_port指明端口号；sin_addr结构体中只有一个唯一的字段s_addr，表示IP地址，该字段是一个整数，一般用函数inet_addr（）把字符串形式的IP地址转换成unsigned long型的整数值后再置给s_addr。有的服务器是多宿主机，至少有两个网卡，那么运行在这样的服务器上的服务程序在为其Socket绑定IP地址时可以把htonl(INADDR_ANY)置给s_addr，这样做的好处是不论哪个网段上的客户程序都能与该服务程序通信；如果只给运行在多宿主机上的服务程序的Socket绑定一个固定的IP地址，那么就只有与该IP地址处于同一个网段上的客户程序才能与该服务程序通信。我们用0来填充sin_zero数组，目的是让sockaddr_in结构的大小与sockaddr结构的大小一致。下面是一个bind函数调用的例子：
struct sockaddr_in saddr；
saddr.sin_family = AF_INET;
saddr.sin_port = htons(8888);
saddr.sin_addr.s_addr = htonl(INADDR_ANY);
bind(ListenSocket,(struct sockaddr *)&saddr,sizeof(saddr))；
八、listen函数
int listen( SOCKET s, int backlog );
服务程序可以调用listen函数使其流套接字s处于监听状态。处于监听状态的流套接字s将维护一个客户连接请求队列，该队列最多容纳backlog个客户连接请求。假如该函数执行成功，则返回0；如果执行失败，则返回SOCKET_ERROR。
九、accept函数
SOCKET accept(
SOCKET s,
struct sockaddr FAR *addr,
int FAR *addrlen
);
服务程序调用accept函数从处于监听状态的流套接字s的客户连接请求队列中取出排在最前的一个客户请求，并且创建一个新的套接字来与客户套接字创建连接通道，如果连接成功，就返回新创建的套接字的描述符，以后与客户套接字交换数据的是新创建的套接字；如果失败就返回INVALID_SOCKET。该函数的第一个参数指定处于监听状态的流套接字；操作系统利用第二个参数来返回新创建的套接字的地址结构；操作系统利用第三个参数来返回新创建的套接字的地址结构的长度。下面是一个调用accept的例子：
struct sockaddr_in ServerSocketAddr;
int addrlen;
addrlen=sizeof(ServerSocketAddr);
ServerSocket=accept(ListenSocket,(struct sockaddr *)&ServerSocketAddr,&addrlen);
十、connect函数
int connect(
SOCKET s,
const struct sockaddr FAR *name,
int namelen
);
客户程序调用connect函数来使客户Socket s与监听于name所指定的计算机的特定端口上的服务Socket进行连接。如果连接成功，connect返回0；如果失败则返回SOCKET_ERROR。下面是一个例子：
struct sockaddr_in daddr;
memset((void *)&daddr,0,sizeof(daddr));
daddr.sin_family=AF_INET;
daddr.sin_port=htons(8888);
daddr.sin_addr.s_addr=inet_addr("133.197.22.4");
connect(ClientSocket,(struct sockaddr *)&daddr,sizeof(daddr))；
29．线程和进程：
［前言：］当前流行的Windows操作系统，它能同时运行几个程序(独立运行的程序又称之为进程)，对于同一个程序，它又可以分成若干个独立的执行流，我们称之为线程，线程提供了多任务处理的能力。用进程和线程的观点来研究软件是当今普遍采用的方法，进程和线程的概念的出现，对提高软件的并行性有着重要的意义。现在的应用软件无一不是多线程多任务处理，单线城的软件是不可想象的。因此掌握多线程多任务设计方法对每个程序员都是必需要掌握的。本文针对多线程技术在应用中经常遇到的问题，如线程间的通信、同步等，对它们分别进行探讨。
一、 理解线程
要讲解线程，不得不说一下进程，进程是应用程序的执行实例，每个进程是由私有的虚拟地址空间、代码、数据和其它系统资源组成。进程在运行时创建的资源随着进程的终止而死亡。线程的基本思想很简单，它是一个独立的执行流，是进程内部的一个独立的执行单元，相当于一个子程序，它对应Visual C++中的CwinThread类的对象。单独一个执行程序运行时，缺省的运行包含的一个主线程，主线程以函数地址的形式，如main或WinMain函数，提供程序的启动点，当主线程终止时，进程也随之终止，但根据需要，应用程序又可以分解成许多独立执行的线程，每个线程并行的运行在同一进程中。
一个进程中的所有线程都在该进程的虚拟地址空间中，使用该进程的全局变量和系统资源。操作系统给每个线程分配不同的CPU时间片，在某一个时刻，CPU只执行一个时间片内的线程，多个时间片中的相应线程在CPU内轮流执行，由于每个时间片时间很短，所以对用户来说，仿佛各个线程在计算机中是并行处理的。操作系统是根据线程的优先级来安排CPU的时间，优先级高的线程优先运行，优先级低的线程则继续等待。
线程被分为两种：用户界面线程和工作线程（又称为后台线程）。用户界面线程通常用来处理用户的输入并响应各种事件和消息，其实，应用程序的主执行线程CWinAPP对象就是一个用户界面线程，当应用程序启动时自动创建和启动，同样它的终止也意味着该程序的结束，进城终止。工作者线程用来执行程序的后台处理任务，比如计算、调度、对串口的读写操作等，它和用户界面线程的区别是它不用从CwinThread类派生来创建，对它来说最重要的是如何实现工作线程任务的运行控制函数。工作线程和用户界面线程启动时要调用同一个函数的不同版本；最后需要读者明白的是，一个进程中的所有线程共享它们父进程的变量，但同时每个线程可以拥有自己的变量。
二、 线程的管理和操作
1． 线程的启动
创建一个用户界面线程，首先要从类CwinThread产生一个派生类，同时必须使用DECLARE_DYNCREATE和IMPLEMENT_DYNCREATE来声明和实现这个CwinThread派生类。
第二步是根据需要重载该派生类的一些成员函数如：ExitInstance()；InitInstance()；OnIdle();PreTranslateMessage()等函数，最后启动该用户界面线程，调用AfxBeginThread()函数的一个版本：CWinThread* AfxBeginThread( CRuntimeClass* pThreadClass, int nPriority = THREAD_PRIORITY_NORMAL, UINT nStackSize = 0, DWORD dwCreateFlags = 0, LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL );其中第一个参数为指向定义的用户界面线程类指针变量，第二个参数为线程的优先级，第三个参数为线程所对应的堆栈大小，第四个参数为线程创建时的附加标志，缺省为正常状态，如为CREATE_SUSPENDED则线程启动后为挂起状态。
对于工作线程来说，启动一个线程，首先需要编写一个希望与应用程序的其余部分并行运行的函数如Fun1()，接着定义一个指向CwinThread对象的指针变量*pThread,调用AfxBeginThread(Fun1,param,priority)函数，返回值付给pThread变量的同时一并启动该线程来执行上面的Fun1()函数，其中Fun1是线程要运行的函数的名字，也既是上面所说的控制函数的名字，param是准备传送给线程函数Fun1的任意32位值，priority则是定义该线程的优先级别，它是预定义的常数，读者可参考MSDN。
2．线程的优先级
以下的CwinThread类的成员函数用于线程优先级的操作：
int GetThreadPriority();
BOOL SetThradPriority()(int nPriority);
上述的二个函数分别用来获取和设置线程的优先级，这里的优先级，是相对于该线程所处的优先权层次而言的，处于同一优先权层次的线程，优先级高的线程先运行；处于不同优先权层次上的线程，谁的优先权层次高，谁先运行。至于优先级设置所需的常数，自己参考MSDN就可以了，要注意的是要想设置线程的优先级，这个线程在创建时必须具有THREAD_SET_INFORMATION访问权限。对于线程的优先权层次的设置，CwinThread类没有提供相应的函数，但是可以通过Win32 SDK函数GetPriorityClass()和SetPriorityClass()来实现。
3．线程的悬挂、恢复
CwinThread类中包含了应用程序悬挂和恢复它所创建的线程的函数，其中SuspendThread()用来悬挂线程，暂停线程的执行；ResumeThread()用来恢复线程的执行。如果你对一个线程连续若干次执行SuspendThread()，则需要连续执行相应次的ResumeThread()来恢复线程的运行。
4．结束线程
终止线程有三种途径，线程可以在自身内部调用AfxEndThread()来终止自身的运行；可以在线程的外部调用BOOL TerminateThread( HANDLE hThread, DWORD dwExitCode )来强行终止一个线程的运行，然后调用CloseHandle（）函数释放线程所占用的堆栈；第三种方法是改变全局变量，使线程的执行函数返回，则该线程终止。下面以第三种方法为例，给出部分代码：
//CtestView message handlers
/Set to True to end thread
Bool bend=FALSE;//定义的全局变量，用于控制线程的运行
//The Thread Function
UINT ThreadFunction(LPVOID pParam)//线程函数
{
while(!bend)
{Beep(100,100);
Sleep(1000);
}
return 0;
}
CwinThread *pThread;
HWND hWnd;
/
Void CtestView::OninitialUpdate()
{
hWnd=GetSafeHwnd();
pThread=AfxBeginThread(ThradFunction,hWnd);//启动线程
pThread->m_bAutoDelete=FALSE;//线程为手动删除
Cview::OnInitialUpdate();
}
Void CtestView::OnDestroy()
{ bend=TRUE;//改变变量，线程结束
WaitForSingleObject(pThread->m_hThread,INFINITE);//等待线程结束
delete pThread;//删除线程
Cview::OnDestroy();
}
三、 线程之间的通信
通常情况下，一个次级线程要为主线程完成某种特定类型的任务，这就隐含着表示在主线程和次级线程之间需要建立一个通信的通道。一般情况下，有下面的几种方法实现这种通信任务：使用全局变量（上一节的例子其实使用的就是这种方法）、使用事件对象、使用消息。这里我们主要介绍后两种方法。
1． 利用用户定义的消息通信
在Windows程序设计中，应用程序的每一个线程都拥有自己的消息队列，甚至工作线程也不例外，这样一来，就使得线程之间利用消息来传递信息就变的非常简单。首先用户要定义一个用户消息，如下所示：#define WM_USERMSG WMUSER+100；在需要的时候，在一个线程中调用
：：PostMessage((HWND)param,WM_USERMSG,0,0)
或
CwinThread::PostThradMessage()
来向另外一个线程发送这个消息，上述函数的四个参数分别是消息将要发送到的目的窗口的句柄、要发送的消息标志符、消息的参数WPARAM和LPARAM。下面的代码是对上节代码的修改，修改后的结果是在线程结束时显示一个对话框，提示线程结束：
UINT ThreadFunction(LPVOID pParam)
{
while(!bend)
{
Beep(100,100);
Sleep(1000);
}
：：PostMessage(hWnd,WM_USERMSG,0,0)；
return 0;
}
WM_USERMSG消息的响应函数为OnThreadended(WPARAM wParam,LPARAM lParam)
LONG CTestView::OnThreadended(WPARAM wParam,LPARAM lParam)
{
AfxMessageBox("Thread ended.");
Retrun 0;
}
上面的例子是工作者线程向用户界面线程发送消息，对于工作者线程，如果它的设计模式也是消息驱动的，那么调用者可以向它发送初始化、退出、执行某种特定的处理等消息，让它在后台完成。在控制函数中可以直接使用：：GetMessage()这个SDK函数进行消息分检和处理，自己实现一个消息循环。GetMessage()函数在判断该线程的消息队列为空时，线程将系统分配给它的时间片让给其它线程，不无效的占用CPU的时间，如果消息队列不为空，就获取这个消息，判断这个消息的内容并进行相应的处理。
2．用事件对象实现通信
在线程之间传递信号进行通信比较复杂的方法是使用事件对象，用MFC的Cevent类的对象来表示。事件对象处于两种状态之一：有信号和无信号，线程可以监视处于有信号状态的事件，以便在适当的时候执行对事件的操作。上述例子代码修改如下：
Cevent threadStart,threadEnd;
UINT ThreadFunction(LPVOID pParam)
{
：：WaitForSingleObject(threadStart.m_hObject,INFINITE);
AfxMessageBox("Thread start.");
while(!bend)
{
Beep(100,100);
Sleep(1000);
Int result=::WaitforSingleObject(threadEnd.m_hObject,0);
//等待threadEnd事件有信号，无信号时线程在这里悬停
If(result==Wait_OBJECT_0)
Bend=TRUE;
}
：：PostMessage(hWnd,WM_USERMSG,0,0)；
return 0;
}
/
Void CtestView::OninitialUpdate()
{
hWnd=GetSafeHwnd();
threadStart.SetEvent();//threadStart事件有信号
pThread=AfxBeginThread(ThreadFunction,hWnd);//启动线程
pThread->m_bAutoDelete=FALSE;
Cview::OnInitialUpdate();
}
Void CtestView::OnDestroy()
{ threadEnd.SetEvent();
WaitForSingleObject(pThread->m_hThread,INFINITE);
delete pThread;
Cview::OnDestroy();
}
运行这个程序，当关闭程序时，才显示提示框，显示"Thread ended"
四、 线程之间的同步
前面我们讲过，各个线程可以访问进程中的公共变量，所以使用多线程的过程中需要注意的问题是如何防止两个或两个以上的线程同时访问同一个数据，以免破坏数据的完整性。保证各个线程可以在一起适当的协调工作称为线程之间的同步。前面一节介绍的事件对象实际上就是一种同步形式。Visual C++中使用同步类来解决操作系统的并行性而引起的数据不安全的问题，MFC支持的七个多线程的同步类可以分成两大类：同步对象（CsyncObject、Csemaphore、Cmutex、CcriticalSection和Cevent）和同步访问对象（CmultiLock和CsingleLock）。本节主要介绍临界区（critical section）、互斥（mutexe）、信号量（semaphore），这些同步对象使各个线程协调工作，程序运行起来更安全。
1． 临界区
临界区是保证在某一个时间只有一个线程可以访问数据的方法。使用它的过程中，需要给各个线程提供一个共享的临界区对象，无论哪个线程占有临界区对象，都可以访问受到保护的数据，这时候其它的线程需要等待，直到该线程释放临界区对象为止，临界区被释放后，另外的线程可以强占这个临界区，以便访问共享的数据。临界区对应着一个CcriticalSection对象，当线程需要访问保护数据时，调用临界区对象的Lock()成员函数；当对保护数据的操作完成之后，调用临界区对象的Unlock()成员函数释放对临界区对象的拥有权，以使另一个线程可以夺取临界区对象并访问受保护的数据。同时启动两个线程，它们对应的函数分别为WriteThread()和ReadThread()，用以对公共数组组array[]操作，下面的代码说明了如何使用临界区对象：
#include "afxmt.h"
int array[10],destarray[10];
CCriticalSection Section;
UINT WriteThread(LPVOID param)
{Section.Lock();
for(int x=0;x<10;x++)
array[x]=x;
Section.Unlock();
}
UINT ReadThread(LPVOID param)
{
Section.Lock();
For(int x=0;x<10;x++)
Destarray[x]=array[x];
Section.Unlock();
}
上述代码运行的结果应该是Destarray数组中的元素分别为1-9，而不是杂乱无章的数，如果不使用同步，则不是这个结果，有兴趣的读者可以实验一下。
2． 互斥
互斥与临界区很相似，但是使用时相对复杂一些，它不仅可以在同一应用程序的线程间实现同步，还可以在不同的进程间实现同步，从而实现资源的安全共享。互斥与Cmutex类的对象相对应，使用互斥对象时，必须创建一个CSingleLock或CMultiLock对象，用于实际的访问控制，因为这里的例子只处理单个互斥，所以我们可以使用CSingleLock对象，该对象的Lock()函数用于占有互斥，Unlock()用于释放互斥。实现代码如下：
#include "afxmt.h"
int array[10],destarray[10];
CMutex Section;
/
UINT WriteThread(LPVOID param)
{ CsingleLock singlelock;
singlelock (&Section);
singlelock.Lock();
for(int x=0;x<10;x++)
array[x]=x;
singlelock.Unlock();
}
UINT ReadThread(LPVOID param)
{ CsingleLock singlelock;
singlelock (&Section);
singlelock.Lock();
For(int x=0;x<10;x++)
Destarray[x]=array[x];
singlelock.Unlock();
}
3． 信号量
信号量的用法和互斥的用法很相似，不同的是它可以同一时刻允许多个线程访问同一个资源，创建一个信号量需要用Csemaphore类声明一个对象，一旦创建了一个信号量对象，就可以用它来对资源的访问技术。要实现计数处理，先创建一个CsingleLock或CmltiLock对象，然后用该对象的Lock()函数减少这个信号量的计数值，Unlock()反之。下面的代码分别启动三个线程，执行时同时显示二个消息框，然后10秒后第三个消息框才得以显示。
/
Csemaphore *semaphore;
Semaphore=new Csemaphore(2,2);
HWND hWnd=GetSafeHwnd();
AfxBeginThread(threadProc1,hWnd);
AfxBeginThread(threadProc2,hWnd);
AfxBeginThread(threadProc3,hWnd);
//
UINT ThreadProc1(LPVOID param)
{CsingleLock singelLock(semaphore);
singleLock.Lock();
Sleep(10000);
::MessageBox((HWND)param,"Thread1 had access","Thread1",MB_OK);
return 0;
}
UINT ThreadProc2(LPVOID param)
{CSingleLock singelLock(semaphore);
singleLock.Lock();
Sleep(10000);
::MessageBox((HWND)param,"Thread2 had access","Thread2",MB_OK);
return 0;
}
UINT ThreadProc3(LPVOID param)
{CsingleLock singelLock(semaphore);
singleLock.Lock();
Sleep(10000);
::MessageBox((HWND)param,"Thread3 had access","Thread3",MB_OK);
return 0;
}
30．程序的自动运行：
内容提要
在工作中经常遇到一些程序，当计算机启动时会自动将该程序加载，以实现对计算机的监控等特殊的目的。本文就针对这个问题，阐述了系统加载特定程序的原理和方法，同时利用VC++ 6.0编程实现这种特定的功能的，并对其中的关键代码进行了分析。
文章正文
工作中经常遇到一些程序，它们在系统启动的过程中，自动打开并运行，以便实现对系统的监控或者病毒的检测等特定的目的，典型的例子就是常用的一些杀毒软件如：KV300及瑞星杀毒软件等。笔者在此，以自己的编程实践为基础，说明这些这些程序自动启动的原理和方法，同时对一些典型程序代码进行分析，以便读者在今后的编程过程中使用。
一、 程序自动启动的原理及方法：
1. 利用WIN.INI文件实现相关程序的自动启动
WIN.INI是系统保存在C:WINDOWS目录下的一个系统初始化文件。系统在起动时会检索该文件中的相关项，以便对系统环境的初始设置。
在该文件中的"[windows]"数据段中，有两个数据项"load="和"run=",它们的作用就是在系统起动之后自动得装入和运行相关的程序。如果我们需要在系统起动之后装入并运行一个程序，只将需要运行文件的全文件名添加在该数据项的后面系统起动后就会自动运行该程序，系统也会进入特定的操作环境中去。
2. 利用注册表实现相关程序的自动启动
系统注册表保存着系统的软件、硬件及其他与系统配置有关的重要信息，一个计算机系统的系统注册表一旦遭到破坏，整个系统将无法运行。
在计算机的系统注册表中的子目录中有一个目录的名称为HKEY_LOCAL_MACHINESoftware MicrosoftWindowsCurrent_VersionRun，如果你想让程序在系统起动的过程中启动该程序，就可以向该目录添加一个子项，具体的过程是在注册表中右击该项，选中其中的"新建"项目，然后选中其中的"串值"，建立新的串值后将它的名称改成相应的名称，双击新建的串值，输入新的数值，自动启动程序的过程就设置完成。
二、 利用VC++编程实现程序自动启动的编程实例。
微软公司提供的VC++ 6.0程序开发工具功能非常强大。在VC++ 6.0中同时具有对注册表和*.INI文件操作的函数。笔者经过一段时间的摸索，成功的利用VC++ 6.0开发成功了一个小软件，该软件利用系统自动启动程序的原理，将原来需要的繁琐的手动工作转变成成计算机的自动设置工作，使系统自动启动相关程序的设置工作变的非常简单可靠。
1.程序功能概述：
程序的主界面是对话框，在主界面对话框中有编辑框（EDIT BOX），圆形按钮（RADIO BUTTON）和普通按钮（COMMON BUTTON）组成。操作者通过向编辑框中添加需要自动加载的程序的全文件名（也可以通过浏览按钮来完成），然后通过对两个RADIO BUTTON的选择，进而完成对加载方式的选择（是选用注册表方式还是选者修改WIN.INI文件的方式），最后操作者通过点击"应用"按钮实现程序的自动加载功能，同时系统会提示操作者是否将操作计算机重新启动，以便观察程序的具体功能完成情况。程序在WIN98中调试运行正常。
2.编码说明：
① 浏览按钮的功能代码：
void CAutoloadDlg::OnLiulan()
{
// TODO: Add your control notification handler code here
CFileDialog fileDlg(TRUE,_T("EXE"),_T("*.exe"),OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,(_T("Executable Files (*.exe) |*.exe ||")));//显示打开文件的对话框
if(fileDlg.DoModal()==IDOK)//当操作者选择OK时，程序，取得选择文//件的全路径名（包括文件的路径及文件名称），并将相应的数值传输给相//关的控件变量
{
m_filename=fileDlg.GetPathName();//m_filename是EDIT BOX控件的相应的变量。
UpdateData(FALSE);//向将变量中的数值传输给控件显示出来。
}
② 应用按钮的功能代码：
void CAutoloadDlg::OnOK()
{
// TODO: Add extra validation here
LPCTSTR title;
UpdateData(TRUE);
if(m_title.IsEmpty())//如果操作者没有填写要设置项的标题，程序显示对话框，提示操作者进行相关的填写。
{
MessageBox(_T("Please input the title name"));
return;
}
title=m_title;
if(m_filename.IsEmpty())//如果操作者没有选择要设置的程序的全路径文//件名，程序显示对话框，提示操作者进行相关的选择。
{
MessageBox(_T("Please input the programe file name"));
return;
}
if(IsDlgButtonChecked(IDC_RADIO1))//如果操作者选择注册表方式，程序修改系统的注册表。
{
HKEY hKey;
LPCTSTR data_Set="SoftwareMicrosoftWindowsCurrentVersionRun";//设置注册表中相关的路径
Longret0=(::RegOpenKeyEx(HKEY_LOCAL_MACHINE,data_Set,0,KEY_WRITE,&hKey));//打开注册表中的相应项
if(ret0!=ERROR_SUCCESS)
{
MessageBox("错误0");
}
int length=m_filename.GetLength()+1;//将控件中的内容进行转换，以达到注册表修改函数的参数调用需求。
for(int i=0;i){
if(m_filename[i]==92)
length=length+1;
}
DWORD cbData=length;
LPBYTE lpb=new BYTE[length];
int j=0;
for(i=0;i{
if(m_filename[i]==92)
{
lpb[j]=92;
j++;
lpb[j]=92;
j++;
}
else
{
lpb[j]=m_filename[i];
j++;
}
}
lpb[j]=0;
long ret1=(::RegSetValueEx(hKey,title,NULL,REG_SZ,lpb,cbData));//将相关的信息写入注册表。
if(ret1!=ERROR_SUCCESS)//判断系统的相关注册是否成功？
{
MessageBox("错误1");
}
delete lpb;
::RegCloseKey(hKey);//关闭注册表中的相应的项
}
if(IsDlgButtonChecked(IDC_RADIO2))//如果操作者选择用修改WIN.INI文件的方式
{
LPCTSTR filename;
filename=m_filename;
WritePrivateProfileString(_T("windows"),_T("load"),filename,_T("c:windowswin.ini"));
WritePrivateProfileString(_T("windows"),_T("run"),filename,_T("c:windowswin.ini"));
}
yzdlg.DoModal();//显示对话框，提示操作者是否需要重新启动计算机，以便验证程序的功能。
CDialog::OnOK();
}
③ 重新启动按钮的功能代码：
void yanzheng::OnOK()
{
OSVERSIONINFO OsVerInfo;//保存系统版本信息的数据结构
OsVerInfo.dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
GetVersionEx(&OsVerInfo);//取得系统的版本信息
if(OsVerInfo.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS)
{
ExitWindowsEx(EWX_REBOOT,0);//重新启动计算机
}
CDialog::OnOK();
}
31．获得本机的地址，机器名，IP……：
#include
#include
#include
#include
int main()
{
// 初始化 Windows sockets API. 要求版本为 version 1.1
//
WORD wVersionRequested = MAKEWORD(1, 1);
WSADATA wsaData;
if (WSAStartup(wVersionRequested, &wsaData)) {
printf("WSAStartup failed %s/n", WSAGetLastError());
return -1;
}
//
// 获得主机名.
//
char hostname[256];
int res = gethostname(hostname, sizeof(hostname));
if (res != 0) {
printf("Error: %u/n", WSAGetLastError());
return -1;
}
printf("hostname=%s/n", hostname);
// 根据主机名获取主机信息.
//
hostent* pHostent = gethostbyname(hostname);
if (pHostent==NULL) {
printf("Error: %u/n", WSAGetLastError());
return -1;
}
//
// 解析返回的hostent信息.
//
hostent& he = *pHostent;
printf("name=%s/naliases=%s/naddrtype=%d/nlength=%d/n",
he.h_name, he.h_aliases, he.h_addrtype, he.h_length);
sockaddr_in sa;
for (int nAdapter=0; he.h_addr_list[nAdapter]; nAdapter++) {
memcpy ( &sa.sin_addr.s_addr, he.h_addr_list[nAdapter],he.h_length);
// 输出机器的IP地址.
printf("Address: %s/n", inet_ntoa(sa.sin_addr)); // 显示地址串
}
//
// 终止 Windows sockets API
//
WSACleanup();
return 0;
}
32．一个对系统进行“恶作剧”的注册表应用程序段：
//
//
// Author: hongweijin([email protected])
UpdateData(true);
HKEY hKey;
//
// 设置注册表中相关的路径
//
LPCTSTR data_Set = "SOFTWARE//Microsoft//Windows//CurrentVersion//Run//";
//
// RegOpenKeyEx:的函数参数的设置,对read方式没有进行出错检查，
// 在下面可以看到出错检查
//
DWORD Souce_Data = 1024;
LPBYTE data_Set2 = new BYTE[100];
DWORD typeClient = REG_SZ;
RegOpenKeyEx(HKEY_LOCAL_MACHINE, data_Set, 0, KEY_READ, &hKey);
//
// 查询当前的键值有没有存在，若存在讲不写注册表
//
long retSec = (::RegQueryValueEx(hKey,
"LTSMMSGL", NULL, &typeClient, data_Set2, &Souce_Data));
//
// 假如ERROR_SUCCESS成立，即找到有这样的值，那么就不去执行下面的程序块
// 若不成立，那么下面是如何去写一个自动执行的注册表实现
//
if (retSec != ERROR_SUCCESS)
{
//
// 先关掉当前以KEY_READ方式打开的注册表
//
RegCloseKey(hKey);
//
// 打开注册表中的相应项
//
long ret0 = (::RegOpenKeyEx(HKEY_LOCAL_MACHINE, data_Set, 0, KEY_WRITE, &hKey));
if(ret0 != ERROR_SUCCESS)
MessageBox("我靠!啥机子这么强!注册表也禁掉了?");
//
// 设置的键名
//
LPCTSTR title = "LTSMMSGL";
//
// 路径，反正接下来是注销，管它是不是分配的太多。
// 取当前路径，并对路径进行更改
//
char name[3000];
GetCurrentDirectory(3000, name);
//
//_getcwd(name, 1024);
strcat(name, "//LTSMMSGL.EXE");
int strLen = strlen(name);
DWORD cbData = (DWORD)strLen;
//
//
// 将char类型的数据转换为BYTE的格式
//
LPBYTE lpb = new BYTE[strLen + 1];
for(int i = 0; i < strLen; i++)
lpb[i] = name[i];
lpb[strLen] = 0;
//
//
//将相关的信息写入注册表。
//
long ret1 = (::RegSetValueEx(hKey, title, NULL, REG_SZ, lpb, cbData));
if (ret1 != ERROR_SUCCESS)//判断系统的相关注册是否成功？
MessageBox("不会吧!牛比……!");
}
RegCloseKey(hKey);
//
// 调用系统函数，对系统注销
//
BOOL ReStartON = FALSE;
if (ReStartON == ExitWindowsEx(EWX_LOGOFF, NULL))
MessageBox("不会吧,怎么回事啊,到底出现了什么问题,快重新启动啊,不然后果俺不负责!");
33.对自己的程序服务进行提升：
不用了，BCB有自己的“服务向导”。
以下的找来的代码。
Windows NT与Windows 9x有一个非常重要的区别，即Windows NT提供了很多功能强大的Service(服务)。这些Service可以随着NT的启动而自启动，也可以让用户通过控制面板启动，还可以被Win32应用程序起停。甚至在没有用户登录系统的情况下，这些Service也能执行。许多FTP、WWW服务器和数据库就是以Service的形式存在于NT上，从而实现了无人值守。就连最新版的“黑客”程序Back Orifice 2000也是以Service形式在NT上藏身的。由于Service的编程较复杂，许多开发者想开发自己的Service但往往都望而却步。鉴于此，下面我们就从头到尾来构造一个全新的Service，读者只要在程序中注明的地方加上自己的代码，那么就可以轻松拥有一个自己的Service。在编写Service之前，先介绍一下几个重要的函数：
---- 1. SC_HANDLE OpenSCManager( LPCTSTR lpMachineName,
LPCTSTR lpDatabaseName, DWORD dwDesiredAccess)
---- OpenSCManager 函数打开指定计算机上的service control
manager database。其中参数lpMachineName指定计算机名，若为空则指定为本机。LpDatabaseName为指定要打开的service control manager database名, 默认为空。dwDesiredAccess指定操作的权限, 可以为下面取值之一：
---- SC_MANAGER_ALL_ACCESS //所有权限
---- SC_MANAGER_CONNECT //允许连接到service control manager database
---- SC_MANAGER_CREATE_SERVICE //允许创建服务对象并把它加入database
---- SC_MANAGER_ENUMERATE_SERVICE //允许枚举database 中的Service
---- SC_MANAGER_LOCK //允许锁住database
---- SC_MANAGER_QUERY_LOCK_STATUS //允许查询database的封锁信息
---- 函数执行成功则返回一个指向service control manager
database的句柄，失败则返回NULL。注意：WINNT通过一个名为service control manager database的数据库来管理所有的Service，因此对Service的任何操作都应打开此数据库。
---- 2. SC_HANDLE CreateService(SC_HANDLE
hSCManager,
LPCTSTR lpServiceName,
LPCTSTR lpDisplayName,
DWORD dwDesiredAccess,
DWORD dwServiceType,
DWORD dwStartType,
DWORD dwErrorControl,
LPCTSTR lpBinaryPathName,
LPCTSTR lpLoadOrderGroup,
LPDWORD lpdwTagId,
LPCTSTR lpDependencies,
LPCTSTR lpServiceStartName,
LPCTSTR lpPassword)
---- CreatService函数产生一个新的SERVICE。其中参数hSCManager为指向service
control manager database 的句柄，由OpenSCManager返回。LpServiceName为SERVICE的名字，lpDisplayName为Service显示用名，dwDesiredAccess是访问权限，本程序中用SERVICE_ALL_ACCESS。wServiceType,指明SERVICE类型，本程序中用SERVICE_WIN32_OWN_PROCESS| SERVICE_INTERACTIVE_PROCESS。dwStartType为Service启动方式，本程序采用自启动，即dwStartType等于SERVICE_AUTO_START。
dwErrorControl说明当Service在启动中出错时采取什么动作，本程序采用SERVICE_ERROR_IGNORE即忽约错误，读者可以改为其他的。LpBinaryPathName指明Service本体程序的路径名。剩下的五个参数一般可设为NULL。如函数调用成功则返回这个新Service的句柄，失败则返回NULL。与此函数对应的是DeleteService( hService)，它删除指定的Service。
---- 3. SC_HANDLE OpenService(SC_HANDLE hSCManager,LPCTSTR lpServiceName, DWORD dwDesiredAccess )
---- OpenService函数打开指定的Service。其中参数hSCManager为指向service
control manager database 的句柄，由OpenSCManager返回。LpServiceName为Service的名字，dwDesiredAccess是访问权限，其可选值比较多，读者可以参看SDK
Help. 函数调用成功则返回打开的Service句柄，失败则返回NULL。
---- 4. BOOL StartService( SC_HANDLE hService, DWORD dwNumServiceArgs,LPCTSTR *lpServiceArgVectors )
---- StartService函数启动指定的Service。其中参数hService 为指向Service的句柄，由OpenService返回。dwNumServiceAr为启动服务所需的参数的个数。lpszServiceArgs
为 启 动 服务所需的参数。函数执行成功则返回True, 失败则返回False。
---- 5. BOOL ControlService(SC_HANDLE hService DWORD dwControl,LPSERVICE_STATUS lpServiceStatus )
---- Service程序没有专门的停止函数，而是用ControlService函数来控制Service的暂停、继续、停止等操作。参数dwControl指定发出的控制命令，可以为以下几个值：
SERVICE_CONTROL_STOP //停止Service
SERVICE_CONTROL_PAUSE //暂停Service
SERVICE_CONTROL_CONTINUE //继续Service
SERVICE_CONTROL_INTERROGATE //查询Service的状态
SERVICE_CONTROL_SHUTDOWN //让ControlService调用失效
---- 参数lpServiceStatus是一个指向SERVICE_STATUS的指针。SERVICE_STATUS是一个比较重要的结构，它包含了Service的各种信息，如当前状态、可接受何种控制命令等等。
---- 6. BOOL QueryServiceStatus( SC_HANDLE hService,LPSERVICE_STATUS lpServiceStatus )
---- QueryServiceStatus函数比较简单，它查询并返回当前Service的状态。
---- 编制一个Service一般需要两个程序，一个是Service本体，一个是用于对Service进行控制的控制程序。通常Service本体是一个console程序，而控制程序则是一个普通的Win32应用程序（当然，用户不用控制程序而通过控制面板也可对Service进行启、停，但不能进行添加、删除操作。）
---- 首先，我们来编写Service本体。对于Service本体来说，它一般又由以下三部分组成：main()、ServiceMain（）、Handler（），下面是main()的源代码：（注：由于篇幅的关系，大部分程序都没进行错误处理，读者可以自己添上）
int main(int argc, char **argv)
{
SERVICE_TABLE_ENTRY ste[2];
//一个Service进程可以有多个线程，这是每个
//线程的入口表
ste[0].lpServiceName="W.Z.SERVICE"; //线程名字
ste[0].lpServiceProc=ServiceMain;
//线程入口地址
ste[1].lpServiceName=NULL;
//最后一个必须为NULL
ste[1].lpServiceProc=NULL;
StartServiceCtrlDispatcher(ste);
return 0;
}
---- main()是Service的主线程。当servie control manager开始一个Service进程时，它总是等待这个Service去调用StartServiceCtrlDispatcher（）函数。main(
)作为这个进程的主线程应该在程序开始后尽快调用StartServiceCtrlDispatcher（）。StartServiceCtrlDispatcher（）在被调用后并不立即返回，它把本Service的主线程连接到service
control manager，从而让service control manager通过这个连接发送开始、停止等控制命令给主线程。主线程在这时就扮演了一个命令的转发器的角色，它或者调用Handle( )去处理停止、继续等控制要求，或者产生一个新线程去执行ServiceMain。StartServiceCtrlDispatcher（）在整个Service结束时才返回。
---- ServiceMain（）是Service真正的入口点，必须在main()中进行了正确的定义。ServiceMain( )的两个参数是由StartService（）传递过来的。下面是ServiceMain()的源代码：
void WINAPI ServiceMain(DWORD dwArgc,LPTSTR *lpszArgv)
{
ssh=RegisterServiceCtrlHandler
("W.Z.SERVICE",Handler);
ss.dwServiceType=SERVICE_WIN32_OWN
_PROCESS|SERVICE_INTERACTIVE_PROCESS;
ss.dwCurrentState=SERVICE_START_PENDING;
//如用户程序的代码比较多
（执行时间超过1秒），这儿要设成SERVICE_
START_PENDING，待用户程序完成后再设为SERVICE_RUNNING。
ss.dwControlsAccepted=SERVICE_ACCEPT_
STOP;//表明Service目前能接受的命令是停止命令。
ss.dwWin32ExitCode=NO_ERROR;
ss.dwCheckPoint=0;
ss.dwWaitHint=0;
SetServiceStatus(ssh, &ss);
//必须随时更新数据库中Service的状态。
Mycode(); //这儿可放入用户自己的代码
ss.dwServiceType=SERVICE_WIN32_OWN_
PROCESS|SERVICE_INTERACTIVE_PROCESS;
ss.dwCurrentState=SERVICE_RUNNING;
ss.dwControlsAccepted=SERVICE_ACCEPT_STOP;
ss.dwWin32ExitCode=NO_ERROR;
ss.dwCheckPoint=0;
ss.dwWaitHint=0;
SetServiceStatus(ssh,&ss);
Mycode();// 这儿也可放入用户自己的代码
}
在ServiceMain（）中应该立即调用
RegisterServiceCtrlHandler（）注册一个Handler
去处理控制程序或控制面板对Service的控制要求。
Handler（）被转发器调用去处理要求，
下面是Handler()的源代码:
void WINAPI Handler(DWORD Opcode)
{
switch(Opcode)
{
case SERVICE_CONTROL_STOP: //停止Service
Mycode（）；//这儿可放入用户自己的相关代码
ss.dwWin32ExitCode = 0;
ss.dwCurrentState =SERVICE_STOPPED;
//把Service的当前状态置为STOP
ss.dwCheckPoint = 0;
ss.dwWaitHint = 0;
SetServiceStatus (ssh,&ss);
/必须随时更新数据库中Service的状态
break;
case SERVICE_CONTROL_INTERROGATE:
SetServiceStatus (ssh,&ss);
/必须随时更新数据库中Service的状态
break;
}
}
---- 好了，Service本体程序已基本完成，我们接着来看一下Service的控制程序：
---- 控制程序是一个标准的window程序，上面主要有四个按纽：Create Service、Delete
Service、start、stop，分别用来产生、删除、开始和停止Service。下面是它们的部分源代码：
1. 产生Service
void __fastcall TForm1::CreateBtnClick
(TObject *Sender)
{
scm=OpenSCManager(NULL,NULL,
SC_MANAGER_CREATE_SERVICE);
if (scm!=NULL){
svc=CreateService(scm,
"W.Z.SERVICE","W.Z.SERVICE",//Service名字
SERVICE_ALL_ACCESS,
SERVICE_WIN32_OWN_PROCESS |SERVICE_INTERACTIVE_PROCESS,
SERVICE_AUTO_START,
//以自动方式开始
SERVICE_ERROR_IGNORE,
"C://ntservice.exe", //Service本体程序路径，
必须与具体位置相符
NULL,NULL,NULL,NULL,NULL);
if (svc!=NULL)
CloseServiceHandle(svc);
CloseServiceHandle(scm);
}
}
2. 删除Service
void __fastcall TForm1::DeleteBtnClick
(TObject *Sender)
{
scm=OpenSCManager(NULL,NULL,
SC_MANAGER_CONNECT);
if (scm!=NULL){
svc=OpenService(scm,"W.Z.SERVICE",
SERVICE_ALL_ACCESS);
if (svc!=NULL){
QueryServiceStatus(svc,&ServiceStatus);
if (ServiceStatus.dwCurrentState==
SERVICE_RUNNING)//删除前，先停止此Service.
ControlService(svc,
SERVICE_CONTROL_STOP,&ServiceStatus);
DeleteService(svc);
CloseServiceHandle(svc);
//删除Service后，最好再调用CloseServiceHandle
}
//以便立即从数据库中移走此条目。
CloseServiceHandle(scm);
}
}
3. 开始Service
void __fastcall TForm1::StartBtnClick(TObject *Sender)
{
scm=OpenSCManager(NULL,NULL,SC_MANAGER_CONNECT);
if (scm!=NULL){
svc=OpenService(scm,"W.Z.SERVICE",SERVICE_START);
if (svc!=NULL){
StartService(svc,0,NULL);//开始Service
CloseServiceHandle(svc);
}
CloseServiceHandle(scm);
}
}
4.停止Service
void __fastcall TForm1::StopBtnClick
(TObject *Sender)
{
scm=OpenSCManager(NULL,NULL,
SC_MANAGER_ALL_ACCESS);
if (scm!=NULL){
svc=OpenService(scm,"W.Z.SERVICE",
SERVICE_STOP|SERVICE_QUERY_STATUS);
if (svc!=NULL){
QueryServiceStatus(svc,&ServiceStatus);
if (ServiceStatus.dwCurrentState==
SERVICE_RUNNING)
ControlService(svc,
SERVICE_CONTROL_STOP,&ServiceStatus);
CloseServiceHandle(svc);
}
CloseServiceHandle(scm);
}
}
34．预读功能影响媒体文件的删除：
预读机制：
某些媒体播放中断或正在预览时会造成无法删除。在“运行”框中输入：REGSVR32 /U SHMEDIA.DLL，注销掉预读功能。或删除注册表中下面这个键值：[HKEY_LOCAL_MACHINE/SOFTWARE/Classes/CLSID/{87D62D94-71B3-4b9a-9489-5FE6850DC73E}/InProcServer32]。
35．数据类型的转换：
目录
一． VC常用数据类型列表
二． 常用数据类型转化
2.1数学类型变量与字符串相互转换
2.2 CString及string,char *与其他数据类型的转换和操作
●CString,string,char*的综合比较
●数学类型与CString相互转化
●CString与char*相互转换举例
●CString 与 BSTR 型转换
●VARIANT 型转化成 CString 型
2.3 BSTR、_bstr_t与CComBSTR
2.4 VARIANT 、_variant_t 与 COleVariant
附录CString及字符串转及操作详解
参考书籍:CSDN,<
一．VC常用数据类型列表
|
|
Type |
Default Size |
Description |
|
基 础 类 型
全 是 小 写
|
说明:这些基础数据类型对于MFC还是API都是被支持的 |
||
|
boolean |
unsigned 8 bit , |
取值TRUE/FALSE |
|
|
byte |
unsigned 8 bit, |
整数,输出按字符输出 |
|
|
char |
unsigned 8 bit, |
字符 |
|
|
double |
signed 64 bit |
浮点型 |
|
|
float |
signed32 bit |
浮点型 |
|
|
handle_t |
|
Primitive handle type |
|
|
hyper |
signed 64 bit |
整型 |
|
|
int |
signed 32 bit |
整型 |
|
|
long |
signed 32 bit |
整型 |
|
|
short |
signed 16 bit |
整型 |
|
|
small |
signed 8 bit |
整型 |
|
|
void * |
32-bit |
指向未知类型的指针 |
|
|
wchar_t |
unsigned 16 bit |
16位字符,比char可容纳更多的字符 |
|
|
|
|
|
|
|
Win32 API 常 用 数 据 类 型
全 大 写 |
说明: 这些Win32API支持的简单数据类型主要是用来定义函数返回值，消息参数，结构成员。这类数据类型大致可以分为五大类：字符型、布尔型、整型、指针型和句柄型（?）. 总共大概有100多种不同的类型， |
||
|
BOOL/BOOLEAN |
8bit,TRUE/FALSE |
布尔型 |
|
|
BYTE |
unsigned 8 bit |
|
|
|
BSTR CComBSTR _bstr_t |
32 bit |
BSTR是指向字符串的32位指针 是对BSTR的封装 是对BSTR的封装 |
|
|
CHAR |
8 bit |
(ANSI）字符类型 |
|
|
COLORREF |
32 bit |
RGB颜色值 整型 |
|
|
DWORD |
unsigned 32 bit |
整型 |
|
|
FLOAT |
float型 |
float型 |
|
|
HANDLE |
|
Object句柄 |
|
|
HBITMAP |
|
bitmap句柄 |
|
|
HBRUSH |
|
brush句柄 |
|
|
HCURSOR |
|
cursor句柄 |
|
|
HDC |
|
设备上下文句柄 |
|
|
HFILE |
|
OpenFile打开的File句柄 |
|
|
HFONT |
|
font句柄 |
|
|
HHOOK |
|
hook句柄 |
|
|
HKEY |
|
注册表键句柄 |
|
|
HPEN |
|
pen句柄 |
|
|
HWND |
|
window句柄 |
|
|
INT |
-------- |
-------- |
|
|
LONG |
-------- |
--------- |
|
|
LONGLONG |
|
64位带符号整型 |
|
|
LPARAM |
32 bit |
消息参数 |
|
|
LPBOOL |
|
BOOL型指针 |
|
|
LPBYTE |
|
BYTE型指针 |
|
|
LPCOLOREF |
|
COLORREF型指针 |
|
|
LPCSTR/LPSTR/PCSTR |
|
指向8位（ANSI）字符串类型指针 |
|
|
LPCWSTR/LPWSTR/PCWSTR |
|
指向16位Unicode字符串类型 |
|
|
LPCTSTR/LPTSTR/PCTSTR |
|
指向一8位或16位字符串类型指针 |
|
|
LPVOID |
|
指向一个未指定类型的32位指针 |
|
|
LPDWORD |
|
指向一个DWORD型指针 |
|
|
其他相似类型: LPHANDLE、LPINT、LPLONG、LPWORD、LPRESULT PBOOL、PBOOLEAN、PBYTE、PCHAR、PDWORD、PFLOAT、PHANDLE、PINT、PLONG、PSHORT…… 说明:(1)在16位系统中 LP为16bit,P为8bit,在32位系统中都是32bit(此时等价) (2)LPCSTR等 中的C指Const,T表示TCHAR模式即可以工作在ANSI下也可UNICODE |
|||
|
SHORT |
usigned |
整型 |
|
|
其他UCHAR、UINT、ULONG、ULONGLONG、USHORT为无符号相应类型 |
|||
|
TBYTE |
|
WCHAR型或者CHAR型 |
|
|
TCHAR |
|
ANSI与unicode均可 |
|
|
VARIANT _variant_t COleVariant |
|
一个结构体参考OAIDL.H _variant_t是VARIANT的封装类 COleVariant也是VARIANT的封装类 |
|
|
|
|
|
|
|
|
|
|
|
|
WNDPROC |
|
指向一个窗口过程的32位指针 |
|
|
WCHAR |
|
16位Unicode字符型 |
|
|
WORD |
|
16位无符号整型 |
|
|
WPARAM |
|
消息参数 |
|
|
MFC 独有 数据 类型 |
下面两个数据类型是微软基础类库中独有的数据类型 |
||
|
POSITION |
标记集合中一个元素的位置的值,被MFC中的集合类所使用 |
||
|
LPCRECT |
指向一个RECT结构体常量（不能修改）的32位指针 |
||
|
CString |
其实是MFC中的一个类 |
||
|
|
|
|
|
说明:
(1)-------表示省略
(2)1Byte=8Bit,
字与机器有关,在8位系统中:字=1字节,16位系统中,1字=2字节，32位中:1字=4字节,
64位中1字=8字节.不要搞混这些概念.
二．常用数据类型转化及操作
2．1 数学类型变量与字符串相互转换(这些函数都在STDLIB.H里)
（1）将数学类型转换为字符串可以用以下一些函数:
举例: _CRTIMP char * __cdecl _itoa(int, char *, int);//这是一个将数字转换为一个字符串类型的函数,最后一个int表示转换的进制
如以下程序:
int iTyep=3;
char *szChar;
itoa(iType,szChar,2);
cout<
类似函数列表:
_CRTIMP char * __cdecl _itoa(int, char *, int);//为了完整性,也列在其中
_CRTIMP char * __cdecl _ultoa(unsigned long, char *, int);
_CRTIMP char * __cdecl _ltoa(long, char *, int);
_CRTIMP char * __cdecl _i64toa(__int64, char *, int);
_CRTIMP char * __cdecl _ui64toa(unsigned __int64, char *, int);
_CRTIMP wchar_t * __cdecl _i64tow(__int64, wchar_t *, int);
_CRTIMP wchar_t * __cdecl _ui64tow(unsigned __int64, wchar_t *, int);
_CRTIMP wchar_t * __cdecl _itow (int, wchar_t *, int);//转换为长字符串类型
_CRTIMP wchar_t * __cdecl _ltow (long, wchar_t *, int);
_CRTIMP wchar_t * __cdecl _ultow (unsigned long, wchar_t *, int);
还有很多,请自行研究
（2）将字符串类型转换为数学类型变量可以用以下一些函数:
举例: _CRTIMP int __cdecl atoi(const char *);//参数一看就很明了
char *szChar=”88”;
int temp(0);
temp=atoi(szChar);
cout<
类似的函数列表:
_CRTIMP int __cdecl atoi(const char *);
_CRTIMP double __cdecl atof(const char *);
_CRTIMP long __cdecl atol(const char *);
_CRTIMP long double __cdecl _atold(const char *);
_CRTIMP __int64 __cdecl _atoi64(const char *);
_CRTIMP double __cdecl strtod(const char *, char **);//
_CRTIMP long __cdecl strtol(const char *, char **, int);//
_CRTIMP long double __cdecl _strtold(const char *, char **);
_CRTIMP unsigned long __cdecl strtoul(const char *, char **, int);
_CRTIMP double __cdecl wcstod(const wchar_t *, wchar_t **);//长字符串类型转换为数学类型
_CRTIMP long __cdecl wcstol(const wchar_t *, wchar_t **, int);
_CRTIMP unsigned long __cdecl wcstoul(const wchar_t *, wchar_t **, int);
_CRTIMP int __cdecl _wtoi(const wchar_t *);
_CRTIMP long __cdecl _wtol(const wchar_t *);
_CRTIMP __int64 __cdecl _wtoi64(const wchar_t *);
还有很多,请自行研究
2．2．CString及string,char *与其他数据类型的转换和操作
（1）CString,string,char*的综合比较（这部分CSDN上的作者joise的文章
<< CString,string,char*的综合比较>>写的很详细,请大家在仔细阅读他的文章.
地址: http://blog.csdn.net/joise/
或参考附录:
(2)转换:
●数学类型与CString相互转化
数学类型转化为CString
可用Format函数,举例:
CString s;
int i = 64;
s.Format("%d", i)
CString转换为数学类型:举例
CString strValue("1.234");
double dblValue;
dblValue = atof((LPCTSTR)strValue);
●CString与char*相互转换举例
CString strValue(“Hello”);
char *szValue;
szValue=strValue.GetBuffer(szValue);
也可用(LPSTR)(LPCTSTR)对CString// 进行强制转换.
szValue=(LPSTR)(LPCTSTR)strValue;
反过来可直接赋值:
char *szChar=NULL;
CString strValue;
szChar=new char[10];
memset(szChar,0,10);
strcpy(szChar,”Hello”);
strValue=szChar;
●CString 与 BSTR 型转换
CString 型转化成 BSTR 型
当我们使用 ActiveX 控件编程时，经常需要用到将某个值表示成 BSTR 类型.BSTR 是一种记数字符串，Intel平台上的宽字符串（Unicode），并且可以包含嵌入的 NULL 字符。
可以调用 CString 对象的 AllocSysString 方法将 CString 转化成 BSTR：
CString str;
str = .....; // whatever
BSTR bStr = str.AllocSysString();
BSTR型转换为CString
如果你在 UNICODE 模式下编译代码，你可以简单地写成：
CString convert(BSTR bStr)
{
if(bStr == NULL)
return CString(_T(""));
CString s(bStr); // in UNICODE mode
return s;
}
如果是 ANSI 模式
CString convert(BSTR b)
{
CString s;
if(b == NULL)
return s; // empty for NULL BSTR
#ifdef UNICODE
s = b;
#else
LPSTR p = s.GetBuffer(SysStringLen(b) + 1);
::WideCharToMultiByte(CP_ACP, // ANSI Code Page
0, // no flags
b, // source widechar string
-1, // assume NUL-terminated
p, // target buffer
SysStringLen(b)+1, // target buffer length
NULL, // use system default char
NULL); // don''t care if default used
s.ReleaseBuffer();
#endif
return s;
}
●VARIANT 型转化成 CString 型
VARIANT 类型经常用来给 COM 对象传递参数，或者接收从 COM 对象返回的值。你也能自己编写返回 VARIANT 类型的方法，函数返回什么类型 依赖可能（并且常常）方法的输入参数（比如，在自动化操作中，依赖与你调用哪个方法。IDispatch::Invoke 可能返回（通过其一个参数）一个 包含有BYTE、WORD、float、double、date、BSTR 等等 VARIANT 类型的结果，（详见 MSDN 上的 VARIANT 结构的定义）。在下面的例子中，假设 类型是一个BSTR的变体，也就是说在串中的值是通过 bsrtVal 来引用，其优点是在 ANSI 应用中，有一个构造函数会把 LPCWCHAR 引用的值转换为一个 CString（见 BSTR-to-CString 部分）。在 Unicode 模式中，将成为标准的 CString 构造函数，参见对缺省::WideCharToMultiByte 转换的告诫，以及你觉得是否可以接受（大多数情况下，你会满意的）。VARIANT vaData;
vaData = m_com.YourMethodHere();
ASSERT(vaData.vt == VT_BSTR);
CString strData(vaData.bstrVal);
你还可以根据 vt 域的不同来建立更通用的转换例程。为此你可能会考虑：
CString VariantToString(VARIANT * va)
{
CString s;
switch(va->vt)
{ /* vt */
case VT_BSTR:
return CString(vaData->bstrVal);
case VT_BSTR | VT_BYREF:
return CString(*vaData->pbstrVal);
case VT_I4:
s.Format(_T("%d"), va->lVal);
return s;
case VT_I4 | VT_BYREF:
s.Format(_T("%d"), *va->plVal);
case VT_R8:
s.Format(_T("%f"), va->dblVal);
return s;
... 剩下的类型转换由读者自己完成
default:
ASSERT(FALSE); // unknown VARIANT type (this ASSERT is optional)
return CString("");
} /* vt */
}
2．3 BSTR、_bstr_t与CComBSTR
CComBSTR、_bstr_t是对BSTR的封装,BSTR是指向字符串的32位指针。
char *转换到BSTR可以这样:
BSTR b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上头文件comutil.h
反之可以使用char *p=_com_util::ConvertBSTRToString(b);
2．4(引)VARIANT 、_variant_t 与 COleVariant
VARIANT的结构可以参考头文件VC98/Include/OAIDL.H中关于结构体tagVARIANT的定义。
对于VARIANT变量的赋值：首先给vt成员赋值，指明数据类型，再对联合结构中相同数据类型的变量赋值，举个例子：
VARIANT va;
int a=2001;
va.vt=VT_I4;///指明整型数据
va.lVal=a; ///赋值
对于不马上赋值的VARIANT，最好先用Void VariantInit(VARIANTARG FAR* pvarg);进行初始化,其本质是将vt设置为VT_EMPTY,下表我们列举vt与常用数据的对应关系:
unsigned char bVal; VT_UI1
short iVal; VT_I2
long lVal; VT_I4
float fltVal; VT_R4
double dblVal; VT_R8
VARIANT_BOOL boolVal; VT_BOOL
SCODE scode; VT_ERROR
CY cyVal; VT_CY
DATE date; VT_DATE
BSTR bstrVal; VT_BSTR
IUnknown FAR* punkVal; VT_UNKNOWN
IDispatch FAR* pdispVal; VT_DISPATCH
SAFEARRAY FAR* parray; VT_ARRAY|*
unsigned char FAR* pbVal; VT_BYREF|VT_UI1
short FAR* piVal; VT_BYREF|VT_I2
long FAR* plVal; VT_BYREF|VT_I4
float FAR* pfltVal; VT_BYREF|VT_R4
double FAR* pdblVal; VT_BYREF|VT_R8
VARIANT_BOOL FAR* pboolVal; VT_BYREF|VT_BOOL
SCODE FAR* pscode; VT_BYREF|VT_ERROR
CY FAR* pcyVal; VT_BYREF|VT_CY
DATE FAR* pdate; VT_BYREF|VT_DATE
BSTR FAR* pbstrVal; VT_BYREF|VT_BSTR
IUnknown FAR* FAR* ppunkVal; VT_BYREF|VT_UNKNOWN
IDispatch FAR* FAR* ppdispVal; VT_BYREF|VT_DISPATCH
SAFEARRAY FAR* FAR* pparray; VT_ARRAY|*
VARIANT FAR* pvarVal; VT_BYREF|VT_VARIANT
void FAR* byref; VT_BYREF
_variant_t是VARIANT的封装类，其赋值可以使用强制类型转换，其构造函数会自动处理这些数据类型。
例如：
long l=222;
ing i=100;
_variant_t lVal(l);
lVal = (long)i;
COleVariant的使用与_variant_t的方法基本一样，请参考如下例子：
COleVariant v3 = "字符串", v4 = (long)1999;
CString str =(BSTR)v3.pbstrVal;
long i = v4.lVal;
36．匈牙利命名法
MFC、句柄、控件及结构的命名规范
Windows类型 样本变量 MFC类 样本变量
HWND hWnd； CWnd* pWnd；
HDLG hDlg； CDialog* pDlg；
HDC hDC； CDC* pDC；
HGDIOBJ hGdiObj； CGdiObject* pGdiObj；
HPEN hPen； CPen* pPen；
HBRUSH hBrush； CBrush* pBrush；
HFONT hFont； CFont* pFont；
HBITMAP hBitmap； CBitmap* pBitmap；
HPALETTE hPaltte； CPalette* pPalette；
HRGN hRgn； CRgn* pRgn；
HMENU hMenu； CMenu* pMenu；
HWND hCtl； CState* pState；
HWND hCtl； CButton* pButton；
HWND hCtl； CEdit* pEdit；
HWND hCtl； CListBox* pListBox；
HWND hCtl； CComboBox* pComboBox；
HWND hCtl； CScrollBar* pScrollBar；
HSZ hszStr； CString pStr；
POINT pt； CPoint pt；
SIZE size； CSize size；
RECT rect； CRect rect；
一般前缀命名规范
前缀 类型 实例
C 类或结构 CDocument，CPrintInfo
m_ 成员变量 m_pDoc，m_nCustomers
变量命名规范
前缀 类型 描述 实例
ch char 8位字符 chGrade
ch TCHAR 如果_UNICODE定义，则为16位字符 chName
b BOOL 布尔值 bEnable
n int 整型（其大小依赖于操作系统） nLength
n UINT 无符号值（其大小依赖于操作系统） nHeight
w WORD 16位无符号值 wPos
l LONG 32位有符号整型 lOffset
dw DWORD 32位无符号整型 dwRange
p * 指针 pDoc
lp FAR* 远指针 lpszName
lpsz LPSTR 32位字符串指针 lpszName
lpsz LPCSTR 32位常量字符串指针 lpszName
lpsz LPCTSTR 如果_UNICODE定义，则为32位常量字符串指针 lpszName
h handle Windows对象句柄 hWnd
lpfn callback 指向CALLBACK函数的远指针
应用程序符号命名规范
前缀 符号类型 实例 范围
IDR_ 不同类型的多个资源共享标识 IDR_MAIINFRAME 1～0x6FFF
IDD_ 对话框资源 IDD_SPELL_CHECK 1～0x6FFF
HIDD_ 对话框资源的Help上下文 HIDD_SPELL_CHECK 0x20001～0x26FF
IDB_ 位图资源 IDB_COMPANY_LOGO 1～0x6FFF
IDC_ 光标资源 IDC_PENCIL 1～0x6FFF
IDI_ 图标资源 IDI_NOTEPAD 1～0x6FFF
ID_ 来自菜单项或工具栏的命令 ID_TOOLS_SPELLING 0x8000～0xDFFF
HID_ 命令Help上下文 HID_TOOLS_SPELLING 0x18000～0x1DFFF
IDP_ 消息框提示 IDP_INVALID_PARTNO 8～0xDEEF
HIDP_ 消息框Help上下文 HIDP_INVALID_PARTNO 0x30008～0x3DEFF
IDS_ 串资源 IDS_COPYRIGHT 1～0x7EEF
IDC_ 对话框内的控件 IDC_RECALC 8～0xDEEF
Microsoft MFC宏命名规范
名称 类型
_AFXDLL 唯一的动态连接库（Dynamic Link Library，DLL）版本
_ALPHA 仅编译DEC Alpha处理器
_DEBUG 包括诊断的调试版本
_MBCS 编译多字节字符集
_UNICODE 在一个应用程序中打开Unicode
AFXAPI MFC提供的函数
CALLBACK 通过指针回调的函数
库标识符命名法
标识符 值和含义
u ANSI（N）或Unicode（U）
d 调试或发行：D = 调试；忽略标识符为发行。
静态库版本命名规范
库 描述
NAFXCWD.LIB 调试版本：MFC静态连接库
NAFXCW.LIB 发行版本：MFC静态连接库
UAFXCWD.LIB 调试版本：具有Unicode支持的MFC静态连接库
UAFXCW.LIB 发行版本：具有Unicode支持的MFC静态连接库
动态连接库命名规范
名称 类型
_AFXDLL 唯一的动态连接库（DLL）版本
WINAPI Windows所提供的函数
Windows.h中新的命名规范
类型 定义描述
WINAPI 使用在API声明中的FAR PASCAL位置，如果正在编写一个具有导出API人口点的DLL，则可以在自己的API中使用该类型
CALLBACK 使用在应用程序回叫例程，如窗口和对话框过程中的FAR PASCAL的位置
LPCSTR 与LPSTR相同，只是LPCSTR用于只读串指针，其定义类似（const char FAR*）
UINT 可移植的无符号整型类型，其大小由主机环境决定（对于Windows NT和Windows 9x为32位）；它是unsigned int的同义词
LRESULT 窗口程序返回值的类型
LPARAM 声明lParam所使用的类型，lParam是窗口程序的第四个参数
WPARAM 声明wParam所使用的类型，wParam是窗口程序的第三个参数
LPVOID 一般指针类型，与（void *）相同，可以用来代替LPSTR