数学建模社区-数学中国

标题: [转帖]经典BCB源码1 [打印本页]

作者: ilikenba 时间: 2004-9-24 21:39
标题: [转帖]经典BCB源码1
1.怎样在C＋＋Builder中创建使用DLL
2.用C++Bulider在WIN.INI中保存信息
3.如何在C＋＋Builder中检测硬件
4.C++Builder如何响应消息及自定义消息
5.利用C++ Builder开发动画DLL
6.用C++ Builder 3制作屏幕保护程序
7.TCP/IP头格式
8.UDP
9.判断windows的Desktop及其它目录
10用C++Builder创建数字签名
11用Enter 键控制焦点切换的方法
12.拦截 Windows 消息
13.使用CommaText
14.程序开始时先显示信息框
15.怎样获取程序的命令行参数？
16.如何监视剪贴板
17.如何使用OnIdle事件
18.用C++Builder编写串行异步通信程序
19.C＋＋BUILDER非可视组件的消息处理技巧
20.用C＋＋Builder 建立数据库VCL使用经验
21.用C++ Builder创建基于Internet的点对点Chat
22.用C++Builder获取应用程序图标
23.BIG5到GB的转换技术
24.C++BUILDER让你的任务栏图标动起来
25.TFORM
26.用BCB在windows桌面创建快捷方式
27.读磁片磁区
28.I/O 端口读写的实现
29.检测鼠标位置
30.令Win32 应用程序跳入系统零层
31.如何取得Memo的行和列
32.使用Sockets
33.Windows95/98下怎样隐藏应用程序不让它出现在CTRL-ALT-DEL对话框中？
34.怎样隐藏应用程序的任务条图标
35.编写自己的Ping.exe程序
36.用C++Builder在WINNT下编制一个Service
37.如何在C++ BUILDER中自动关闭WINDOWS屏保
38.显示/隐藏任务栏图标
39.信箱监视程序
40.C++Building制作闹钟
41.拨号上网IP地址的检知
42.用C++ Builder编写Tray程序
43.怎样用代码来最小化或恢复程序
44.制作主窗口显示前的版权窗口
45.判断是否已经联到 internet
46.获取登陆用户名
47.隐藏桌面图标
48.程序启动时运行
49.控制面板的调用
50.模拟键盘按键
51.让标题栏闪烁
52.启动屏幕保护
53.年月日星期的取法
54.键盘事件
55.隐藏任务栏
56.禁止关机
57.怎样以最小化方式启动程序
58.在Memo中增加一行后，如何使最后一行能显示
59.设置壁纸方法
怎样在C＋＋Builder中创建使用DLL
　　自从C＋＋Builder从去年浪漫情人节上市以来，吸引了大量的Delphi、VC、Vb的程序员到它的怀抱,大量的C、C＋＋程序员感叹道：总算有了C的可视化开发工具，对我也是一样，从BC、Delphi到C＋＋Builder。
　　动态链接库(DLL)是Windows编程常遇到的编程方法，下面我就介绍一下在BCB (C＋＋Builder下简称BCB) 中如何创建使用DLL和一些技巧。
　　一、创建:
　　使用BCB File|NEW建立一个新的DLL工程，并保存好文件BCB，生成一个DLL的程序框架。
　　1．DllEntryPoint函数为一个入口方法，如果使用者在DLL被系统初始化或者注销时被调用，用来写入对DLL的初始化程序和卸载程序；参数：hinst用来指示DLL的基地址；reason用来指示DLL的调用方式，用于区别多线程单线程对DLL的调用、创建、卸载DLL；
　　2．在程序中加入自己所要创建的DLL过程、函数；
　　3．用dllimport描述出口；
　　例程序如下：
＃include
＃pragma hdrstop
extern 揅?__declspec(dllexport) int test();
int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void＊)
{
return 1;
}
int test()
{
return 3;
}
　　注意：动态链接库中调用过程、函数时有不同的CALL方式 __cdecl、 __pascal, __fastcall、__stdcall，BCB中默认的方式为__cdecl(可不写)，如果考虑兼容性可用时__stdcall声明方法为：
extern 揅?__declspec(dllexport) int __stdcall test();
　　对于其中过程、函数也改为：
int __stdcall test()
　　二、使用DLL
　　在BCB中使用DLL有两种方法：
　　1．用静态调用法
　　首先需要在BCB的项目中加入输入接口库(import library)，打开工程项目，使用BCB View|Project Manager打开项目列表，向项目中加入接口库(＊.lib)。
　　其次在头文件中加入接口声明。
　　例程序如下：
//define in include file
extern 揅?__declspec(dllimport) int __cdecl test();
//use function in main program
int I；
I=test();
注意：
(1)动态链接库调用过程、函数时CALL方式与创建时方式一样不写为__cdecl，其它需要声明。
(2)BCB创建的DLL有对应的输入接口库(import library)，如只有DLL而无库时，可用BCB的implib工具产生：implib xxx.lib xxx.dll；另外可用：tlib xxx.lib,xxx.lst 产生DLL的内部函数列表，许多Windows的未公开技术就是用这种方法发现的。
　　2．动态调用法
　　动态调用法要用Windows API 中的LoadLibrary()和GetProcAddress()来调入DLL库，指出库中函数位置，这种方法较常见。
　　例程序如下：
HINSTANCE dd;
int _stdcall (＊ddd)(void);
dd=LoadLibrary(搙xx.dll?;
ddd=GetProcAddress(dd,搕est?;
Caption=IntToStr(ddd());
FreeLibrary(dd);
　　三、注意：
创建DLL时编译链接时注意设置Project Options。
Packages标签：去除Builder with runtime packages检查框。
Linker标签：去除Use dynamic RTL检查框。
否则创建的DLL需要Runtime packages or Runtime library。

用C++Bulider在WIN.INI中保存信息
　　现在许多软件把程序中需要的数据保存在注册表中，这样当用户装的软件越来越多时，致使注册表越来越庞大，容易使系统出错。当然，微软也建议在注册表中保存数据，但当我们需要保存的数据不多时完全可以把数据保存在WIN.INI中，这样可以很方便地维护，实现方法相对来说比较简单。下面我以Borland C＋＋ Builder为例来说说如何实现。
　　原理其实很简单，只需调用API的 WriteProfileString和GetProfileInt函数就可以了。这两个函数的原型是：BOOL WriteProfileString(LPCTSTR lpAppName,LPCTSTR lpKeyName,LPCTSTR lpString );
　　UINT GetProfileInt(LPCTSTR lpAppName,LPCTSTR lpKeyName,INT nDefault);
　　其中lpAppName指在WIN.INI中段的名字，即用[]括起来的字符串，lpKeyName指在这个段中每一个项目的名字，lpString指这个项目的值，即“=”后的数, nDefault为当GetProfileInt没有找到lpAppName和lpKeyName时返回的值，即缺省值,前者返回为布尔值(true 或 false)，后者返回为无符号整形值。当在WriteProfileString函数中 lpKeyName 为空(NULL)时，则清除这个段的全部内容，lpString 为空时，则清除这一项目的内容，即这一行将清除掉。
　　下面举一例子来说明这两个函数的用法。新建一个应用程序，在Form1上放两个Edit和三个Button，其中Edit的Text为空，三个Button的Caption分别为“添加”、“查看”、“清除”。双击“添加”按钮加入下面代码：
WriteProfileString(“例子程序”，“项目”，Edit1→Text.c_str());
　　双击“查看”按钮加入如下代码：
unsigned int Temp;
Temp=GetProfileInt(“例子程序”，“项目”，100);
Edit2→Text=IntToStr(Temp);
　　双击“清除”按钮加入如下代码：
WriteProfileString(“例子程序”，NULL，NULL)；
　　然后按F9键运行程序。
　　下来可以检验一下程序的正确性。在Edit1中输入数字，如“3265”，按“添加”按钮，这时运行“sysedit”来查看“WIN.INI”文件的最后面，可以看到加入了如下内容：
　　[例子程序]
　　项目=3265
　　其中“[]”和“=”是函数自动加上的。按下“查看”按钮，在Edit2中出现“3265”，当按下“清除”按钮可清除添加的部分。经过查看可知程序已达到预期的目的。
　　喜爱编程的朋友可以把上述方法应用到自己的程序中去，来达到保存数据信息的作用。当确实要把信息保存到注册表中，可以在C＋＋ Builder中定义一个TRegistry类的对象来进行相关的操作，或者直接调用Windows的API函数，具体如何编程大家可以参阅相关资料或者同我联系。

如何在C＋＋Builder中检测硬件
　　在我们编写的程序中常常要和硬件打交道,那么如何在程序中确定系统中是否有该设备,它的运行状态又是怎样的呢？对于初学者来说，这个问题常常不好解决，其实只需简单地利用几个API函数，硬件的问题并不神秘。下面就让我们一起看看在C＋＋ Builder中是如何检测硬件的。
　　1. 检测CPU的型号
　　先让我们从最简单的做起，看一看自己的CPU型号。首先，在C＋＋ Builder中画出图1所示的窗体，在下面的几个例子中我们将一直使用这个窗体作示范，它包括一个用来激活测试的Button和一个用来显示结果的Memo。我们可以用GetSystemInfo这个API获得CPU的型号。将下列代码添加到Button的Click事件里就可以了：
void __fastcall TForm1::Button1Click(TObject ＊Sender)
{
//获得CPU型号
SYSTEM_INFO systeminfo;
GetSystemInfo (＆systeminfo);
Memo1→Lines→Add(撃?腃PU类型是:敚玈tring( systeminfo.dwProcessorType ));
}
运行它，点击Test试试，CPU型号出来了吧！
　　2.检测内存状态
　　获得内存状态的方法和CPU型号差不多，只是他用到的是另外一个API：GlobalMemoryStatus。
　　其中，成员dwTotalPhys用来获得物理内存总量，而dwAvailPhys顾名思义是有效物理内存的意思。我们只要把下面几行代码加到上面程序的后面就可以了（不用重做，下同）：
//获得内存状态
MEMORYSTATUS memory;
memory.dwLength =sizeof(memory); //初始化
GlobalMemoryStatus(＆memory);
Memo1→Lines→Add(撃?奈锢砟诖媸?Mb):敚玈tring(int(memory.dwTotalPhys /1024/1024)));
Memo1→Lines→Add(撈渲锌捎媚诖媸?Kb):敚玈tring(int( memory. /1024)));
　　怎么样，看出点门道了么？两段程序的格式几乎一模一样，其实，GetSystemInfoGlobalMemoryStatus还可以获得许多其他有关CPU和内存的信息，就按照上面的格式去套就行了，更详细的资料可以去看C＋＋ Builder4的Help。
　　3. 检测可用硬盘空间
好了，经过前面两个简单问题的热身，我们来处理一个稍微复杂的问题：我们知道安装程序大都有一个检测硬盘空间的过程，那么这是怎么实现的呢?他用到的是API函数GetDiskFreeSpace，这个函数输入一个参数：目标盘的路径；返回四个参数，依次是每簇的扇区数、每扇区的字节数、空闲的簇数、总簇数。假如我们需要检测C盘的总容量和可用容量，那么可以把以下代码加到上面的程序中：
//获得C盘可用空间
DWORD sector,byte,cluster,free;
long int freespace,totalspace;
GetDiskFreeSpace(揅:?＆sector,＆byte,＆free,＆cluster); //获得返回参数
totalspace=int(cluster)＊int(byte)＊int(sector)/1024/1024; //计算总容量
freespace=int(free)＊int(byte)＊int(sector)/1024/1024; //计算可用空间
Memo1→Lines→Add(揅盘总空间(Mb):敚玈tring(totalspace));
Memo1→Lines→Add(揅盘可用空间(Mb):敚玈tring(freespace));
怎么样?现在可以自己做安装程序了吧！

C++Builder如何响应消息及自定义消息
　　Inprise(Borland) C++Builder中，可以象在Delphi中一样响应消息，只是看起来要稍复杂一点。
　　对于系统已定义的消息，可以直接响应：
#define WM_MY_OPEN_CMDLINE_FILE (WM_USER+1) //进程间通讯的自定义消息
#define WM_MY_SEARCH_NODE (WM_USER+2) //查找命令的自定义消息
class TSomeForm : public TForm
{
//...类中的其它代码
protected:
//消息的响应过程
void __fastcall OpenCmdLineFile(TMessage Message);
void __fastcall SearchDocumentNode(TMessage Message);
void __fastcall GetWindowMinMaxInfo(TWMGetMinMaxInfo Message);
//以下通过宏定义实现消息的正确响应
BEGIN_MESSAGE_MAP
MESSAGE_HANDLER(WM_MY_OPEN_CMDLINE_FILE, TMessage, OpenCmdLineFile)
MESSAGE_HANDLER(WM_MY_SEARCH_NODE, TMessage, SearchDocumentNode)
MESSAGE_HANDLER(WM_GETMINMAXINFO , TWMGetMinMaxInfo, GetWindowMinMaxIn fo)
END_MESSAGE_MAP(TForm)
};//end class
//以下为实现代码
void __fastcall TSomeForm::OpenCmdLineFile(TMessage Message)
{//直接通过消息结构传递参数
LPSTR lpCmdLine=(LPSTR)Message.LParam;//从Message中取得参数
this->HandleCmdLineFile(lpCmdLine);//处理命令行的参数
return;
}
void __fastcall TSomeForm::SearchDocumentNode(TMessage Message)
{//响应查找消息
//Message中的参数在此处不需要。
this->SearchNode();
return;
}
void __fastcall TSomeForm::GetWindowMinMaxInfo(TWMGetMinMaxInfo Messag
e)
{//设置主窗口的最小尺寸
MINMAXINFO *MinMaxInfo=Message.MinMaxInfo;
MinMaxInfo->ptMinTrackSize.x=400;
MinMaxInfo->ptMinTrackSize.y=300;
return;
}
其中：TMessage和TWMGetMinMaxInfo类型的定义可参见：
C:\Program Files\Borland\CBuilder\inlucde\vcl\Messages.hpp；其它的消息
响应方法与此相同。
另外，可以为自定义的消息也定义一个对应的消息结构(如：TSearchNode_Mes
sage)，至于如何定义消息结构, 可以参考：
C:\Program Files\Borland\CBuilder\inlucde\vcl\Messages.hpp

利用C++ Builder开发动画DLL
　　我们在Windows98环境下执行拷贝文件、查找文件或计算机等耗时比较长的操作时，Windows会显示一个小小的动画，指示正在进行的操作，与死板的静止图像相比增色不少。那么我们自己开发软件时，能否也显示一个这样的动画提示呢？我在开发一个外贸应用软件系统时，遇到的数据量很大，当通过复合条件查找时，因为不是数据库表的每个项目都有索引，所以很费时，系统也会表现出长时间停顿，用户感觉极为不爽。我经过一段时间的探索，开发了一个能够在采用的开发环境PowerBuilder下调用的动画DLL，由于采用多线程编程，PB调用的DLL函数能够及时将控制权交还为PB，不影响应用系统的运转。用户能够看到一个东西在动，也就不会想到系统是不是停止响应了，感觉时间也似乎没那么久了。
　　代码与编译选项
　　(1) 在C++Builder的File菜单下选择New，在New Item对话框的New属性中选择DLL，C++Builder就会创建一个空白的DLL项目。
　　(2) 在File菜单下选择New Form，C++Builder创建一个空白的Form，修改它的属性为
BorderStyle=bsDialog
BorderIcons的子属性均为False
FormStyle=fsStayOnTop
Position= poScreenCenter
Name=StatusForm
　　(3) 在Form上添加一个Win32下的Animate控件Animate1，修改它的属性为
Align=alTop
　　(4) 在Form上添加一个Standard下的Button控件Button_Cancel，再添加System下的Timer控件Timer1，设置定时Interval时间位250，以较快的响应用户的取消请求。
　　因为PB应用系统与动画窗体代码分别属于两个线程，不能采用PB线程直接关闭动画窗体线程的窗口，否则会引起系统运行不正常，因此采用PB线程设置关闭标志，而动画线程采用Timer控件定时检查标志，一旦检测到关闭标志，就关闭窗口，清除线程标志，结束动画线程。
　　下面给出编码及编码原理：
　　1．DLL DLL主体代码：
/**********************************
* DLL主体代码
* 定义DLL公用变量
* g_CommonAVI
对Animate控件动画类型索引
* gi_Canceled
Button_Cancel按钮是否被选择过
* gi_AVIType
要显示的动画类型，由DLL输出函数做为参数输入
* gi_RequestClose
请求动画线程关闭标志
* gi_WindowActive
动画窗口所处的状态
* lpsWinTitle
动画窗体的标题，由DLL输出函数做为参数输入
*/
TCommonAVI g_CommonAVI[]={
aviNone, aviFindFolder,
aviFindFile, aviFindComputer,
aviCopyFiles, aviCopyFile,
aviRecycleFile, aviEmptyRecycle,
aviDeleteFile
};
int gi_Canceled=0,gi_AVIType=0;
int gi_RequestClose=0,gi_WindowActive=0;
char lpsWinTitle[256];
HWND hWndParent=NULL;
/* 定义DLL 输出函数 */
extern "C" __declspec(dllexport)
int pascal DllEntryPoint(HINSTANCE hinst,
unsigned long reason, void*);
extern "C" __declspec(dllexport) int
pascal ShowStatusWindow(int AVIType,
LPSTR WinTitle,long hWnd);
extern "C" __declspec(dllexport) int
pascal GetStatus(int ai_CloseWin);
extern "C" __declspec(dllexport) int
pascal CloseStatusWindow();
/*定义线程TformThread:*/
class TFormThread : public TThread{
public:// User declarations
__fastcall TFormThread(bool CreateSuspended);
void __fastcall Execute(void);
};
__fastcall TFormThread::
TFormThread(bool CreateSuspended):
TThread(CreateSuspended){
}
/* 动画线程执行代码，
动画窗体的定时器控件会关闭它，
清除窗体存在标志后结束线程的运行
*/
void __fastcall TFormThread::Execute(void){
gi_WindowActive=1;
StatusForm=new TStatusForm(NULL);
StatusForm- >Caption=lpsWinTitle;
StatusForm- >ShowModal();
gi_WindowActive=0;
delete StatusForm;
gi_RequestClose=0;
}
/* 定义一个线程实例指针 */
TFormThread *FormThread;
/**********************************************
* 输出函数代码实现部分
* DllEntryPoint 32位DLL入口
* ShowStatusWindow 显示动画窗口，
它通过创建一个线程来创建窗口，避免由于窗口
的MODAL属性而使控制权不能及时的返还给调用者
* GetStatus
取得撊∠麛状态，即用户有没有选择撊∠麛按钮
* CloseStatusWindow 关闭动画窗口，
*/
__declspec(dllexport) int WINAPI DllEntryPoint
(HINSTANCE hinst, unsigned long reason, void*)
{
return 1;
}
__declspec(dllexport) int pascal
ShowStatusWindow(int AVIType,LPSTR
WinTitle,long hWnd){
hWndParent=(HWND)hWnd;
memset(lpsWinTitle,0,sizeof(lpsWinTitle));
strncpy(lpsWinTitle,WinTitle,sizeof(lpsWinTitle)-1);
if (AVIType >0 && AVIType< =8)
gi_AVIType=AVIType;
FormThread=new TFormThread(true);
FormThread- >

riority = tpNormal;
FormThread- >Resume();
}
__declspec(dllexport) int pascal
GetStatus(int ai_CloseWin){
if (gi_Canceled)
if (gi_WindowActive){
gi_RequestClose=1;
while(gi_RequestClose);
}
return gi_Canceled;
}
__declspec(dllexport) int pascal
CloseStatusWindow(){
if (gi_WindowActive){
gi_RequestClose=1;
while(gi_RequestClose);
}
return gi_Canceled;
}
　　2.窗体StatusForm的代码：
TStatusForm *StatusForm;
//-----------------------------------
extern int gi_Canceled;
extern int gi_AVIType;
extern TCommonAVI g_CommonAVI[];
__fastcall TStatusForm::
TStatusForm(HWND ParentWindow)
: TForm(ParentWindow)
{
gi_Canceled=0;
}
//-----------------------------------
//取消按钮并不直接关闭窗体，
而指示设置取消标志，供调用者查看
void __fastcall TStatusForm::
Button_CancelClick(TObject *Sender)
{
gi_Canceled=1;
// ModalResult=mrCancel;
}
//-----------------------------------
// 激活动画，在FORMCREATE事件中
void __fastcall TStatusForm::
FormCreate(TObject *Sender)
{
Animate1- >CommonAVI=g_CommonAVI[gi_AVIType];
Animate1- >Active = true;
}
//-----------------------------------
extern int gi_RequestClose;
// 定时器事件检测到结束标志关闭窗体
void __fastcall TStatusForm::
Timer1Timer(TObject *Sender)
{
if (gi_RequestClose){
ModalResult=mrOk;
}
}
//-----------------------------------
　　(5) 设置编译选项：Project->Options打开Project Options对话框，清除Linker属性页中的Use Dynamic RTL标志，清除Packages属性页中的Build with runtime packages。这样只要单个DLL就可以运行了，而不必安装一些动态连接运行时间库。使用动画DLL
　　上面编译出DLL可以由其它任何开发语言调用，下面给出在PB中的使用方法。
　　(1) 定义：
//Declare - > Global External Functions
FUNCTION Long ShowStatusWindow(Long
AVIType,String WinTitle,long hWnd) &
LIBRARY "STATWIN.DLL" ALIAS FOR "ShowStatusWindow"
FUNCTION Long GetCancelStatus(Long CloseWindow) &
LIBRARY "STATWIN.DLL" ALIAS FOR "GetStatus"
FUNCTION Long CloseStatusWindow() &
LIBRARY "STATWIN.DLL" ALIAS FOR "CloseStatusWindow"
　　(2) 调用：
long ll_EndTime
//显示查找文件夹动画
ShowStatusWindow(2)
setpointer(HourGlass!)
ll_EndTime = Cpu() + 10 * 1000
DO
if GetCancelStatus(0)=1 then
exit
end if
// 做想做的事情
LOOP UNTIL cpu() > ll_EndTime
CloseStatusWindow()

用C++ Builder 3制作屏幕保护程序
　　屏幕保护程序是以scr为扩展名的标准Windows可执行程序，在激活控制面板的显示器属性的"屏幕保护程序"页时，该模块会自动在Windows启动目录（Windows目录和系统目录）下查找扩展名是scr的基于Windows的可执行文件。使用屏幕保护程序，不仅可以延长显示器的使用寿命，还可以保护私人信息。
　　编制屏幕保护程序不仅要涉及消息的处理，还要涉及命令行参数的处理。在WIN32SDK文档中描述了编制基于WIN32的标准的屏幕保护程序所必须遵守的严格标准。按照这些标准，屏幕保护程序必须要输出两个函数：ScreenSaverProc和ScreenSaverConfigureDialog，但是，在Windows系统中的很多屏幕保护程序并没有遵循这些标准(使用impdef或者tdump实用工具查看即可)。并且使用该文档中介绍的方法编写屏幕保护程序，不仅要使用资源编辑器，并且在链接时还要利用Scrsaver.lib文件（在C++Builder3环境下，不能成功连接）。不仅要涉及消息的处理，还要涉及命令行参数的处理。
　　C++Builder3是一种快速的应用程序开发工具，提供了许多类型的应用程序开发模板，但没有提供开发屏幕保护程序的模板，并且在其在线帮助中也没有提及如何开发这类应用程序。经过本人的研究，找到了用C++Builder3编制屏幕保护程序的方法。
　　在控制面板的"显示器属性"项的"屏幕保护程序"页中进行设置时，要遇到三种类型的命令行参数，并且，各种情况下的屏幕保护程序的显示结果也各不相同，一般来讲，就需要三种类型的窗体（或两种，在随后的内容中讨论）。下面将分四步来具体地说明如何编制屏幕保护程序。
　　一、屏幕保护程序的选择
　　如果在标题为"屏幕保护程序"的下拉列表框中选中了某个保护程序时，系统会自动启动该程序，这个程序的显示范围是在这个页面上的显示器图形的屏幕范围，同时，会将两个命令行参数：一个是"/p"；另一个是显示窗口的句柄，传递给这个被选中的程序。因此，这类程序首先应该能够处理命令行参数。在C++Builder3中，与命令行参数处理有关的函数是：ParamCount()和ParamStr()，具体的申明方式如下：
　　1．externPACKAGEint__fastcallParamCount(void);
　　该函数返回命令行参数的个数，但不包含应用程序本身。
　　2．externPACKAGEAnsiString__fastcallParamStr(intIndex);
　　该函数返回指定索引值的命令行参数。ParamStr(0)返回的是应用程序本身。
　　所以，在这以步骤中的参数判断的语句如下：
if(UpperCase(ParamStr(1))==
"-p"||UpperCase(ParamStr(i))=="/p")
{
//addthecodeinhere
}
　　在完成了参数判断后，就应该对显示窗口的处理，为能够使程序在显示器图形的屏幕区域内显示，就要重新设置程序的父窗口和显示区域。这要涉及到父窗口句柄的获得及父窗口的设置，以及API函数的调用。这种环境下的父窗口句柄就是传递过来的第二个命令行参数；要设置父窗口，只需设置窗体的ParentWindow属性即可。这段程序如下：
RECTrc;//Line1
HWNDhWnd=(HWND)
(atol(ParamStr(2).c_str()));//Line2
::GetClientRect(hWnd,&rc);//Line3
ParentWindow=hWnd;//Line4
Left=rc.left;//Line5
Top=rc.top;//Line6
Width=rc.right-rc.left;//Line7
Height=rc.bottom-rc.top;//Line8
　　在上面的程序片段中，第2行语句是将传递过来的第2个参数转换成窗口句柄；然后，第3行语句利用这个窗口句柄，调用API函数以获得该窗口的客户区域；第4行语句将选中的屏幕保护程序的父窗口设置为指定的窗口；余下的语句是将该程序的窗口大小设置成副窗口的客户区大小。这一程序片段的位置应该是在窗体的OnCreate事件处理中。
　　需要说明的是，这种类型（包括第三步介绍的窗体）的窗体样式应是：
FormStyle=fsStayOnTop;
　　窗体边界的样式应为：
BorderStyle=bsNone;
当然，这时也不需要鼠标图形，因此，可以将鼠标的形状设为crNone：
Cursor=crNone;
　　二、初始化参数的设置
单击"显示器属性"模块的"屏幕保护程序"页面中的"设置"按钮时，系统会启动指定的保护程序的初始值设置对话框，这时传递过来的命令行参数是："/c"或"-c"（参数的处理与前面介绍的相同）。通过该对话框，可以设置保护程序的一些初始参数，比如图形的变化快慢等。在这段程序中，还要涉及到初始化文件或注册表的读写，用以记录初始化参数，便于保护程序启动时使用。
　　三、预览及运行
　　预览的效果就是屏幕保护程序被激活后的显示。单击单击"显示器属性"模块的"屏幕保护程序"页面中的"预览"按钮，就可以观察保护程序运行的实际效果。这时，系统启动该程序时传递过来的命令行参数是："/s"或"-s"。对于命令行参数的处理与前面的步骤相同，但在这一步中，还要对几个消息进行处理，这些消息是：WM_MOUSEMOVE，WM_LBUTTONDOWN，WM_MBUTTONDOWN，WM_RBUTTONDOWN，WM_KEYDOWN，WM_ACTIVATE。对WM_MOUSEMOVE和WM_ACTIVATE消息的处理形式如下：
void__fastcallHandleSomeMessage(TMessage&Msg)
{
switch(Msg.Msg)
{//......
caseWM_ACTIVATE:if(Msg.WParamLo==WA_INACTIVE)
Close();
break;
caseWM_MOUSEMOVE:if(OldMouseX==-1&&OldMouseY==-1)
//Intheconstructor,OldMouseXand
OldMouseYmustbeinitializedby-1.
{OldMouseX=Msg.LParamLo;
OldMouseY=Msg.LParamHi;
}
elseif(OldMouseX!=Msg.LParamLo
||OldMouse!=Msg.LParamHi)
Close();
break;
......
}
}
　　对于其他的消息仅仅是调用Close()函数来关闭应用程序即可。应用这种消息处理方式时，必须要类定义时进行消息映射，不然的话，就要在相应的消息响应中进行处理（使用一定的布尔变量，就可以与第一步合用一个窗体）。
　　与第一步类似，在该步骤中，也不需要具体的鼠标指针的形状，因此，将鼠标指针设为crNone：
Cursor=crNone;
　　四、修改项目源文件
　　在C++Builder3中，一个窗体也就是一个类，换句话说，具有某些特性的类也就是一个窗体，因此，编制屏幕保护程序时，也不需要什么主窗体，同时，也不用自动创建某些窗体了，这时就要修改项目源文件，下面所列出的程序就是笔者在编制某屏幕保护程序时使用的项目源文件，供读者参考。
WINAPIWinMain(HINSTANCE,HINSTANCE,LPSTR,int)
{
CreateMutex(NULL,true,"ScreenSaver");
if(GetLastError()!=ERROR_ALREADY_EXISTS)
{
try
{
Application->Initialize();
Application->Title="屏幕保护程序测试";
if(UpperCase(ParamStr(1))==
"/C"||UpperCase(ParamStr(1))=="-C"
||ParamCount()==0)
{TScrSaverConfiguerF*ScrCfg=
newTScrSaverConfiguerF(NULL);
ScrCfg->ShowModal();
deleteScrCfg;
return0;
}//单击"设置"按钮
elseif(UpperCase(ParamStr(1))==
"/P"||UpperCase(ParamStr(1))=="-P")
{TScrForP*ScrFP=newTScrForP(NULL);
ScrFP->ShowModal();
deleteScrFP;
return0;
}//在"屏幕保护程序"下拉列表框中选择一个程序
elseif(UpperCase(ParamStr(1))==
"/S"||UpperCase(ParamStr(1))=="-S")
{TScreenSaveF*ScreenSave=newTScreenSaveF(NULL);
ScreenSave->ShowModal();
deleteScreenSave;
return0;
}//单击"预览"按钮，及运行屏幕保护程序
else
return1;
}
catch(Exception&exception)
{
Application->ShowException(&exception);
}
}
return0;
}//theWinMainFunctionend
　　前面介绍了在C++Builder3下编制屏幕保护程序的方法.对于C++Builder3这种RAD工具来讲，开发这类程序也是相当方便的，按照前述的方法，可以在极短的时间开发出屏幕保护程序。对于屏幕保护程序，在本文中没有说明的就是如何设置口令的问题，这部分就由读者自己摸索吧。

TCP/IP头格式

一、先是常用的IP头格式。
IP头格式：
版本号 (4位)
IP头长度 (4位)
服务类型 (8位)
数据包长度 (16位)
标识段 (16位)
标志段 (16位)
生存时间 (8位)
传输协议 (8位)
头校验和 (16位)
发送地址 (16位)
目标地址 (16位)
选项
填充
简单说明
============
1. IP头长度计算所用单位为32位字, 常用来计算数据开始偏移量
2. 数据包长度用字节表示, 包括头的长度, 因此最大长度为65535字节
3. 生存时间表示数据被丢失前保存在网络上的时间, 以秒计.
4. 头校验和的算法为取所有16位字的16位和的补码.
5. 选项长度是可变的, 填充区域随选项长度变化, 用于确保长度为整字节的倍数.
描述
============
struct iphdr {
BYTE versionihl;
BYTE tos;
WORD tot_len;
WORD id;
WORD frag_off;
BYTE ttl;
BYTE protocol;
WORD check;
DWORD saddr;
DWORD daddr;
/* Put options here. */
};
二、TCP头格式
TCP头格式：
源端口 (16位)
目的端口 (16位)
序号 (32位)
确认号 (32位)
数据偏移 (4位)
保留 (6位)
标志 (6位)
窗口 (16位)
校验和 (16位)
紧急指针 (16位)
选项
填充
简单说明
============
1. 数据偏移用于标识数据段的开始
2. 保留段6位必须为0
3. 标志包括紧急标志、确认标志、入栈标志、重置标志、同步标志等。
4. 校验和计算方式为将头与16位二进制反码和中的16位二进制反码加在一起。
5. 选项长度是可变的, 填充区域随选项长度变化, 用于确保长度为整字节的倍数.
6. 更详细的说明请参阅有关资料。
描述
============
struct tcphdr {
WORD SourPort;
WORD DestPort;
DWORD SeqNo;
DWORD AckNo;
BYTE HLen;
BYTE Flag;
WORD Window;
WORD ChkSum;
WORD UrgPtr;
/* Put options here. */
};

UDP

一、说明
使用UDP时，直接使用API代替控件。
第一个程序(ReadBufferUdp)使用来接收到缓存中。
"Destino"变量非常重要，如果你从其他地方接收数据到Buffer，你必须设置Destino = 0 并且在以后执行的时候赋值你将要发送的包的地址给它（after the execution it will have the address which send you the packet.）。
如果你只想从一个指定的地址接收数据，你必须设置变量Destino = <address>.
"gvEncerrar" 用来中止处理过程。(gvEncerrar被设置为全局变量。)
超时时间设置。"Inicio + 12" = 12 sec of timeout.
第三个程序是用来准备WinSock程序。
二、代码
int ReadBufferUdp(unsigned long *Destino,void *T,int Size)
{
char Buffer[128];
SOCKADDR_IN SockAddr;
int LenSockAddr=sizeof(SOCKADDR_IN);
fd_set FdRead;
struct timeval t_val;
int Ret;
time_t Inicio = time(NULL);
Application->

rocessMessages();
if(gvEncerrar)
return false;
FD_ZERO(&FdRead);
FD_SET(gvSocket,&FdRead);
t_val.tv_sec=0;
t_val.tv_usec=0;
while((Ret=select(0,&FdRead,NULL,NULL,&t_val))!=1 && (Inicio + 12) >
time(NULL) && !gvEncerrar)
{
FD_ZERO(&FdRead);
FD_SET(gvSocket,&FdRead);
t_val.tv_sec=0;
t_val.tv_usec=0;
Application->

rocessMessages();
}
if(Ret != 1)
return false;
if(recvfrom(gvSocket,Buffer,Size,0,(LPSOCKADDR)&SockAddr,&LenSockAddr)!=Size)
return false;
if(*Destino == 0)
{
*Destino = SockAddr.sin_addr.s_addr;
}
else
if(*Destino != SockAddr.sin_addr.s_addr)
return false;
memcpy(T,Buffer,Size);
return true;
}
int WriteBufferUdp(unsigned long Destino,void *T,int Size)
{
SOCKADDR_IN SockAddr;
int Sent;
Application->

rocessMessages();
SockAddr.sin_family = AF_INET;
SockAddr.sin_port = gvPortUdp;
SockAddr.sin_addr.s_addr = Destino;
Sent = sendto(gvSocket,(char
*)T,Size,0,(LPSOCKADDR)&SockAddr,sizeof(SockAddr));
if(Sent != Size)
return false;
else
return true;
}
void InicializaTCPIP()
{
WORD wVersionRequested;
WSADATA wsaData;
IN_ADDR In;
PSERVENT PServent;
SOCKADDR_IN SockAddrIn;
wVersionRequested = MAKEWORD( 1, 1 );
if(WSAStartup( wVersionRequested, &wsaData ))
{
ShowMessage("Erro na inicializao do TCP/IP");
Application->Terminate();
return;
}
// Get the port on service file
if((PServent=getservbyname("your_service_name","udp"))==NULL)
{
ShowMessage("Erro obtendo port do servi transurb/udp");
Application->Terminate();
return;
}
gvPortUdp = PServent->s_port;
sprintf(StrAux,"Servi transurb/udp port:%d",ntohs(gvPortUdp));
Log(StrAux);
// Open de Socket
if((gvSocket = socket(AF_INET,SOCK_DGRAM,0))==INVALID_SOCKET)
{
ShowMessage("Erro na criao do socket");
Application->Terminate();
return;
}
Log("Socket criado com sucesso");
// Do the bind
SockAddrIn.sin_family = AF_INET;
SockAddrIn.sin_port = gvPortUdp;
SockAddrIn.sin_addr.s_addr = NULL;
if(bind(gvSocket,(LPSOCKADDR)&SockAddrIn,sizeof(SockAddrIn))==SOCKET_ERROR)
{
ShowMessage("Erro no bind do socket");
Application->Terminate();
return;
}
Log("Bind do socket com sucesso");
}

判断windows的Desktop及其它目录

使用API函数SHGetSpecialFolder。shlobj.h里有SHGetSpecialFolder的原型声明。这个函数可以帮我们找到windows的Desktop目录、启动目录、我的文档目录等。
SHGetSpecialFolder需要三个参数。第一个参数是HWND，它指定了"所有者窗口"：在调用这个函数时可能出现的对话框或消息框。第二个参数是一个整数id，决定哪个目录是待查找目录，它的取值可能是：
CSIDL_BITBUCKET 回收站
CSIDL_CONTROLS 控制面板
CSIDL_DESKTOP Windows 桌面desktop
CSIDL_DESKTOPDIRECTORY desktop的目录
CSIDL_DRIVES 我的电脑
CSIDL_FONTS 字体目录
CSIDL_NETHOOD 网上邻居
CSIDL_NETWORK 网上邻居virtual folder
CSIDL_PERSONAL 我的文档
CSIDL_PRINTERS 打印机
CSIDL_PROGRAMS 程序组
CSIDL_RECENT 大多数最近打开的文档列一
CSIDL_SENDTO “发送到”菜单项
CSIDL_STARTMENU 任务条启动菜单项
CSIDL_STARTUP 启动目录
CSIDL_TEMPLATES 临时文档
最后一个参数是pidl地址。SHGetSpecialFolderLocation把地址写到pidl。
下面的代码演示了怎样使用SHGetSpecialFolderLocation：
//----------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
LPITEMIDLIST pidl;
LPMALLOC pShellMalloc;
char szDir[MAX_PATH];
if(SUCCEEDED(SHGetMalloc(&pShellMalloc)))
{
if(SUCCEEDED(SHGetSpecialFolderLocation(NULL,
CSIDL_DESKTOPDIRECTORY,
&pidl)))
{
// 如果成功返回true
if(SHGetPathFromIDList(pidl, szDir))
{
Label1->Caption = szDir;
}
pShellMalloc->Free(pidl);
}
pShellMalloc->Release();
}
}
//----------------------------------------------------------------------
注意: 有些目录是空的。有些特定的目录在这个文件系统上并没有一个相应的目录。

作者: ilikenba 时间: 2004-9-24 21:42
<

>取得本地internet机器的名字及IP地址 <

>一、下面的例子使用 Winsock API 取得本地主机的名字及地址
void __fastcall TForm1::Button1Click(TObject *Sender)
{
hostent *p;
char s[128];
char *p2; <

>//Get the computer name
gethostname(s, 128);
p = gethostbyname(s);
Memo1->Lines->Add(p->h_name); <

>//Get the IpAddress
p2 = inet_ntoa(*((in_addr *)p->h_addr));
Memo1->Lines->Add(p2);
} <

>void __fastcall TForm1::FormCreate(TObject *Sender)
{
WORD wVersionRequested;
WSADATA wsaData; <

>//Start up WinSock
wVersionRequested = MAKEWORD(1, 1);
WSAStartup(wVersionRequested, &wsaData);
} <

>void __fastcall TForm1::FormDestroy(TObject *Sender)
{
WSACleanup();
} <

>用C++Builder创建数字签名 <

>
　　如果你在网络上传递一份数据，但却存在着种种不安全的因素，使你对数据能否原封不动地到达目的地而心存疑惑，这时，你就可以给数据加上数字签名，从而使对方可以通过验证签名来检查你所传过去的数据是否已被他人修改。 <

>　　一、程序原理 <

>　　数字签名的工作原理还是比较简单的，它是根据你所提供的原始数据，经过复杂的算法，产生特定的数据签名，对方通过同样的过程也产生签名，如果数据已被修改，那么就不可能得到两份一模一样的签名，从而就可判断数据已被他人修改。编程人员利用Windows的CAPI接口，就可以实现数据的加密、解密和数字签名。　　 <

>　　二、程序清单 <

>　　下面用C＋＋ Builder的语句来看一下它的具体实现过程。
　　先来创建数字签名,假定其数据来自于一个文件。
　　//变量声明：
　　HCRYPTPROV hProv；
　　// CSP的句柄
　　HCRYPTHASH hHash；
　　// 散列的句柄
　　const int BUFFER=4096;
　　// 缓冲区大小常数
　　BYTE pBuffer[BUFFER];
　　// 存放读文件内容的缓冲区
　　BYTE pSignature[256];
　　// 存放签名的缓冲区
　　DWORD dSignatureLen=256;
　　// 签名的长度
　　TFileStream ＊sourceFile；
　　// 一个文件流
　　if(!CryptAcquireContext（＆hProv,NULL,NULL,PROV-RSA-FULL,0))
　　// 连接默认的CSP，接受它的句柄放入hProv
　　{
　　　　// 错误处理
　　}
　　if(!CryptCreateHash(hProv,CALG-MD5,0,0,＆hHash))
　　// 创建一个散列对象，得到它的句柄放入hHash
　　{
　　　　// 错误处理
　　}
　　do
　　{
　　 dReadLen=sourceFile－>Read(pBuffer,BUFFER);
　　 if(!CryptHashData(hHash,pBuffer,dReadLen,0))
　　// 根据文件的内容计算散列值
　　 {
　　　　// 错误处理
　　 }
　　}while(!(dReadLen<BUFFER));
　　if(!CryptSignHash(hHash,AT-SIGNATURE,NULL,0,pSignature,＆dSignatureLen))
　　//使用私人密钥对散列值进行数字签名
　　//签名数据放入pSignature，长度放入dSignatureLen
　　// 错误处理
　　}
　　对基于文件的数据签名进行检验。
　　//变量声明：
　　HCRYPTPROV hProv；
　　// CSP的句柄
　　HCRYPTHASH hHash；
　　// 散列的句柄
　　HCRYPTKEY hPublicKey;　　　　
　　// 公共密钥的句柄
　　const int BUFFER=4096;　　
　　// 缓冲区大小常数
　　BYTE pBuffer[BUFFER];　　　　
　　// 存放读文件内容的缓冲区
　　TFileStream ＊sourceFile； // 一个文件流
　　BYTE pSignature[256];　　　　
　　// 上一段得到的签名的缓冲区
　　DWORD dSignatureLen；　　　　
　　// 上一段得到的签名的长度
　　if(!CryptAcquireContext（＆hProv,NULL,NULL,PROV-RSA-FULL,0))
　　// 连接默认的CSP，接受它的句柄放入hProv
　　{
　　　　// 错误处理
　　}
　　if(!CryptGetUserKey(hProv,AT_SIGNATURE,＆hPublicKey); // 得到公共密钥的句柄
　　{
　　　　// 错误处理
　　}
　　if(!CryptCreateHash(hProv,CALG-MD5,0,0,＆hHash)) // 创建一个散列对象，得到它的句柄放入hHash
　　{
　　　　// 错误处理
　　}
　　do
　　{
　　 dReadLen=sourceFile－>Read(pBuffer,BUFFER);
　　 if(!CryptHashData(hHash,pBuffer,dReadLen,0))
　　// 根据文件的内容计算散列值
　　 {
　　　　// 错误处理
　　 }
　　}while(!(dReadLen<BUFFER));
　　if(!CryptVerifySignature(hHash,pSignature,dSignatureLen,hPublicKey,NULL,0))
　　{
　　　　if(GetLastError()==NTE-BAD-SIGNATURE) ShowMessage(″文件已被修改″);
　　}
　　else
　　{
　　 ShowMessage(″文件没被修改″);
　　} <

>　　以上是一个数字签名的简单实现，得到的签名数据可以单独保存，也可以分开保存。 <

>用Enter 键控制焦点切换的方法 <

>在Windows 环境下，要使一个控件取得焦点，可在该控件上用鼠标单击一下，或按Tab 键将焦点移至该控件上。这种控制焦点切换的方法有时不符合用户的习惯。就图一而言，用户就希望用Enter 键，控制焦点由Edit1 切换到 Edit2。要实现这样的功能需借助WinAPI 函数SendMessage 来完成。方法是：先设Form1 的KeyPreview 属性为true, 然后在Form1 的OnKeyPress 事件中加入如下的代码。这样，用户就可以通过按Enter，键控制焦点按定义好的Taborder 顺序来移动了！
void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key)
{
if(Key==VK_RETURN) <

>{
SendMessage(this- >Handle,WM_NEXTDLGCTL,0,0);
Key=0;
}
} <

>
拦截 Windows 消息 <

>
- --Borland C++ Builder的API后门 <

>---- 引子 <

>---- C++ Builder不愧为Borland公司的优秀产品，用它来开发Windows程序非常快捷高效，但在编程过程中你也会发现它的一些限制性，让你无法实现自己的想法。比如你无法在修改表单的系统菜单；比如使用跟踪栏时，你找不到StartTrack和EndTrack事件，而偏偏你的程序需要这两个事件。Windows API编程中，你就不会有这些麻烦，只需处理一下WM_SYSCOMMAND和WM_HSCROLL(或WM_VSCROLL)消息，就能实现上述功能。Windows API的缺点是编程十分麻烦，太多的时间要耗在细节上面，但它的功能却是最强大的。C++ Builder的VCL在功能上只是它的一个子集，因为VCL是在API的基础上封装的，封装时舍弃了一些不常用到的功能。但是程序员的想象力没有被封装，他们总怀着更大的热情去实现别出心裁的想法，修改系统菜单和给跟踪栏增加StartTrack和ndTrack事件只是其中的小把戏而已。可是VCL并没有这些功能，怎么办？ <

>---- 幸好，Borland公司没有把路堵死，而是留了个后门--允许程序员自己拦截并处理Windows消息，就象API编程一样。于是，办法有了... <

>---- 方法 <

>---- 拦截Windows消息需要以下几步：
---- 在表单头文件内(如Unit1.h)
---- 1. 在类声明中建立消息映射表，把某条消息的处理权交给自定义的消息处理函数。 <

>BEGIN_MESSAGE_MAP
MESSAGE_HANDLER(Windows消息名，TMessage，消息处理函数名)
MESSAGE_HANDLER(...)
END_MESSAGE_MAP（TForm） <

>
---- 2. 在类声明的private区内声明消息处理函数。 <

>private: // User declarations
void __fastcall 消息处理函数名(TMessage &Message)；
在表单文件内（如Unit1.cpp） <

>
---- 3. 写出消息处理函数，在这里实现你需要的功能。比如
void __fastcall MainForm::OnWMHScroll (TMessage &Message)
{
... // 在此加入你自己的代码
TForm:

ispatch(&Message);
} <

>
---- 解释 <

>---- 1. 关于TMessage ---- TMessage是VCL预定义的结构，定义如下：
struct TMessage
{
unsigned int Msg; //消息
int WParam; //字参数
int LParam; //长字参数
int Result; //消息结果
}; 
---- 2. 关于TForm:

ispatch(&Message) ---- 自定义的消息处理函数末尾最好加一句TForm:

ispatch(&Message)，这一句的作用是让消息继续传递下去。如果没有这一句，消息将被完全拦截，VCL类可能由于得不到消息而无法实现正常功能。 ---- 实例一：修改系统菜单 ---- 有一些程序，主窗口很小，菜单也没有，如果想加入关于或设置对话框，最好的办法是拿系统菜单开刀。Windows API编程中，修改系统菜单与实现其他功能一样，不太容易，也不会太难。但在C++ Builder中，表单类(TForm)没有提供有关系统菜单的任何属性与方法，实现其他功能易如反掌，而修改系统菜单似乎难于上青天。 ---- 还好，Borland公司允许程序员自已处理Window消息，于是机会来了！ 一、用Window API函数修改系统菜单 假定表单名为MainForm，设置MainForm::OnCreate()函数： 1. 用GetSystemMenu(MainForm->Handle,false)取得系统菜单句柄； 2. 用AppendMenu,DeleteMenu,ModifyMenu函数修改系统菜单，把新的ID号赋于自定义的菜单项。
这时运行程序，可以看到系统菜单也被修改，但自定义的菜单项却不能被响应。 二、拦截WM_SYSCOMMAND消息以响应自定义的菜单项
在表单头文件内(如Unit1.h) 1. 在表单类定义末尾加入消息响应表，取得WM_SYSCOMMAND消息的处理权
BEGIN_MESSAGE_MAP
MESSAGE_HANDLER(WM_SYSCOMMAND,TMessage,OnWMSysCommand)
END_MESSAGE_MAP(TForm) 2. 在表单类定义的private区内加入消息处理函数声明
private: // User declarations
void __fastcall OnWMSysCommand(TMessage& Message); 在表单文件内(如Unit1.h) 3. 写出消息响应函数
void __fastcall TForm1::OnWMSysCommand(TMessage& Message)
{
if(Message.WParam==ID_SysMenu_MyItem)
{
// Your Code Here, Do Something
}
TForm:

ispatch(&Message);
} 
三、完整程序示例 实例二：给跟踪栏增加OnStartTrack和OnEndTrack事件 当跟踪栏用于进度控制时，OnStartTrack和OnEndTrack很可能是你需要的事件。比如在控制多媒体播放进度的场合，当用户移动滑块时，你需要OnStartTrack事件让播放停止，需要OnEndTrack事件定位新的播放位置。但Borland公司没有提供这两个事件，我等编程爱好者只好自力更生，打拦截Windows消息的主意了。 一、拦截WM_HSCROLL消息，给跟踪栏增加OnStartTrack和OnEndTrack事件 在表单头文件内（如Unit.h） 1. 在表单类定义末尾加入消息响应表，把WM_HSCROLL消息处理权交给OnWMHScroll函数。
BEGIN_MESSAGE_MAP
MESSAGE_HANDLER(WM_HSCROLL,TMessage,OnWMHScroll)
END_MESSAGE_MAP(TForm) 2. 在表单类定义的private区内加入OnWMHScroll函数声明。
private: // User declarations
void __fastcall OnWMHScroll(TMessage &Message); 
3. 在表单类定义的private区内加入StartTrack和EndTrack函数声明。
private: // User declarations
void __fastcall TrackBar1StartTrack(TObject *Sender);
void __fastcall TrackBar1EndTrack(TObject *Sender); 在表单文件内（如Unit.cpp） 4. 写出OnWMHScroll函数，使它能根据消息参数调用StartTrack和EndTrack函数，在实际意义上产生OnStartTrack和OnEndTrack事件。 5. 写出StartTrack和EndTrack函数。 如果是垂直跟踪栏，把上面的WM_HSCROLL改为WM_VSCROLL即可。 二、完整程序示例 尾声 Borland C++ Builder编程中，拦截Windows消息是一项高级编程技术，能让你尽量挖掘Windows的潜力，尤其让曾用API编程的程序员感到心慰。拦截Windows消息是API尽情发挥的舞台，当VCL不能为你做什么时，请想起底层的API。 使用CommaText 有时需要一个方便的方法存放一个StringList，它只有简单的一行。例如，当你想使用一个INI文件，如何向一个INI文件中写入一行呢，使用CommaText 就能完成这个工作。 这里有个例子，功能是创建一个blah.ini文件，并写入一个如下形式的值: [My Section]
Memo1=(你在Memo1中输入的文字) 1.在Form1上有两个按钮btnLoad and btnSave和一个Memo1 2.还要加入：
#include <inifiles.hpp> 3.定义变量：
const String iniFile="blah.ini",iniSection="My Section",iniValue="Memo1"; 4.保存按钮代码：
void __fastcall TForm1::btnSaveClick(TObject *Sender)
{
TIniFile *ini=new IniFile(ExtractFilePath(Application->ExeName)+iniFile);
ini->WriteString(iniSection,iniValue,Memo1->Lines->CommaText);
delete ini;
} 5.装载按钮代码：
void __fastcall TForm1::btnLoadClick(TObject *Sender)
{
TIniFile *ini=new TIniFile(ExtractFilePath(Application->ExeName)+iniFile);
Memo1->Lines->CommaText=ini->ReadString(iniSection,iniValue,"");
delete ini;
} 6.以下代码支持加载后对内容进行排序，到实际存储不变:
void __fastcall TForm1::btnSortLoadClick(TObject *Sender)
{
TStringList *sl=new TStringList;
TIniFile *ini=new TIniFile(ExtractFilePath(Application->ExeName)+iniFile);
sl->CommaText=ini->ReadString(iniSection,iniValue,"");
sl->Sort();
Memo1->Lines=sl;
delete ini;
delete sl;
} 程序开始时先显示信息框 一、软件进入主窗口前，先显示一个信息框，告诉用户一些有关该软件的信息，比如软件名称，版本号等。该信息框在显示1～2秒后自动消失。
1.建立New Application,这时系统自动生成一个Form1,这作为主Form. 2.File->New Form 建立一个新Form为Form2,这个作为信息框。 3.在Form2上添加组件TTimer(System控件条上），用于设定信息框的显示时间。
4.TTimer的事件OnTimer中加入：Form2->Close(); 5.在WinMain()函数中加入：
Application->CreateForm(__classid(TForm2), &Form2);
Form2->ShowModal( ); //这句要自己加入
Application->Run();
并且要把Form2的头文件Unit2.h包括到WinMain()所在的Project1.cpp中。 6.运行程序，将先显示Form2,显示时间由TTimer的Interval属性决定，1000是一秒。 二、软件封面的实现
现代软件设计的流行做法是，在程序运行完成初始化之前，先调用一幅画面做为封面，通常是1/4 屏幕大小，显示一下软件的名称、作者、版本等信息。要用C++ Builder 实现这样的功能，方法很简单： ① 自定义一窗体类 TSplashForm，将其设置成" 透明窗口"，即 BorderIcons 下的所有选项均置成false， BorderStyle=bsNone，FormStyle=fsStayOnTop， Position=poScreenCenter； ② 在TSplashForm 窗体上放置一TPanel（相当于图形的镜框）； ③ 在TPanel 上放置一TImage 控件，调入所需要的图形; ④ 对WinMain 函数稍加修改，加入如下所示代码即可。需要指出的是，这段代码通过函数 FindWindow，搜索内存中是否有窗口标题为 "Demo" 应用程序存在，若存在，则退出程序的运行。该功能可防止程序的再次运行。在某些场合这样设计是必须的。 WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
{
try
{
if(FindWindow(NULL,"Demo")!=0)
{
Application- >MessageBox (" 程序已经运行!"," 警
告",MB_ICONSTOP);
return 0;
} TSplashForm *splash=new TSplashForm(Application); splash- >Show(); splash- >Update(); Application- >Initialize(); Application- >CreateForm(__classid(TForm1), &Form1); splash- >Close(); delete splash; Application- >Run(); } catch (Exception &exception) { Application- >ShowException(&exception); } return 0; } 怎样获取程序的命令行参数？ 
你可以用下面的两种不同的技巧来解决这个问题。 技巧1：首先，也许是最简单的方法是调用VCL ParaStr()函数。你可使用ParamCount()函数来确定到底有多少个命令行参数传递给了应用程序。 ParamStr需要一个整数参数并且返回一个AnsiString对象。若参数为0，ParamStr 将返回可执行文件的全称路径。若参数为1，将返回程序名及第一个命令行参数。若参数为2，将返回第二个参数，等等。 作为一个实践，开启一个新的项目，在主窗口上放置5个Label，将下面的代码添加到窗口的构造函数中： Label1->Caption = ParamStr(0);
Label2->Caption = ParamStr(1);
Label3->Caption = ParamStr(2);
Label4->Caption = ParamStr(3);
Label5->Caption = ParamStr(4);
再运行程序。一般应能看到类似字符串： E:\CBUILDER\PROJECTS\PROJECT1.EXE
如果没传递参数到程序，那么Label2到Label5是空字符串。关闭程序，从C++Builder菜单中选择 Run | Parameters。输入几个参数(-debug -testing -param)再次运行程序。你将看到： E:\CBUILDER\PROJECTS\PROJECT1.EXE
-debug
-testing
-param
提示： ParamStr 对目录中的空格能智能判断。为证实这点，把生成的EXE文件拷贝到Program Files目录下再运行它，你将会看到ParamStr(0)返回全路径，并包含空格。 技巧2：第二个方法就是调用GetCommandLine API函数。GetCommandLine不需要参数，并且返回一个C风格的char *，包含全部的命令行参数。你将不得不分解字符串以取得相关参数。 Label5->Caption = AnsiString(GetCommandLine());
运行后，Label5将为： "E:\CBuilder\Projects\Project1.exe" -debug -testing -param 
如何监视剪贴板 在Form1的.h的private加上：
void __fastcall ClipboardChanged(TMessage& Msg); 在Form1的.h的public加上：
BEGIN_MESSAGE_MAP
　MESSAGE_HANDLER(WM_DRAWCLIPBOARD,TMessage,ClipboardChanged)
END_MESSAGE_MAP(TForm) 在Form1的.cpp内加上：
void __fastcall TForm1::ClipboardChanged(TMessage& Msg)
{
　POINT MousePos;
　GetCursorPos(&MousePos);
　PopupMenu4->PopupComponent=Form1;
　PopupMenu4->Popup(MousePos.x,MousePos.y); //一有变化,就弹出一个菜单，复制,剪切或清除都能引发此函数
} 在Form1的.cpp内有一个ToolButton
void __fastcall TForm1::ToolButton9Click(TObject *Sender)
{
　static HWND LastHandle;
　static bool clip=false;
　if(clip==true)
　{
　　ToolButton9->Down=false;
　　ChangeClipboardChain(Form1->Handle,LastHandle); //结束监视
　}
　else
　{
　　ToolButton9->Down=true;
　　Clipboard()->Clear();
　　Application->Minimize();
　　LastHandle=SetClipboardViewer(Form1->Handle); //启动监视
　}
　clip=!clip;
} 
如何使用OnIdle事件 使用OnIdle事件随时监视剪贴板内容以改变弹出菜单的可执行项。 在Form1的.h的private加上：
void __fastcall OnIdle(TObject* Sender,bool& Done); 在Form1的.cpp内加上：
void __fastcall TForm1::OnIdle(TObject* Sender,bool& Done)
{
　bool TextSelected=DBRichEdit1->SelLength>0;
　N17->Enabled=TextSelected;//剪切,复制,清除
　N18->Enabled=TextSelected;
　N20->Enabled=TextSelected;
　bool CBHasText=Clipboard()->HasFormat(CF_TEXT);// 需加入#include<Clipbrd.h>
　N19->Enabled=CBHasText;//粘贴
　bool HasText=RichEdit1->Lines->Count>0;
　N21->Enabled=HasText;//全选
　bool HasChanged=RichEdit1->Modified;
　ToolButton2->Enabled=HasChanged;
　ToolButton4->Enabled=HasChanged;
} 在Form1的OnCreate内加上：
Application->OnIdle=OnIdle; 
　
用C++Builder4.0编写Win 95下的串行异步通信程序 　　·串口操纵的基本方法· 
　　在Win32下，对串口的操作就如同对文件一样打开或关闭，对串行数据的读写可在用户定义的读写缓冲区中进行。具体使用的函数为： 　　首先用CreateFile( )打开通信串口，其中参数lpFileName指向串口逻辑名，如“COM1”或“COM2”等，参数dwDesiredAccess定义文件的读写权限，一般设为GENERIC-READ|GENERIC-WRITE；参数dwShareMode定义资源共享方式，此处必须设为0，为独占方式；lpSecurityAttributes定义安全属性，Win 95下为NULL；dwCreationDistribution定义文件创建方式；dwFlagsAndAttributes定义文件属性和标记，应设为FILE-FLAG-OVERLAPPED，表示异步通信方式；hTemplateFile 指向一个模板文件的句柄，在 Windows 95下为NULL。 　　然后用BuildCommDCB( )和SetCommState( )函数通过通信设备控制块DCB（Device Control Block）设置串口通信参数(如波特率、停止位、数据位、校验位等)，其中BuildCommDCB( )中的字符串参数lpDef 定义同DOS命令中MODE的参数格式，关于DCB更具体的设置需要根据用户对数据流定义、握手信号及通信控制要求具体定义，参见有关Windows技术资料。用GetCommState()可以得到当前的DCB参数值。如果需要还可通过SetCommTimeouts()和GetCommTomeouts()重新设置读写的超时参数；读写缓冲区的设置使用SetupComm()，参数dwInQueue和 dwOutQueue分别定义为输入和输出缓冲区的大小。 　　在串口初始化完毕后，还要建立与通信有关的事件对象。一般使用CreateEvent()函数，它返回一事件句柄，其中参数lpEventAttributes指向安全属性结构地址，在Win 95（无安全属性）中为NULL；布尔参数bManualReset 定义事件重置方式，true 表示手工重置，false表示自动重置（相关函数为SetEvent()和ResetEvent()）；参数bInitialState定义事件初始状态，true表示发信号，否则为不发信号；lpName是为多进程设置的事件名，对于单进程定义为NULL。然后用SetCommMask()定义用户程序可监视的通信事件类别。 　　以上设置完成后，用户程序就可以等待通信事件的产生，一般调用函数WaitCommEvent()监视通信事件，其中参数lpEvtMask指向产生事件的掩码地址，用于判断事件产生的性质，lpOverlapped指向重叠结构地址，可简单定义为NULL。对于串口事件的响应一般有四种方式：查询、同步I/O、异步I/O和事件驱动I/O，需要根据用户不同控制要求而定。查询方式占用较长的计算机时间，同步I/O方式直到读取完指定的字节数或超时时才返回，容易造成线程阻塞，异步I/O用于后台处理，事件驱动是由系统通知用户程序发生的事件并进行串口操作。比较而言事件驱动I/O方式较灵活。 　　当有通信事件产生时，就可用函数ReadFile()和WriteFile()直接对串口缓冲区进行读写操作了。其中lpBuffer 指向读写缓冲区，nNumberOfBytes为要读写的字节数，lpNumberOfBytes为实际读写的字节数，lpOverlapped指定同步或异步操作。通信结束后，调用函数CloseHandle()将串口关闭。 　　·应用实例说明· 
　　使用以上的API函数，笔者给出了简化后的串口初始化的实例。图1为使用C＋＋ Builder 组件生成的串口通信基本参数设置的界面实例。 　　HANDLE hcom; //定义句柄 　　DCB dcb; 　　OVERLAPPED e; //定义重叠结构 　　void -fastcall TForm1::OkBtnClick(TObject?Sender) 　　{ hcom=CreateFile("COM2",GENERIC-READ|GENERIC-WRITE,0,NULL,OPEN-EXISTING,
FILE-ATTRIBUTE-NORMAL|FILE-FLAG-OVERLAPPED,NULL); //打开通讯口 　　 BuildCommDCB("9600,O,8,1",＆dcb); //第一个字符串参数实际使用时由图1选择后组合，这里仅简单说明其格式 　　 SetCommState(hcom,＆dcb); 　　 SetupComm(hcom,512,512);//设置读写缓冲区 　　 e.hEvent=CreateEvent(NULL,false,false,NULL); //设置事件 　　 SetCommMask(hcom,EV-RXCHAR| EV-TXEMPTY); //设置事件掩码 　　 OkBtn－〉Enabled=false;} C＋＋BUILDER非可视组件的消息处理技巧 　　一个非可视的组件必须对Windows操作系统或用户定义的消息作出响应。然而，由于一个非可视组件没有窗口，因此它也没有窗口句柄，自然它也不能接收到消息,为了解决这一问题,我们的思路是创建一个隐藏的窗口，使非可视组件能够接收到消息。 　　为了给你的非可视组件创建一个隐藏的窗口，需要有以下： 　　1．一个私有变量型(Private Variable)的HWnd来取得窗口句柄。 　　2．一个用来捕捉窗口发送给组件的函数（a WndProc）。 　　3．对AllcolateHwnd的调用使之创建窗口句柄并设置WndProc。 　　为了清楚的解释上述思路和展示创建过程，下面我们将以一个具体的实例来说明。 　　首先我们先创建一个新的组件，在C＋＋Builder中，选择FILE|NEW...双击组件图标显示一个新的组件对话框改变Ancestor Type为Tcomponent和Class name为TTest并设置完毕。 　　然后，切换到新组件的头文件，在类的私有部分（private section）加入以下声明： 　　HWnd FHandle; 　　 void-fastcall WndProc (TMessage＆ Msg); 　　第一行声明了一个调用Fhandle的HWnd变量，这个变量将用于窗口创建后捕获窗口句柄。第二行声明了一个用于接收消息的WndProc函数。这个函数的声明必须加以标识，以便限定它是一个WndProc,然后在类声明Public（公有）部分构造以下声明： 　　Viod DoIt( )； 　　这个公有函数将被我们用来测试组件，类声明应如下： 　　class PACKAGE TTest : public TComponent 　　{ 　　 private: 　　 HWnd FHandle; 　　 void-fastcall WndProc (TMessage＆ Msg); 　　 protected: 　　 public: 　　 -fastcall TTest (TComponent＊ Owner); 　　 void DoIt( ); 　　 -published: 　　}; 　　现在切换到组件的代码单元，将下面一行加入到单元的顶部（在函数上也许是不错的地方） 　　＃define MY-Message.WM_USER＋1 　　这一行声明了一个在DoIt函数被调用时，组件将发送给它自己的用户自定义消息。此时我们必须为组件分配一个窗口句柄。这个句柄将提供一个隐藏的窗口使我们可以捕捉组件中的消息。找到组件构造代码，加入下面代码: 　　-fastcall Test::Test (TComponent＊ Owner) : TComponent(Owner) 　　{ 　　FHandle=AllocateHWnd (WndProc); 　　} 　　好，重要的一步已完成，AllocateHWnd函数创建了一个隐藏窗口并且返回它的句柄，注意这里我们为了使Windows知道哪里发来了消息，传递WndProc的地址； 　　现在我们来创建WndProc的函数部分。在源文件中加入: 　　void-fastcall TTest::WndProc (TMessage＆ Msg) 　　{ 　　 if (Msg.Msg == MY_MESSAGE) 　 MessageBox(0, ″Got here!″, ″Message″, 0); 　　 try { 　　 Dispatch(＆Msg); 　　 } 　　 catch (...) { 　　 Application－〉HandleException(this); 　　 } 　　} 　　无论何时Windows发送消息给组件，Windows都会调用这个函数。这部分代码完成了两件事。首先，它检查被接收的消息是否是我们用户自定义的消息。如果是，一个消息框将被显示，你可以看到实际上我们接收到的消息。其次，这段代码传送了系统（或VCL）处理过程中的消息，try/catch块用来保证，如果异常出现，它将成为缺省风格下的句柄。 　　概括地说，WndProc函数在为缺省句柄传递所有其他消息，监控了所有客户消息。现在我们创建DoIt函数，完成我们的组件，加入我们创建DoIt函数，完成我们的组件，加入代码： 　　void TTest:

oIt() 　　{ 　　PostMessage(FHandle, MY-MESSAGE, 0, 0); 　　} 　　这个函数发送一个消息组件的窗口句柄（记住，这个窗口句柄是以前存入到Fhandle数据成品中的）。现在我们已经完成了创建组件选择，用SelectFile|ColseAll来保存我们的工作测试组件。 　　下一步将测试组件。如果你使用BCB3,那么你必须把组件加入到“包”（Packege）中，然后用Componet|install(可以使用DCLSTD35 Packege来快速测试)。再选择你刚存的TestBCB.Cpp,一旦你安装完成组件后，它将出现在组件板上。双击按钮，为按钮的OnClick事件创建以下代码： 　　 Test1－〉 DoIt( ); 　　现在运行程序，当你点击按钮时，将看到一个消息框显示“Got here". 　　ListingA和B包含了头文件和源代码以下列出。 　　总结：一个可以响应Windows消息的非可视组件有许多用途。最显而易见的就是用来封装某些方面的WindowsAPI。例如：TAPI和WinSock发送消息给事件的指定用户。如果你写的组件封装了一个这样的API。你将需要捕捉Windows发送的消息。而在你的组件中加入隐藏窗口将很好的帮你做到这一点。 　　以上程序在C＋＋ BUILDER 3.0中调试通过。 用C＋＋Builder 建立数据库VCL使用经验 　　随着数据库的广泛应用，数据库编程已经成为程序设计中发展迅猛的一支。C＋＋ Builder在数据库开发方面具有的强大功能是无可比拟的，你甚至可以不写一行程序就生成漂亮的数据库程序。 　　下面对C＋＋Builder中的几个数据库VCL的使用技巧做一下介绍： 　　一、DBGrid控件 　　1.设置DBGrid的字段显示宽度属性 　　为了在DBGrid中建立较小的列，你必须建立一个显示标题，它等于或小于字段值。例如，你希望建立一个只有三个字符宽的列，你的列标题显示必须只有三个字符或更少。 　　2.改变DBGrid的显示字段及日期显示格式 　　(1)双击DBGrid对应的Table1,进入字段编辑器。 　　(2)点右键出现选单选“Add Fields…" ,出现添加字段对话框，选择要添加的字段（该字段将在运行时由DBGrid显示）然后点OK按钮。 　　(3)假设添加了“日期”字段，点该字段，在属性表中的：DisplayLabel中填入你希望DBGrid显示的字段名。如果原来字段名是英文的，这里用中文名后DBGrid将显示中文名。在DisplayFormat中填入：yyyy－mm－dd，以后日期将按1999－05－28格式显示。 　　二、Tquery控件 　　Tquery 控件是数据库编程中非常重要的一个控件，它负责通过BDE与数据库建立联系，通过SQL语句方便的建立查询。Query必须建立相应的SQL才能生效。 　　Tquery的参数设置如下： 　　(1)在SQL属性中：Select ＊ from 表名 where 字段名=:变量名 　　跟在“ : "后面的是变量。这样写后，在参数属性中就可以修改该变量的数据类型等。 　　(2)对变量的赋值： 　　 Query1－〉Active=false; 　　 Query1－〉Params－〉Items[0]－〉AsString=Edit1－〉Text; 　　 Query1－〉Active=true;//查找符合变量的记录 　　(3)用DBGrid显示结果 　　DBGrid的DataSource与DataSource1连接，而DataSource1的DataSet与Tquery1 连接。 　　三、应用示例 　　通过Query控件嵌入SQL语句建立的查询比Table更简单、更高效。 　　用一个简单的代码来说明如何建立查询程序： 　　例如，要建立一个检索表1中书名为book1的程序则在表单上放置DBGrid,DataSource,Query三个控件加入以下代码： 　　DBGrid1－〉DataSource=DataSource1; 　　DataSource1－〉DataSet=Tqery1; 　　Query1－〉Close(); 　　Query1－〉SQL－〉Clear(); 　　Query1－〉SQL－〉Add(″Select ＊ From 表 Where (书名=′book1′ ″); 　　Query1－〉ExecSQL(); 　　Query－〉Active=true; 　　你就可以在生成的表格中看到所有名称为book1的记录。 用C++ Builder创建基于Internet的点对点Chat ---- 创建基于Internet的应用程序，你也许会想到复杂的WinSock编程。不过，C++ Builder3提供了新的WebBroker的Internet套件，其中的TClientSocket和TServerSocket组件封装了Windows的有关API，大大简化了WinSock编程。要通过Internet传输数据，至少需要一对Socket，一个Socket在客户端，另一个Socket在服务器端。其实TClientSocket、TServerSocket组件并不是Socket对象，其属性Socket将返回各自的Socket对象。TClientSocket用来处理客户端到服务器端之间的socket连接，TServerSocket用来处理由客户端发来的socket连接，一旦客户端和服务器端都接通了socket，客户端和服务器端就可以相互通信了。 ---- 建立一新项目，创建应用程序的用户界面： ---- 1.将组件页切换到Internet页，放一个TServerSocket组件和一个TClientSocket组件到窗体上，这样应用程序既可以是TCP/IP服务器，也可以是TCP/IP客户。将Port属性都设为同一个值(如1000)，确定Socket之间的连接类型为NonBlocking(非阻塞方式)。 ---- 2.放两个TMemo组件到窗体上，用来分别显示双方的谈话内容，将Memo2的ReadOnly属性设为True。 ---- 3.在窗体的顶部放上一个Panel组件，在其上放三个按钮：监听(btnlisten)、连接(btnconnect)、断开(btndisconnect)，用来启动相应的操作。 ---- 4.在窗体底部放一个StatusBar组件，将其SimplePanel属性设为True,在相应的事件处理程序中改变状态条信息，让用户随时了解连接状态。 ---- 打开头文件，在窗体类的Private段添加两个私有成员: bool IsServer;String Server。双方通信时需同时运行Chat程序，IsServer用来确定哪个Chat程序处于服务器端，Server用来存放服务器的主机名。建立窗体类的构造器如下： __fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
IsServer=false;
Server="localhost";
} 
---- 这里Server被缺省设为localhost，这样程序可以在没有连入Internet的单机上进行调试。在Windows子目录下你可以找到hosts.sam文件中，在该文件中已经将本机IP地址127.0.0.1定义了主机名：localhost。
void __fastcall TForm1::FormCreate(TObject *Sender)
{
btndisconnect- >Enabled=false;
} ---- 程序运行后，如果用户按下＂监听＂钮，则将该程序设为服务器端，这时应将TServerSocket的Active属性设为True，使服务器自动进入监听状态。
void __fastcall TForm1::btnlistenClick(TObject *Sender)
{
ClientSocket1- >Active=false;
ServerSocket1- >Active=true;
StatusBar1- >SimpleText="正在监听...";
btnlisten- >Enabled=false;
btnconnect- >Enabled=false;
} ---- 当用户按下＂连接＂钮后，程序会弹出一个询问框，要求用户输入要连接的服务器的主机名，然后建立连接。
void __fastcall TForm1::btnconnectClick(TObject *Sender)
{
if(InputQuery("连接到服务器","输入服务器地址:",Server)){
if(Server.Length() >0){
ClientSocket1- >Host=Server;
ClientSocket1- >Active=true;
btnlisten- >Enabled=false;
btnconnect- >Enabled=false;
btndisconnect- >Enabled=true;
}
}
} 
---- 当用户提出连接请求后，客户端会触发OnCreate事件，程序先在状态条中显示连接信息，然后将显示对方谈话内容的Memo2清空，准备开始交谈。
void __fastcall TForm1::ClientSocket1Connect(TObject *Sender,
TCustomWinSocket *Socket)
{
StatusBar1- >SimpleText="连接到:"+Server;
Memo2- >Lines- >Clear();
} 
---- 在服务器接受了客户的请求后会触发OnAccept事件，在这个事件处理程序中将标志服务器端的变量IsServer设为True，并准备开始交谈。
void __fastcall TForm1::ServerSocket1Accept(
TObject *Sender,
TCustomWinSocket *Socket)
{
Memo2- >Lines- >Clear();
IsServer=true;
StatusBar1- >SimpleText="连接到:"
+Socket- >RemoteAddress;
} 
---- 在建立连接后，双方就可以在Memo1中输入谈话内容开始进行交谈了，按下Enter键后，将所在行的文本发送出去。服务器端的Socket的Connections属性返回一个数组，该数组由服务器当前活动的连接组成。
void __fastcall TForm1::Memo1KeyDown(
TObject *Sender, WORD &Key,
TShiftState Shift)
{
if(Key==VK_RETURN){
if(IsServer)
ServerSocket1- >Socket- >Connections[0]- >SendText(
Memo1- >Lines- >Strings[Memo1- >Lines- >Count-1]);
else
ClientSocket1- >Socket- >SendText(
Memo1- >Lines- >Strings[Memo1- >Lines- >Count-1]);
}
} 
---- 在本例中我们采用非阻塞传输方式，当其中的一方进行写操作时，另一方会触发OnRead事件(客户端)或OnClientRead事件(服务器端)，这两个事件的处理程序只是将接收到的内容添加到Memo2的后面。
Memo2- >Lines- >Add(Socket- >ReceiveText()); ---- 如果在用户建立连接后单击＂断开＂钮，将断开客户端与服务器的连接，服务器端将触发OnClientDisconnect事件，而客户端则会触发OnDisconnect事件，这时服务器端应回到监听状态，等待用户的连接；而客户端将返回到连接前的状态，等待用户再次建立连接，如果有不止一个服务器的话，可以选择连接到其他的服务器上。
void __fastcall TForm1::btndisconnectClick(
TObject *Sender)
{
ClientSocket1- >Close();
}
void __fastcall TForm1::ServerSocket1ClientDisconnect(
TObject *Sender,
TCustomWinSocket *Socket)
{
StatusBar1- >SimpleText="正在监听...";
}
void __fastcall TForm1::ClientSocket1Disconnect(
TObject *Sender, TCustomWinSocket *Socket)
{
btnlisten- >Enabled=true;
btnconnect- >Enabled=true;
btndisconnect- >Enabled=false;
StatusBar1- >SimpleText="";
} 
---- 此外在客户端还应该增加错误捕获机制，当用户输入无效的服务器名或服务器端没有处于监听状态时能够及时给用户反馈信息。
void __fastcall TForm1::ClientSocke
t1Error(TObject *Sender,
TCustomWinSocket *Socket,
TErrorEvent ErrorEvent, int &ErrorCode)
{
StatusBar1- >SimpleText="无法连接到:
"+Socket- >RemoteHost;
ErrorCode=0;
} 用C++Builder获取应用程序图标 现在，网上有大量的有关图标的共享软件或免费软件，而且很多也很好用，也方便。但是那毕竟是别人的，用起来总有些哪个，况且自己又喜欢编程，何不自己动手呢！说干就干，而且手头上有可视化编成的利器――Ｃ++Builder4.0，想来应该是很简单的一件事。 首先启动C++Builder，新建一工程，在窗体上放置一个Button控件，一个Image控件，和一个OpenDialog控件，它们的名称均不必改动。双击Button控件，写如下代码： if(OpenDialog1->Execute()) { FileName = OpenDialog1->FileName; HICON hIcon; // Total =(int) ExtractIcon( Form1->Handle, FileName.c_str(), -1); 　 Icon = new TIcon(); hIcon = ExtractIcon( Form1->Handle, FileName.c_str(), 0); Icon->Handle=hIcon; 　 Icon->SaveToFile(TempFile); Image1->Picture->LoadFromFile(TempFile); } 其中：FileName,TempFile,Icon在其头文件中定义：AnsiString　　TempFile, FileName ; Ticon *Icon; 这样，你所选定的程序的第一个图标就在Image控件中显示了出来。本程序所用的是Windows API ExtractIcon来获取图表的，因此它只能获取可执行文件的图标，如果想获取任意文件的图标，那末你可以调用Windows API 的SHGetFileInfo函数来完成，SHGetFileInfo所能完成的任务有很多，具体用法可参见Win32的帮助文件。 
BIG5到GB的转换技术 中文因为数量太多，所以与英文用ASCII码一个字节表示不同，它使用两个字节来表示。通过计算这两个字节，我们可以得到其表示的汉字在中文字库中的位置。读取该位置的若干字节，以获得表示这个汉字的点阵信息。有了这些信息，就可以分别在DOS或WINDOWS中显示该汉字。事实上，在文本文件中保存的就是每个汉字对应的两个字节编码，而显示问题由中文操作系统自动解决。
汉字编码并不统一，我们使用的是GB码，而台湾地区使用的是BIG5码。BIG5码文件中保存的是汉字相应的BIG5编码，GB码文件中保存的是汉字相应的GB编码（这也就是“乱码现象”的来由）。所以转换工作的关键是有一个记录每个BIG5编码对应GB编码的码表文件。
第一步制作码表文件
BIG5码编码规则是这样的：每个汉字由两个字节构成，第一个字节的范围从0X81－0XFE，共126种。第二个字节的范围分别为0X40－0X7E，0XA1－0XFE，共157种。也就是说，利用这两个字节共可定义出 126 * 157＝19782种汉字。这些汉字的一部分是我们常用到的，如一、丁，这些字我们称为常用字，其BIG5码的范围为0XA440－0XC671，共5401个。较不常用的字，如滥、调，我们称为次常用字，范围为 0XC940－0XF9FE，共7652个，剩下的便是一些特殊字符。
制作码表文件的原理是这样的：首先将所有的BIG5编码写入一个文件，然后，使用具有BIG5码到GB码转换功能的软件，如地球村、东方快车、四通利方，将文件转换为GB码文件，即得到码表文件。
下面的源程序将所有可能的BIG5编码（0XA100－0XFEFF）写入文件“Table.TXT”。
//TURBO C++ 3.0
#include <Stdio.h>
#include <stdlib.h>
void main(){
FILE * codefile;
int i,j,k;
codefile=fopen("table.txt","w+b");
for (i=0xa1;i<=0xfe;I++){
for(j=0x00;j<=0xff;j++){
fwrite(& i,1,1,codefile);
fwrite(& j,1,1,codefile);}
}
fclose(codefile);
return;
}
运行地球村、东方快车或四通利方，将“Table.txt”从BIG5码转换为GB码，即获得码表文件。
第二步转换
下面的源程序，将BIG5码文件转换为GB码文件。
//TURBO C++3.0
#include <stdio.h>
#include <stdlib.h>
void main(){
int que, wei;
FILE * sourcefile;
FILE * tabfile;
FILE * destfile;
sourcefile = fopen("big.txt', "r+b");
//BIG5 码文件
tabfile = fopen("table.txt", 'r+b");
//码表文件
destfile = fopen("gb.txt","w+b");
//转换生成的GB码文件
while (!feof(sourcefile)){
fread(& que,1,1,sourcefile);
if (feof(sourcefile)){
break; }
if (que> =0xa1 && que <=0xfe)
//叛断是否汉字（BIG5编码）
{fread(& wei,1,1,sourcefile);
if (wei<0xa1) wei = wei - 0x40;
if (wei>=0xa1) wei = wei - 0xa1 + 0x7e - 0x40 + 1;
fseek(tabfile, 2 * ((que -0xa1) * (0xfe - 0xa1 + 1 + 0x7e - 0x40 + 1 ) + wei), SEEK_SET);
fread(& que,1,1,tabfile);
fread(& wei,1,1,tabfile);
fwrite(& que,1,1,destfile);
fwrite(& wei,1,1,destfile);
}
else
fwrite(& que,1,1,destfile); //处理英文
}
fclose(sourcefile);
fclose(tabfile);
fclose(destfile);
return;
}
以上程序在Win95/97，TC3.0 通过。稍加修改，也可用于VC或VB程序中。用同样的方法，我们也可以将GB码转换为BIG5码。 C++BUILDER让你的任务栏图标动起来 ---- 在windows环境下上网时，你有没有注意到在屏幕的右下脚的任务栏上有一个动画图标呢？它一闪一闪的，形象的表示出网络此时正在传输数据。关于任务栏图标编程的文章有不少，可是如何才能编制出动态图标呢？在C++Builder中可以比较方便的实现。 ---- 其基本编程思路是：通过设置Timer时钟控件使应用程序在规定的时间间隔内发送特定的消息，使任务栏图标不断更改，从而形成动画效果。实现方法为在应用程序的表单中加载几个Image控件，使他们装载相应的图画，几幅图画按顺序连续的被显示，就形成了动画。 ---- 在这里，我们用一个门的开关动画来做例子，在表单上放置一个Timer控件，两个Image，分别装载“开门”和“关门”两幅图。开始加入代码。 ---- 应用程序必须用发送消息的办法通知任务栏增加，删除,和修改图标。发送消息必须调用Shell_NotifyIcon。它的原形为： WINSHELLAPI BOLL WINAPI Shell_NotifyIcon(
DWORD dwMessage, POINTIFYCONDATA pnid); 第一个参数 dwMessage是发送消息的标志，可以选
NIM_ADD // 往任务栏通知区添加图标
NIM_DELETE //往任务栏通知区删除图标
NIM_MODIFY //通知任务栏通知区修改图标 编制消息发送函数TrayMessage
bool __fastcall TForm1::TrayMessage(DWORD dwMessage)
{
NOTIFYICONDATA tnd;
PSTR pszTip;
pszTip = TipText();
tnd.cbSize= sizeof(NOTIFYICONDATA);
//结构的大小
tnd.uCallbackMessage = MYWM_NOTIFY;
//自定义回调消息，在头文件中声明
tnd.hWnd= Handle;
//接受回调消息的窗口句柄
tnd.uID = IDC_MYICON;
//图标标志号
tnd.uFlags= NIF_MESSAGE | NIF_ICON | NIF_TIP；
//指定以下三个参数哪个包含有效数据
if (dwMessage == NIM_MODIFY)
{
tnd.hIcon =
(HICON)IconHandle(); //取得图标句柄
if (pszTip)
lstrcpyn(tnd.szTip, pszTip,
sizeof(tnd.szTip));
else
tnd.szTip[0] = '\0';
}
else
{
tnd.hIcon = NULL;
tnd.szTip[0] = '\0';
}
return (Shell_NotifyIcon(dwMessage, &tnd));
}
编制取得图标句柄的函数
HICON __fastcall TForm1::IconHandle(void)
{
if (n==1)
{ return (Image1- >Picture->Icon- >Handle);
//n是全局变量，1为显示Image1,0为Image2
}
else
{ return (Image2- >Picture- >Icon- >Handle);
}
}
编制图标状态转换函数 void __fastcall TForm1::ToggleState(void)
{
if (n==1) //n为图标句柄锁，是全局变量，
1为显示Image1,0为Image2
{
n=n-1;
}
else
{
n=n+1;
}
TrayMessage(NIM_MODIFY);
//发送图标变换消息
} 
对Timer控件编制代码，设它的Interval
属性为1000，即定时器每一秒响应一次。为 Ontimer
事件键入代码： void __fastcall TForm1::Timer1Timer(TObject *Sender)
{ ToggleState( );
} ---- 由于篇幅有限，以上只列出了基本部分的代码，其他功能的实现，如关闭程序，打开窗口等，比较简单，不在赘述。程序运行时，你将看到在屏幕的右下角任务栏有一扇门打开又关闭的动画图标。是不是很有趣，快编一个你喜欢的吧。 TFORM 
一、让窗口总是在最前面
Form 的FormStyle属性设置为fsStayOnTop值。 二、动态调用窗体Form
在缺省情况下，由File/New Form 生成添加入项目文件中的窗体都具有"Auto Create"（自动创建）的特性。即只要程序运行，该窗体就存在于内存中了，不管当前它是否被调用。具有这种特性的窗体一般适用于窗体属性比较固定、经常被调用的情况。其优点是速度快，缺点是占用内存。在实际程序设计中，会遇见大量类似对话框功能的窗体，它们用于显示状态或输入信息，仅须在程序中调用一下，完成其功能就行了，无需常驻内存。这时可以通过选择Project/Options/Forms，将"Auto--Create forms " 栏中相应的窗体, 如Form1，用" >" 键移动到 "Available forms" 栏中，并在程序需调用该窗体处，加入下列语句： TForm1 *myform=new TForm1(this); myform- >ShowModal(); delete myform; 窗体Form1 仅是在需要调用时才调入内存，调用完成后，即用delete 清除出内存。这样可减少程序对内存资源的占用。 三、遍历窗体控件的方法
要访问或修改窗体上的控件，方法很简单，以TEdit 为例子： Edit1- >Text=""; Edit2- >Text=""; 但如果窗体上有十来个像Edit1 这样的控件，需要进行相同的初始化，用上面的方法一个一个地进行，岂不麻烦！所以有必要掌握遍历窗体控件的方法。在介绍该方法之前，让我们先了解一下窗体Form 的Components 和Controls 属性。参见表一。
表一 属性类型说明 ComponentCount Int 目前Form上各类
控件的总数 Components TCompont* 目前Form上指向
所有控件的数组 目前Form上指向
所有控件的数组
ControlCount
Int
目前Form上某一子
区域上各类控件的总数
Controls TControl* 目前Form上指向某一子
区域上所有控件的数组 
以图一为例（图略）说明，Form1 的ComponentCount=6, 而Panel1 的ControlCount=4.， 其中：数组对象 Components[0] Panel1 Components[1] Label1 Components[2] Edit1 Components[3] Label2 Components[4] Edit2 Components[5] Button1 
数组对象 Controls[0] Label1 Controls[1] Edit1 Controls[2] Label2 Controls[3] Edit2 
下面这段代码完成了对Panel1 上所有TEdit 控件的遍历初始化。读者稍加修改，即可对其它控件进行遍历。这里有一个小技巧，我们把需要进行初始化的控件放置在了一Panel1 上，与不需要初始化的控件区分开来，这样便于编程。
AnsiString namestring="TEdit";
for(int i=1;i< Panel1- > ControlCount;i++)
{
if(Panel1- > Controls- > ClassNameIs(namestring)) { TEdit *p=dynamic_cast < TEdit* > (Panel1- >Controls); P- >Text=""; }
: [! p& D5 v" r0 } T} 四、不规则窗口 1.在窗口定义中,加入HRGN hWndRgn;
2 ~; k5 g' ]& I/ s! ?' l+ t2.在TForm::OnCreate()消息函数最后,加入下面的代码: % i: A9 n+ {% F. y* Q) X& w- B
hWndRgn=::CreateEllipticRgn(0,0,Width,Height); ' M0 M- M8 i0 E o; h
::SetWindowRgn(hWndRgn,TRUE); 9 O' U3 Y- v: O1 J/ k" A& r a
3.设置TForm的属性为无标题，无边框。
/ ]1 X3 B, A1 E4.编译连接应用程序,就可以看到一个椭圆形窗口。 五、MDI Form 1.Application->CreateForm(__classid(Tjjcginput), &jjcginput); 后不用在使用显示Form的语句就可以显示出来了。 2.form 的onclose 事件必须用下面语句释放空间：
* l( N- L/ O. B- \void __fastcall TMDIChild::FormClose(TObject *Sender, TCloseAction &Action) : S( O8 Z! h0 R" H0 m
{
' Y0 H) [* f7 }Action = caFree;
1 T, N4 F7 G0 T9 [% y} 用BCB在windows桌面创建快捷方式 API提供了一个叫做IShellLink的COM接口允许我们创建快捷方式。为在桌面创建快捷方式，我们创建一个IShellLink对象，设置它的属性，然后把这个link保存到desktop目录。 下面的例子代码演示了怎样创建一个快捷方式。在这个例子里，这个快捷方式保存在C:\Drive目录下。 //---------------------------------------------------------------------- 8 h; |9 a- X, u3 J
include <shlobj.h> void __fastcall TForm1::Button1Click(TObject *Sender) - `# ~7 k% ^1 D. V
{ 3 V( U7 b+ |' c2 d8 h9 v: X" `- _
if(OpenDialog1->Execute()) 0 C# N0 o& a* B2 A
CreateShortCut(OpenDialog1->FileName);
 E$ g2 L1 J. N, I}
( I) q, \, B+ B1 ^- u2 D//---------------------------------------------------------------------- 5 p4 `* s7 H1 w3 g t' x2 J* K
void TForm1::CreateShortCut(const AnsiString &file)
/ m3 k0 Z4 E5 ?% g7 p. z% Y9 v; H{
" ^9 l1 q& b5 v( j2 UIShellLink* pLink; - L8 } p/ z9 E4 ?9 i
IPersistFile* pPersistFile;
' u! {8 U( Q. @8 I+ X9 [if(SUCCEEDED(CoInitialize(NULL))) 6 [1 F: H+ V7 a/ n
{
! h* y; h5 ]8 V$ m* pif(SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL,
9 [$ P" r+ y2 Y' gCLSCTX_INPROC_SERVER,
" x( z( d2 b2 a2 \# L. \IID_IShellLink, (void **) &pLink))) 8 v* G" d7 O; N4 s: @
{
& b# r0 E i9 ` D! R) kpLink->SetPath(file.c_str());
5 Q6 t( O7 X1 M& d/ e% |pLink->SetDescription("Woo hoo, look at Homer's shortcut");
# F! D6 O$ s* ^* K' ]+ a" {pLink->SetShowCmd(SW_SHOW);
$ P# [# [6 O8 A L, q+ A2 aif(SUCCEEDED(pLink->QueryInterface(IID_IPersistFile,
( x/ g- I6 |, X3 w* X0 I6 M3 U(void **)&pPersistFile))) 4 x7 ^) W3 n/ w+ j
{ ; `- y* d$ e! p% P @( k
WideString strShortCutLocation("C:\\bcbshortcut.lnk");
 |5 R' l& K) z5 B/ ~7 vpPersistFile->Save(strShortCutLocation.c_bstr(), TRUE); # X0 y( ?3 ^; F) H' g. m
pPersistFile->Release();
% W0 q- J- i) c! U} / G" z$ Q! N# [" C. P8 ?3 q
pLink->Release(); * o0 \7 K$ {" W+ d
} CoUninitialize();
/ y' U' \1 Z* d! _4 L}
9 C, `; {! f f' ?4 l, P} 3 i6 E. p: f- K4 }. j6 V
//---------------------------------------------------------------------- 7 j# ~$ F) V0 @9 U5 O3 V, N4 d
上面的例子只是把快捷方式文件保存到了c:\drive目录下，但没保存到desktop目录下。 要让快捷方式出现在桌面上，只须把快捷方式文件保存到desktop目录下。首先我们要找到windows的desktop目录，请参阅判断windows的Desktop及相关目录这一节。一旦我们知道了desktop所在的目录，我们就能将快捷方式文件保存到desktop目录下。然后windows就能将快捷方式图标显示到桌面上。下面是经过改进了的例子： //---------------------------------------------------------------------- * a4 `9 a4 d; [
void TForm1::CreateShortCut(const AnsiString &file)
7 ?' j! u) {9 ]1 _ \{ " s9 i1 O+ A% C7 r! p/ }
IShellLink* pLink; $ o- z6 e# i# V$ F% \, ]# U
IPersistFile* pPersistFile; 9 E; @0 O9 @7 M1 ]
LPMALLOC ShellMalloc;
 L' c+ T/ M! N( Z4 BLPITEMIDLIST DesktopPidl;
0 z" J+ A U. E2 Y; v0 bchar DesktopDir[MAX_PATH]; if(FAILED(SHGetMalloc(&ShellMalloc)))
5 j, J( X/ k5 H+ a1 J- I ireturn; if(FAILED(SHGetSpecialFolderLocation(NULL, ) x6 v. K: t! |0 `: ^2 K) Y4 B h
CSIDL_DESKTOPDIRECTORY,
8 {. W7 M4 ~0 D+ p% \$ w2 B&DesktopPidl)))
: H' f# c/ `6 P8 |3 X* _3 ureturn; if(!SHGetPathFromIDList(DesktopPidl, DesktopDir))
8 O y) Q; `0 O/ Q4 _* U9 O{
3 d' K4 y8 R! }0 A- M$ Y5 zShellMalloc->Free(DesktopPidl); + ^, q% I% ?+ O6 b- s/ \
ShellMalloc->Release(); + e( I8 r+ g7 `2 y- |- E2 K
return;
+ T0 T" z. \" J5 V} ShellMalloc->Free(DesktopPidl);
. j, v! D2 d/ w6 yShellMalloc->Release(); if(SUCCEEDED(CoInitialize(NULL)))
( [- a6 j" B: ]: R6 C8 V- s2 K) M3 a{ $ R- H0 @6 y% g2 X( A% q! w
if(SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL, ; _. X9 ], a; i. _7 C2 d) @
CLSCTX_INPROC_SERVER,
' U0 E. p$ O/ ]IID_IShellLink, (void **) &pLink))) ( E4 @7 J: L* s4 h$ K" t: T
{
( e, H4 x9 {4 x$ J' ZpLink->SetPath(file.c_str()); ; ]/ }8 }: j1 |: Z! p \
pLink->SetDescription("Woo hoo, look at Homer's shortcut");
# q. O* U# N# w& dpLink->SetShowCmd(SW_SHOW); if(SUCCEEDED(pLink->QueryInterface(IID_IPersistFile, & i0 T" f, F8 Q2 p9 v) o1 U
(void **)&pPersistFile)))
) h: t2 k+ i6 C" s1 _0 ?- R{ WideString strShortCutLocation(DesktopDir);
: u, z( V1 C/ Y# Q) VstrShortCutLocation += "<a>\\bcbshortcut.lnk</A>";
) O1 |2 @* G9 w9 P7 apPersistFile->Save(strShortCutLocation.c_bstr(), TRUE); ; Z6 S2 S) Z- U, ~
pPersistFile->Release();
8 n8 X( o( {) i% Z% [- b}
* y4 }4 q% r0 I) H$ _9 m0 q5 opLink->Release();
7 [( O; b* T* F/ _3 x8 D6 {} 1 S6 j. r( K }) A9 v
CoUninitialize();
" j* @3 F0 _2 l; J} " U/ _+ g0 Q8 _3 B! ~/ k: k
}
& u3 Z7 }7 X. e* i$ q//---------------------------------------------------------------------- ; e: }! P/ h3 S4 h% y6 F+ k( k. _: x
不要陷于COM的泥沼之中 * A0 c' K" o% @$ b4 Z8 e0 b
创建快捷方式包括一些对COM的使用。不要让你陷入到COM的复杂之中。COM只是创建和使用对象的一种方法。在这个例子里我们可以考虑不使用COM而是用等价的C++技术。 COM code C++ psuedo-equivalent
6 |/ [+ v4 J B8 H+ H0 P5 g5 FIShellLink* pLink; TShellLink *Link;
; b3 { S% @, P% `! ZIPersistFile* pPersistFile; TPersistFile *PersistFile; CoInitialize(); 
6 D1 ~7 p7 m1 h; E: p' A, ?3 k qCoCreateInstance(CLSID_ShellLink, Link = new TShellLink;
( p5 b4 _& ^ E7 t3 ~4 h* _NULL, ' O. C$ e/ ?1 X/ y$ n! S
CLSCTX_INPROC_SERVER, 7 P3 [* ]! P; w: @0 L. Q0 z
IID_IShellLink, 1 u* w `0 R+ o1 u( h
(void **) &pLink) & q; ?9 x' j( g3 |
pLink->SetPath(file.c_str()); Link->SetPath(file.c_str()); + F3 x2 C: Z8 _
pLink->SetShowCmd(SW_SHOW); Link->SetShowCmd(SW_SHOW); 
$ U7 n6 Y* ^7 I5 C; V3 y+ FpLink->QueryInterface(IID_IPersistFile PersistFile = % K: ?: P6 J( K, o
(void **)&pPersistFile))) dynamic_cast<TPersistFile*>(Link); pPersistFile->Save("C:\\", TRUE); PersistFile->Save("C:\\"); 
/ @8 j" u o5 D$ gpPersistFile->Release(); delete PersistFile 6 R/ j5 c9 t+ K+ K* ^
pLink->Release(); delete Link; CoUninitialize(); 
 B4 g, q+ r* {读磁片磁区 8 ?* d; b, f9 {- Q$ e2 l+ p
一、以前的DOS版要读、写、格式化第0轨的第1个磁区，程式大致如下： char buffer[512]; reg.x.dx=0 ; /* for drive A *
# w- y- P3 Q! I( X1 u; F' ereg.x.cx=0x0001 /* for boot sector */
" i0 w7 V9 G3 |" u! W% v; @/ Zreg.x.bx=FP_OFF(buffer);
7 _4 v( n2 L, I |+ Csreg.es=FP_SEG(buffer);
5 K0 a: S1 {4 @& n$ Nresg.x.ax=0x0201; /* 02 for Read, 03 for Write ,05 for Format */
" g7 d4 V p* W, Z; Z4 xint86x(0x13,?,?,&sreg); 那麽在windows 下转换为呼叫 DeviceIoControl 以便格式化、读取、写入该磁轨，DIOC_REGISTERS 这struct 在套上 DOS 下 Int21对HDD或FDD 的各项参数如要格式化是Int21也是有, 但Windows下也另有提供。 l#pragma pack(push, 1)
, y- ~4 Y+ q, |- ^9 c6 e* r& jstruct DIOC_REGISTERS { ! Y' n0 F3 ]' f
DWORD reg_EBX;
- v' k6 E% X% q2 e* u" f7 k! {: q/ ZDWORD reg_EDX; 4 L& k& A; e# z' k& c8 i, R s
DWORD reg_ECX;
& p5 U; f2 u' |! Q) }# d0 pDWORD reg_EAX; 3 r7 F/ O1 _6 b+ Y! _5 [/ o3 S
DWORD reg_EDI; 2 H2 d: l/ e2 z. x8 ^
DWORD reg_ESI;
7 J# l+ Q$ o6 ?6 Q7 @2 uDWORD reg_Flags; $ @ { l3 C8 J
}; ( c4 D- f, h/ {& x) g
#pragma pack(pop) sDiskImageInfo->hDevice = ::CreateFile("<A>\\\\.\\vwin32</A>", 0, 0, NULL, 0,
2 Z2 k8 e6 k7 T! z. E9 ?FILE_FLAG_DELETE_ON_CLOSE, NULL);
 k& W6 P& z- s8 ` L% ]if( sDiskImageInfo->hDevice == INVALID_HANDLE_VALUE) # n7 h+ d" E1 u4 ^/ c Q2 Z2 Z6 ^
bRunNext = false; // Reset Floppy Disk
1 l; ?# X- p6 _: U- I( Yreg.reg_EBX = 0;
7 ^+ E) O% D+ K, areg.reg_EAX = 0x0000; // IOCTL for block devices
; P0 j- Z, o5 \% y& M4 ^5 rreg.reg_EDX = sDiskImageInfo->Driver; ! W7 p8 k: r& {5 Z' p' O
reg.reg_EDI = 0; reg.reg_ESI= 0; ) G% |$ F8 D* x
reg.reg_Flags = 0x0001; // assume error (carry flag is set) ; _( N5 c+ ^, T+ j0 l
dwResult = :eviceIoControl( sDiskImageInfo->hDevice, ' B/ J4 Y+ c) s E, j: o
VWIN32_DIOC_DOS_INT13, ! a% L! Y5 I0 ]9 Y* g
?, sizeof(DIOC_REGISTERS), ?, * k3 C$ d# x7 t$ o7 A9 J0 ^$ K
sizeof(DIOC_REGISTERS), &cb, 0); // Seek Floppy 6 K( u5 v2 n2 M! ?# {( M
reg.reg_EBX = 0;
/ ~$ _) J9 y" `/ }7 F4 treg.reg_EAX = 0x0C00; // IOCTL for block devices % l7 E; D" g; K8 L; I% S H
reg.reg_ECX = ( sDiskImageInfo->nC << 8) | sDiskImageInfo->nS; 4 e# ?, N$ j7 Y3 C) ]
reg.reg_EDX = ( sDiskImageInfo->nH << 8) | sDiskImageInfo->Driver; 4 L2 E9 K' w2 Q$ W; A2 G
reg.reg_EDI = 0; 9 B4 \* ?7 ~# U/ k/ L
reg.reg_ESI= 0; 6 B3 F. Q9 d1 p
reg.reg_Flags = 0x0001; // assume error (carry flag is set)
) ?5 `9 G/ u- f1 }7 h$ m; p: @0 p3 RdwResult = :eviceIoControl( sDiskImageInfo->hDevice,
 N! { O+ f! f3 C; ~VWIN32_DIOC_DOS_INT13,
* s7 {- I7 n/ b9 c0 S?, sizeof(DIOC_REGISTERS), ?, / y3 X; t# }0 E i% G7 ?, z- e$ j4 Y
sizeof(DIOC_REGISTERS), &cb, 0); // Read Floppy
" w% e" {5 E% x7 jR_CreateDiskImageFile: 9 ~0 `9 h, s; P/ a; d
reg.reg_EBX = 0;
8 _1 {* ~# a3 a( u4 T8 i0 |reg.reg_EAX = 0x0200 | 0x01; // IOCTL for block devices
# | i& P. x; y$ s+ Y1 Z+ `' \reg.reg_ECX = ( sDiskImageInfo->nC << 8) | sDiskImageInfo->nS;
5 `0 \- N: u, C* i# c4 lreg.reg_EDX = ( sDiskImageInfo->nH << 8) | sDiskImageInfo->Driver;
* W& `% |& p6 e0 k8 C$ Z greg.reg_EBX = (DWORD) &m_Buf;
/ ^- l+ X; e9 ?+ F# D5 i+ jreg.reg_EDI = 0; - X( b5 t; _7 k; Z. z& \
reg.reg_ESI= 0;
6 U- Z4 }* d' }, V# W* _$ F8 {/ nreg.reg_Flags = 0x0001; // assume error (carry flag is set) + }* M# n5 }, w, s$ \
dwResult = :eviceIoControl( hDevice, VWIN32_DIOC_DOS_INT13,
% U' \0 f6 v, ?& {# x?, sizeof(DIOC_REGISTERS), ?,
3 B8 P. s) Z- asizeof(DIOC_REGISTERS), &cb, 0); % c5 v( C0 {6 Z' q& y/ f) S: c
if (!dwResult || (reg.reg_Flags & 0x0001))
% E3 |. r2 L3 X' B) R+ O7 p{ ! r Z S) C3 p% a: e- j0 Q8 D
} I/O 端口读写的实现 
# F: R! Z9 |( T8 l细心的读者会发现，C++ Builder 不再支持如inportb()、outportb() 一类I/O 端口读写指令了。准确地说，在Windows 环境下，Borland C++ 仅支持16 位应用程序的端口操作，对32 位应用程序的端口操作不再支持, 而C++ Builder 开发出来的程序是32 位的。我个人以为，这是C++ Builder 设计者的败笔。因为PC 机中，I/O 地址空间与内存地址空间从来都是各自独立的。看看Delphi，不就通过Port 数组实现了对I/O 端口的访问了吗？搞不清楚为什么C++ Builder 就没有提供类似的机制？下面这几个函数是笔者从网上淘下来的，经过验证，在Windows95 环境下，的确可实现对I/O 端口的读写。读者可以借鉴使用。 + v- i6 @2 r) t$ R, w1 u( i
void outportb(unsigned short int port, unsigned char value) { // mov edx, *(&port); __emit__(0x8b, 0x95, &port); // mov al, *(&value); __emit__(0x8a, 0x85, &value); // out dx, al; __emit__(0x66, 0xee); } void outportw(unsigned short int port, unsigned short int value) { // mov edx, *(&port); __emit__(0x8b, 0x95, &port); // mov ax, *(&value); __emit__(0x66, 0x8b, 0x85, &value); // out dx, ax; __emit__(0xef); } unsigned char inportb(unsigned short int port) { unsigned char value; // mov edx, *(&port); __emit__(0x8b, 0x95, &port); // in al, dx; __emit__(0x66, 0xec); // mov *(&value), al; __emit__(0x88, 0x85, &value); return value; } unsigned short int inportw(unsigned short int port) { unsigned short int value; // mov edx, *(&port); __emit__(0x8b, 0x95, &port); // in ax, dx __emit__(0xed); // mov *(&value), ax __emit__(0x66, 0x89, 0x85, &value); return value; } & ~* E1 ~8 ^: j% m
检测鼠标位置 例如，通过一个定时器Timer1的触发事件源来检测鼠标位置 void __fastcall TForm1::Timer1Timer(TObject *Sender) { TPoint pt; GetCursorPos(&pt); Label1->Caption = "(" +IntToStr(pt.x) +")(" +IntToStr(pt.y) +")"; ｝ 令Win32 应用程序跳入系统零层 0 d F& ]- T1 r
众所周知，在Windows95/98 的Win32 on Intel x86 体系中利用了处理器的三环保护模型中的零环（Ring0，最高权限级别）和三环（Ring3，最低权限级别）。一般应用程序都运行在Ring3 下，受到严格的" 保护"，只能规矩地使用Win32API。如果我们想进行一些系统级的操作，例如在嵌入汇编中使用诸如"Mov EAX，CR0"，或像在DOS 下那样调用一些必不可少的系统服务（如BIOS，DPMI 服务）而用"Int xx"，都会导致" 非法操作"。但这种能力有时是必不可少的，一到这种时候Microsoft 就 " 建议编写一个VxD"。VxD 大家早有所闻了，在VxD 里，不但可以执行CPU 的所有指令，而且可以调用VMM( 虚拟机管理器）和其他VxD 提供的上千个系统级服务。获得这一能力的最本质原因在于它运行在Ring0，与系统内核同一级别。但是它体系的复杂性、开发工具的不易获得、帮助文档的不完备，使Microsoft 排除了一大批程序员和竞争对手。而将在Windows2000（Windows98 也开始支持）中取代VxD 的WDM 对Win95 程序员也是个噩梦，它需要了解Windows NT 核心驱动模型。 ----有没有简单一些的办法呢？我们可以令一个普通Win32 应用程序运行在Ring0 下，从而获得VxD 的能力吗？答案是肯定的。下面我们就简述一下这一技巧，有关Intel x86 保护模式的基础知识请大家看有关书籍。 ----首先此技巧基于以下理论根据： ----一、SIDT 指令（将中断描述符表寄存器 IDTR －－64 位宽，16 ～47Bit 存有中断描述符表IDT 基地址－－的内容存入指定地址单元）不是特权指令，就是说我们可以在Ring3 下执行该指令，获得IDT 的基地址，从而修改IDT，增加一个中断门安置我们的中断服务，一旦Ring3 程序中产生此中断，VMM 就会调用此中断服务程序，而此中断服务程序就运行在Ring0 下了。这一点与在DOS 下非常相似。 ----二、Windows95 Win32 应用程序运行一个映射到全部4G 内存的段中，选择子为0137h，Ring0 中的VxD 运行在另一个映射到全部4G 内存的段中，选择子028h，这两个段除了选择子决定的访问权限不同外，没什么不同，各自段中相同的偏移量对应了相同的线性地址。所以我们放在Win32 应用程序中的中断服务程序可以以Ring3 的段偏移量被Ring0 中的VMM 寻址。 ----下面我们以具体例子进一步说明，程序中有详细注释。 ----这是一个Win32 Console Program（控制台应用程序），虽然运行中看起来很像DOS 筐中运行的实模式DOS 程序，但它是货真价实的运行在Ring3 下的Win32 程序。用Visual C ＋＋ 5.0 AppWizard 创建一个Win32 Console Program 项目, 添加以下.CPP 文件, 编译即可。 ＃include
! h4 E9 \9 M& L( o! O＃include 3 D- ?6 q9 s+ B- D' G5 g
＃include 7 D! q% u, q1 j1 b& m
＃include ) Z; ^ J# q3 f9 W
// 若无DDK 带下划线的可略去， ) u8 @ ?3 U5 A) i
这些语句演示了调用VMM/VXD 服务
% p8 N) P! Z/ g% gDWORDLONG IDTR,SavedGate; 9 @% X! V5 Z: p0 h
WORD OurGate[4]={0,0x0028,0xee00,0x0000}; + `1 N" l( q8 s" X9 r% B7 ]
// 中断门描述符格式如下： - Q/ a+ E# ], S
DWORD _eax,_ecx,_cr0;
. @. C& L& I5 ]WORD vmmver;
! {. \8 B% t5 jHVM sysvm; void nothing()
' e ?( g4 S6 e' ]/ L- D; w{
4 G3 K# C2 g% A//Used to test call in Ring0 5 T6 B- B6 ?% e
sysvm=Get_Sys_VM_Handle(); % ~8 f4 H( J3 i j3 D2 X
} void __declspec( naked ) Ring0Proc(void) $ Q+ g/ |) g) x3 Z- l
// 中断例程，运行在Ring0
; P- D, U! f, c0 L! @& j{ . V* b6 U: U3 j( b: u
_asm{ ! B* ~; \: E% s7 D1 s; F, V
mov _eax,eax //
" y+ \& @7 @: Zmov _ecx,ecx // : k$ j/ _# \& z$ }% L+ J0 R
mov eax, CR0
% Y5 L5 x- \7 v% z- v: H% x// 测试Ring3 中不能执行的特权指令
" |6 S3 j$ ]9 Q+ H% Y) O+ hmov _cr0,eax // - \6 n& H% t: n& f
}
. l5 O1 d, h$ H [VMMCall(Get_VMM_Version);
0 u% `/ D9 J+ N! e' {7 l// 调用VMM 服务 * s' H- V4 [1 S+ n/ W, j
_asm{ . n; U( }2 J# t& L0 O1 W
mov vmmver,ax Z, m- j# q3 K/ k* u
}
- C$ S0 [% n6 n+ k ~1 R, x3 Bnothing(); 0 K9 L& J) w4 c3 _+ x! Q
// 测试在运行于Ring0 的 9 A4 C4 W$ L. P% g. c: G7 u
中断例程中调用子
) }" ]( C0 [6 Z+ ~) g　　 _asm iretd ( u2 I B$ ]* R2 [$ Y6 G I; W
// 中断返回, 与在实模式
' v0 c9 ~' K& V/ |. `: ?1 M/ }1 M编程无本质区别
0 b8 I3 ` Z2 A} . T9 _. S( e/ X8 R( t
void main() // 主程序 . m8 e5 ?+ k* `' e
{
) ?- d. z7 o- q- |& f1 V2 }_asm{
3 P7 F' ~, O) h3 b8 ]7 M9 r6 J1 Smov eax, offset Ring0Proc
& T" p3 R2 f( ^0 ~3 Hmov [OurGate], ax // 将中断函数的地址
8 ?# a8 y; F& v/ Q2 }% N! eshr eax, 16 // 填入新造的中断门 ) n% s+ f, A% m- i$ l1 y+ r
mov [OurGate ＋6], ax // 描述符 sidt fword ptr IDTR
2 M! y) @5 f3 q// 将中断描述符表寄存器（IDTR）
6 j8 o7 ]) E* f' R1 i" \! E3 e的内容取出
* d A3 j# o$ G* P6 D8 Xmov ebx, dword ptr [IDTR ＋2] 7 P2 ?; e! T0 M5 t, s' e
// 取出中断描述符表（IDT）基地址 5 U* ?% L# Z/ B( P
add ebx, 8 ＊9 * @+ C: o: n0 q. X
// 计算Int 9 的描述符应放置的地址选用
; } C' `+ v' j" j+ \4 wInt9 是因为它在Win32 保护模式下未占用 mov edi, offset SavedGate
# j( i- N4 y7 D9 p/ Smov esi, ebx
6 @2 L) A) R( W# ~movsd // 保存原来的Int 9 描述符到 3 Q$ n- a4 ]% d, T! M
movsd //SavedGate 以便恢复 mov edi, ebx
% j- x* F$ m& p5 b z- emov esi, offset OurGate
& b. L0 `2 I8 _/ H' O/ P# y% tmovsd // 替换原来的中断门描述符 & l( G, H- d9 K- Q9 f; ]; O" J, \! P
movsd // 以安装中断服务例程 mov eax,0x6200 W$ m: e) t% Z, g- a3 W3 e1 p
// 用以测试放在EAX 中的数据
$ P8 o$ G- |/ L: C. _$ ^/ s8 A能否正确传到Ring0 中断 7 @7 A Y6 N1 D$ i: P' n/ ~, f
mov ecx,0
. u1 Q' ~) z0 J6 z// 用以测试放在ECX 中的数据
9 Z2 I! g. m, \* C b能否正确传到Ring0 中断
 ?& J! ?3 {9 M1 M# j9 Imov ecx,0 / S2 l5 h, F3 W& @
// 用以测试放在ECX 中的数据
( S0 B& y+ y" h# M能否正确传到Ring0 中断 ; j/ R: F, {/ O
// 因为很多VxD 服务都用
9 j. g f5 ?, i" g# |$ c此二寄存器传递参数 : \7 [/ _. O$ z1 F0 n: S
int 9h * c# {* R0 b+ R% `
// 人为触发中断, 平时会出现 2 o& N# L+ G" M6 A3 H1 y$ Q
保护错误蓝屏或非法操 9 |( J3 Z& P" {
// 作对话框，现在安装了 ' w. A# O( ]/ D* n5 Z$ ]0 k' `+ d
// 中断服务例程后，就会通过 / J; [ @$ K( C3 M( E( B, [
//VMM 在Ring0 调用中断服务例程 0 \ b9 a2 Z: _( K
－－Ring0Proc mov edi, ebx 4 F F3 H+ J4 d: C- S9 X
mov esi, offset SavedGate
8 c( K+ O( F6 \/ Dmovsd // 恢复原来的中断门描述符
1 t0 q6 r& ~- p% E' [movsd
' X j+ f8 ], j+ }/ O}
) y8 Y2 P: M. I) }cout<<"CR0="<<_cr0< } _getch(); if(0="=_getch())" while(_kbhit()="=0);" do{} continue.?< 
- ]: M) ~4 }; I8 G8 ]7 S5 }如何取得Memo的行和列 
0 i0 l6 N5 d3 N0 b* e+ f　　新建一个应用，在窗体Form1上添加两个TLabel组件名为Label1，Label2； 3 w8 U. K1 s3 x/ `. [4 ?1 N; `
添加两个TButton组件名为Button1，Button2；添加一个TMemo组件名为Memo1。
6 ?& V. c! C* V然后在代码编辑器中添加以下代码。
; y- K4 N" f# y% X: ?! @7 E4 V　　void __fastcall TForm1::Button1Click(TObject ＊Sender)
$ `, } B& [ I* n2 p( b) u5 Q　　{
3 X3 t1 ? a u* @5 ]　　Label1→Caption=SendMessage(Memo1→Handle,EM_LINEFROMCHAR,－1,0)＋1; & c, N* x1 M, S: }. h
　　} : a0 B, [7 O7 w( k; q
　　 3 m i. T) L' B
　　void __fastcall TForm1::Button2Click(TObject ＊Sender)
$ y2 t7 H' o' h$ _: A# q- M　　{
2 F% ^3 t& O* g8 r) p( [2 k　　Label2→Caption=Memo1→SelStart－SendMessage(Memo1→Handle,EM_LINEINDEX,－1,0)＋1; - P/ T3 I3 u: u7 O( [* h
　　}
6 X/ I1 R, M' F; @　　这种方法同样适用于RichEdit。 使用Sockets 
( Z2 d. j% b' q9 L, b, F* j使用sockets Socket控件让你建立一个利用TCP/IP和有关的协议与其他系统进行通信的应用。使用Sockets,你能够读和写通过它连接的其他机器，而不用担心实际的网络软件的相关细节。Sockets提供基于TCP/IP协议的连接。除此以外还能很好的工作，在其他相关的协议，例如Xerox Network System (XNS), Digital's DEC net, or Novell's IPX/SPX 家族。 2 ?7 N; L+ d/ m+ ^% W5 ]
C++ Builder提供你写网络服务器或客户应用程序去读和写其他的系统。一个服务或客户程序通常专注于一个单一的服务如超文本传送协议（HTTP)或文件传输协议(FTP)。使用server sockets,一个应用程序可以提供这些服务中的一个去连接一个希望使用服务的客户程序。Client sockets允许一个应用使用这些服务中的一个去连接提供这个服务的服务应用。
* f# V; C5 z* i& G( `8 U" D使用sockets去写应用程序，你必须理解下面这些知识：
+ m. u8 b( o; t3 \( Z一、服务工具
1 l( G- P8 [% o6 W当你需要写网络服务或客户应用时，Sockets提供一种接合。对于许多服务，象 / p9 ^: J+ z- L0 V
HTTP 或 FTP,第三方服务商提供这些服务已经相当有效。有些甚至随着操作系统捆绑而来，以便不用你自己写。然而，当你想更多的控制服务的实现，如想让你的应用程序与网络通信更加紧密，或当没有一个服务能提供你特殊需要的服务时，你可能想建立你自己的服务或客户应用。例如，工作在分布式data sets时，你可能想为数据库写一层与其他系统通信的应用。想使用Sockets实现一个服务，你必须理解： 1.服务协议 / H" M+ Q- G+ ?& V _7 ^
在你写一个网络服务或客户程序前，你必须明白你的应用将提供或使用什么服务。你的网络应用必须支持许多服务的标准协议。如果你为标准的服务例如HTTP,FTP写网络应用，或even finger or time,你必须先理解与其他系统通信所使用的协议。特殊服务细节你必须看提供的或使用的文档。 1 M- Y i% K. x+ m1 |% m' }
如果你的应用程序提供一个新的服务与其他系统通信，第一步是为这个服务的 " p& Z# j% _; t- w
服务端和客户端设计通信协议。什么信息将发送？如何整理这些信息？如何对这些信息进行编码？ 应用程序通信
- r6 A W- {' {2 H- D经常的，你的网络服务端或客户端应用程序要提供一层在网络软件和一个应用之间使用的服务。例如，一个HTTP服务站点在INternet与一个Web 服务应用之间为HTTP请求信息提供内容和应答。 + B4 m! O* x6 e) F
在你的网络应用（或客户应用）和网络软件之间Sockets 提供一个接口。你必须提供一个接口，在你的应用程序与应用间使用。你可以拷贝第三方服务商提供的标准API(例如ISAPI），或你可以设计和发布你自己的API. 2.理解服务和端口 N) E5 S4 ?, e$ ]3 J. Q& F
许多标准服务都有关联的、指定的端口号。当执行服务时，你可以为服务考虑一个端口号。如果你实现一个标准服务， Windows socket objects 提供一些方法让你为服务寻找端口号。如果提供一个新的服务，在基于Windows 95 或 NT机器上，你能够在文件Services中为你的服务指定一个相关联的端口号。设置Services文件的更多信息请看微软的Windows Sockets文档。 二、Socket连接的类型
" L# ]: o; t1 D' o/ G# q* ]* U3 bSocket连接可以分成三个基本的类型，它们反映了如何开始连接和本地Socket 连接是什么。这三个类型是： 1.客户端连接 $ Z, A: o! o, R; P0 {6 p3 Z8 H+ [
客户端连接是一个本地系统的客户端socket与一个远程系统上的服务端Socket连接。客户端连接由客户端Socket开始。首先，客户端Socket必须描述它想连接到的服务端Socket. 接着客户端socket查找服务端socket，当找到服务器时，就要求连接。服务端socket可能不能完成正确的连接。服务器sockets维持一个客户端请求队列，在他们有时间时完成连接。当服务端socket接受客户端连接，服务端socket ! K+ K7 X/ S7 l; [1 t4 N
将向它想连接的客户socket发送一个完整的描述，客户端的连接完成。 2.倾听连接
! ` k/ g! M+ a# }% d服务器 socket不会去定位客户端，代替的，他们形成被动的，"半连接"状态，倾听来自客户端的请求。服务器 sockets形成一个队列，存放它们听到的连接请求。这个队列记录着客户端连接请求就象他们已连接进来一样。当服务器sockets同意客户连接请求时，它形成一个新的socket去连接客户端，因此这个倾听连接能保持开放状态允许其他客户端请求。 3.服务端连接 ! s: _3 X4 z/ h3 {( y
当倾听socket同意一个客户端请求时，服务器端socket形成一个服务器连接。当服务器端同意连接时，向客户端发送一个服务端socket描述以完成连接，当客户端socket收到这个描述时这个连接得到确认，连接完成。一但连接到客户端的Socket完成，服务端连接就不能识别从一个客户端来的连接。末端双方有同样的能力去接收同样的事件类型。只有倾听（listening)连接是根本不同的，它只有一个单一的末端。 三、sockets描述 * G/ S, n5 I6 u5 g3 T8 E4 `
Sockets让你的网络应用软件通过网络与其他系统进行通信。在网络连接中每个socket可以看成一个终端点。它有一个指定的地址。 *这个系统正在运行 : \* J5 C2 d0 H4 G) f7 I
*它理解的接口类型 6 h2 x% h) [& z) `* T2 t3 C( a5 N' z
*用来连接的端口 7 X7 O' u; U' `
一个完整的socket连接描述，你必须提供sockets 在连接两端的地址。在你开始一个socket连接前，你必须完整的描述你想得到的连接。有些信息可以从你的应用 , A7 P3 [* c, y. E! E
软件运行的系统平台上得到。例如，你不需要描述一个客户端socket的本地IP地址--这个信息可以从操作系统上获得。你必须提供你工作所依靠的socket的类型的信息。客户端socket必须描述他们想连接的服务器。侦听服务器sockets必须描述他们提供反应的服务器的端口。一个socket 连接终端的完整描述包括两部分： 1.IP地址
) Q4 o" {& E$ |1 j' z主机是这样一个系统，它运行着包含有socket的应用程序。你必须描述主机给socket，通过给出主机的IP地址来完成这个描述。IP地址是一个有四个数字（byte)值的，在标准internet点付内的字符串。 ( ^0 j3 _) x) }0 s
例如123.197.1.2 6 j* @1 X7 P* Z w/ s# a! O
一个简单的系统可以支持多于一个的IP地址。IP地址通常难于记忆并且容易打错。一个可供选择的方法是使用主机名。主机名就是IP地址的别名，它就是你常看到的统一资源定位（URLs)。它是一个字符串，包括了域名和服务。
2 w$ N6 N! S( G' z; Z例如 <a href="http://www.wsite.com" target="_blank" >http://www.wsite.com</A>
2 Z5 q' {3 G3 `! d/ Y: d许多内部网提供给主机的名字对应的系统IP地址是internetIP地址。在windows95 和NT机器上，如果一个主机名不能用，你可以在HOSTS文件中为你的本地IP地址（这个本地IP地址应该是指你想连接的主机IP地址--zyqsj)建立一个进入的名字。
% Y% `0 h$ _ h# a& N; J: T关于HOSTS文件的更多信息请看WINDOWS SOCKETS的文档。 % A% ^5 S( \/ X* t- O/ [
服务器sockets不需要指定主机。本地IP地址可以从系统中读到。如果本地系统支持多于一个的IP地址，服务器sockets将同时在所有的IP地址上侦听客户端请求。当一个服务器socket同意一个连接，客户端提供一个远程IP地址。客户sockets必须指定远程主机通过提供主机名或者IP地址。 在主机名和IP地址间作一个选择 , f N- E2 F2 H, I2 ]- Q0 s
许多应用软件使用一个主机名去指定一个系统。主机名容易记住和容易检查排版错误。进一步讲，服务器能改变系统或与IP地址关联的特殊的主机名。使用一个主机名，能够允许客户端通过主机名描述找到抽象的站点，即使主机使用一个新的IP地址。
8 k ?. I3 B$ s0 ~如果主机名是未知的，客户socket必须指定服务器系统使用的IP地址。通过给一个IP地址来指定服务器将更快。当你提供主机名时，socket在定位服务器系统前，必须搜寻与这个主机名相关的IP地址。 2.端口号
+ M+ p4 w# r F" D4 \虽然IP得地址提供了足够的信息去找到socket连接中位于另一端的系统，你通常还需要指定那个系统的端口号。没有端口号，一个系统在同一时间只能进行一个单一的连接。端口号是唯一标识那允许一个独立系统连接到支持同时多个连接的主机，每个连接都必须指定一个端口号。 # A4 x9 g. V5 p9 y
在网络应用中，对于服务器工具来说端口号是一个数字代码。有一个习惯就是侦听服务连接到他们自己固定的端口号上，以便他们能找到客户端sockets.服务器socket监听为他们提供服务的相关端口号。当他们允许给予一个客户端socket连接时，他们创建一个独立的socket连接，使用不同的专用的端口号。通过这个方法，能持续的监听相关服务的端口号。
. J( ^2 d; V2 W7 ?客户端socket使用一个专用的本地端口号，就不用其他的socket去寻找它们。他们指定他们想连接的服务器端socket的端口号，这样他们就能找到服务器应用程序。常常的，这个端口号是通过命名想连接的服务来间接指定的。 四、使用socket控件
3 t H( J9 O4 N: `5 `) I* rC++Builder提供两个socket控件，客户端sockets和服务器sockets.他们允许你的网络应用构成连接其他的机器和允许你通过这个连接来读写信息。与每个socket控件相关联的是windows socket对象，它们在终端的的作用是一个实际的socket连接。socket控件使用windows socket对象去封装windows socket API 调用，所以你的应用不用去关心连接建立的细节或管理socket信息。
& E- |( ?4 ?; Z$ V! O5 c f如果你想利用windows socket API调用或自定义连接细节，socket控件提供了便利，你可以使用windows socket对象的properies,events和方法。 1.使用客户端sockets
" y- Q Q0 J0 W添加一个客户端socket控件（TClientSocket)到你的form或data module 使你的应用成为一个TCP/IP客户。客户sockets允许你指定你想连接的服务器socket和你希望服务器提供的服务。一但你描述你想得到的连接，你可以使用客户socket控件去完成连接服务。 4 X, k: O1 ?! n, _* I- W
每个客户socket控件使用独立的客户windows socket对象(TClientWinSocket)去应答连接中的客户终端。使用客户sockets去： A.指定想得到的服务
7 k R. x. ?5 V8 F$ I客户socket控件有一个数字properties,允许你指定想连接的服务器系统和端口。你可以通过主机名来指定服务器系统，使用Host property。 8 G) X& t2 I3 Z8 c1 x0 c+ M! |
如果你不知道主机名，或者你关心找到服务器的速度，你可以指定服务器系统的IP地址，通过使用 Address property。你必须指定IP地址和主机名中的一个。 * t. ?# d! S4 I7 _$ M( h
如果你两个都指定，客户socket控件将使用主机名。除服务器系统外，你必须指定你的客户socket将连接的在服务器系统上的端口。你能够直接使用Port property来指定服务端口号。或者直接在Service property使用想得到的服务的名字。如果你指定端口号和服务名，客户socket控件将使用服务名。 B.建立连接 5 U) k6 D5 e" N3 G" f! y) d; S
一旦你在客户socket控件中完成了设置描述你想连接的服务器的属性，你就可以进行连接，通过调用Open方法。如果你想你的应用启动时自动建立连接，在设计时设置Active property为true，通过使用Object Inspector来设置。 C.取得关于连接的信息
* ^, M8 @, T: O( Z1 V完成连接到服务器socket后，你可以使用与你的客户socket控件相关的客户windows socket object去取得关于连接的信息。使用Socket property去访问client windows socket object。windows socket object 有一个properties,它能让你确定在连接的两端客户和服务器使用的地址和端口号。
: d+ s- t# R6 v' G4 X5 U& E9 n当使用一个windows socket API调用时，你可以使用SocketHandle property区获得socket连接使用的handle。你可以使用Handle property去访问windows,以便接收来自socket连接的信息。AsyncStyles property决定哪种信息类型是windows handle要接收的。 D.关闭连接 9 _0 Z# w/ e( { J3 _
当你完成通讯想关闭socket 连接时，你能够通过调用Close方法来关闭连接。连接可能要由服务器端来关闭。如果是这种情况，你将收到一个OnDisconnect 事件的通知。 2.使用服务器sockets
 s3 `- G1 h# ]5 z! {添加一个服务端socket控件（TServerSocket)到你的form或data module使你的应用成为一个TCP/IP服务器。服务器sockets允许你指定你想提供的服务或你想用来监听客户请求时使用的端口。你可以使用服务器socket控件去监听和允许客户连接请求。每个服务器socket控件使用一个单一的服务器windows socket Object(TServerWinSocket)去应答在服务器端监听到的连接。它通常使用一个服务器客户winodws socket Object(TServerClientWinSocket)应答在服务器端每个活动的，连接着得到允许服务的客户socket。使用服务器sockets去： A.指定端口
3 r; j n2 K9 y6 |- |在你的服务器socket能够监听客户请求之前，你必须指定一个端口给你的监听服务。你可以使用Port property来指定这个端口。如果你的服务器应用提供一个标准的服务，这个服务使用一个习惯使用的相关联的端口。你能够使用Service property直接指定端口号。使用Service property是一个好的主意，能够减少设置端口号时的错误。如果你既指定了Port property,又指定了Service property,服务socket将使用服务名。 B.监听客户请求 # [. \1 {* ]) D
一旦你在server socket控件上设置好你的端口号，你就能够通过在运行时通过调用Open方法来监听一个连接。如果你希望你的应用程序能够在启动的时候自动监听连接，在设计的时候通过使用Object Inspector设置Active 属性为true。 C.连接到客户端。 # Q6 @* X* `6 j% H* D, B; G
当监听服务socket控件接收到一个客户端连接请求时他们将自动接受这个请求。当你没次收到通知时，OnClientConnetc事件将发生。 D.取得关于连接的信息 6 u! m: W2 G; U4 i, N
一但你的服务器socket打开了监听连接，你能够使用与你服务器socket控件相关联的服务器windows socket object来取得关于连接的信息。使用Socket property去访问server windows socket object.windows socket object有一个属性能够让你找到关于所有活动的客户socket连接这些客户socket是你通过服务器socket控件允许连接的。使用Handle属性去存取windows通过socket连接收到的信息。
/ m' B$ B0 T' g8 K每个活动的，连接到客户应用是通过服务、客户windows socket bject (TServerClientWinSocket)封装的。你能够通过server windows socket object的连接属性来访问所有的这些。这些server client windows socket object有些属性让你能够决定哪些地址和端口号给连接的两端--客户和服务器socket使用。当你使用windows socket API调用时，可以使用SocketHandle属性去获得socket连接使用的handle。你能够使用Handle属性去访问windows从socket连接处得来的信息。AsyncStyles属性决定windows handle将接收哪种类型的信息。 E.关闭连接
 T& u0 A0 q' P1 X' [' p5 ], U$ }当你决定关闭监听连接时，调用Close方法。这将关闭所有打开着的，连接到客户应用的连接，取消任何尚未同意的连接，接着关闭监听连接以便你的服务socket控件不在接受任何新的连接。当客户端关闭他们自己独立的连接到你的server socket的连接时，你可以在OnClientDisconnect事件中得到讯息。 五、socket事件的应答
: {4 k Z/ p3 U* t, \' V. x当使用sockets写应用程序时，大多数工作发生在socket控件的handler事件中.当通过socket连接开始读或写时,OnRead和OnWrite事件在non-blocking client sockets中发生从而通知sockets.同样的,服务器sockets(blocking or non-blocking)收到OnClientRead和OnClientWrite事件.
9 u0 L/ J8 D- M. r当服务器结束一个连接时,客户scokets收到一个OnDisconnect事件.当客户端结束一个连接时,服务器socket收到一个OnClientDisconnect事件.
0 B! d. |; I. Q% F3 C0 Z1 Z另外,客户端Sockets和服务器端socket从连接中收到一个错误信息时,都将产生有个错误事件. 错误事件:客户sockets和服务器sockets通常会产生一个OnError事件,当他们从连接中收到一个错误信息的时候.你能够写一个OnError事件处理去响应这些错误信息.这个OnError事件处理提供传送关于socket试图做什么的时候这个错误发生的信息,以及错误信息提供的错误代码.你可以在OnError事件处理中对这个错误作出响应,并且把错误代码改为0,以避免socket产生一个例外. 当开始和完成发生时,socket控件通常会收到一个事件号(number of events).如果你的应用程序需要改变socket开始操作的处理过程或通过连接开始读或写操作时,你将写事件handlers去应答这些client events和server events. A.client events % e! |2 B5 j; U, h% D4 K. [
当一个客户socket打开一个连接时,以下事件发生: + K- m$ R5 }( s j1 O8 w% z
1.一个OnLookup事件最先发生,它试图去定位server socket.在这里你不能改变Host,Address,Port,Service属性去改变你想定位的服务器.你能够使用Socket属性去访问client windows socket object,并且使用它的SocketHandle属性去调用windows API,以便改变socket的客户属性.例如,如果你想在客户应用软件中设置端口号,你必须在server client连接前做这件事.
, B# M# o. W j- U, n6 J2.windows socket设置和初始化事件通知.
: A8 Z b) ?4 t, b& U5 v3.当找到server socket时一个OnConnecting事件发生.在这事件中,windows Socket object可以利用的是通过socket属性提供关于连接的另一端的服务socket的一些信息.这是获得实际使用来连接的端口和IP地址的第一个机会,它可能不同于从监听socket处同意连接时得到的端口或IP地址.
& t1 Y. {, g3 P0 t5 Z. j v2 D: L4.服务器同意连接请求,客户端socket完成连接. 0 c g3 i5 T( g6 P, ]+ C; G
5.当一个连接得到确定后,一个OnConnect事件发生.如果你的socket立即开始通过连接读或写,就应写一个OnConnect事件Handler去作这件事. B.服务器端事件(server events)
9 i! r9 F, Q- Z3 m服务器socket控件通过两中方式连接:监听连接和连接到客户应用.服务器socket收到这两个连接的所有事件. 监听时事件
& q: F8 B" X* C; |. b1 m3 W$ e2 M1 Y当构成监听连接前,OnListen事件发生.在这个时候你能够通过socket属性获得server windows socket object.你能够使用它的SocketHandle属性去改变socket,在socket打开监听之前.例如,如果你想限定监听服务使用的IP地址,你可以在这个OnListen事件Handler中做. 与客户端连接的事件 , j2 e$ _3 R0 @- u& u/ A7 w+ A
当一个服务器socket同意一个客户连接请求时,接下来的事件发生:
; I! S: A! p) N$ F1 m1.服务器socket产生一个OnGetSocket事件,通过windows socket handle传送给连接的另一端的socket.如果你想提供自己定义的TServerClientWinSocket of descendant,你可以在OnGetSocket 事件 handler中建立,将被用来替代TServerClientWinSocket. 7 f* H/ T; a* u' x6 a. `( i' e
2.一个OnAccept事件发生,传送新的TServerClientWinSocket对象给事件句柄.这是第一个要点,当你使用TServerClientWinSocket的属性去获得被连接中服务的那端的客户的信息时. 7 f7 a, X- i: E, O, J* f p ~! w
3.如果服务类型是stThreadBlocking,一个OnGetThread事件发生.如果你想提供自己定义的TServerClientThread子类,你可以在OnGetThread事件句柄中建立一个,它将替代TServerClientThread. & z4 S% ?- ^% \
4.如果服务类型是stThreadBlocking,一个ONThreadStart事件发生当这个线程(thread)开始执行时.如果你想执行任何初始化这个线程,或调用一些windows socket API在这线程开始通过连接读和写之前,应该使用OnThreadStart事件句柄. 7 v+ a6 g1 Z3 T7 k5 M2 g
5.当客户端完成一个连接时,一个OnClientConnect事件发生.如果是non-blocking服务,你可能想开始通过socket连接在这端进行读或写操作. 六、通过socket连接进行读和写
 c, x# x9 F6 p+ L6 j( v9 v通过socket连接到其他机器的原因是想通过这些连接来读和写信息.什么信息是你要读和写的,或者当你想读和写时是依靠哪些socket连接的相关服务的. 2 S4 X4 b, @4 J6 B+ }; Q! c
通过sockets进行读和写可以是异步的,所以在你的网络应用中不需要阻塞其他代码的执行.这是调用non-blocking connection.你也同样可以通过blocking connection,这时你的下一行代码的执行必须等到读或写操作完成. A.Non-blocking连接,读和写是异步的, 所以在你的网络应用中不需要阻塞其他代码的执行.建立一个Non-blocking连接:
- _% T+ n' S" a1.在客户socket中设置ClientType属性为ctNonBlocking. 4 G A$ q; d0 }/ i
2.在服务器socket中设置ServerType属性为stNonBlocking.
 s8 q" s4 p3 l% `# H" l当连接是non-blocking时,连接的另一端企图读或写时读和写事件将把这个信息通知你的socket. 读和写操作事件
: w3 O6 \ i' A6 INon-blocking sockets想通过连接读或写时,它会产生一个读和写操作事件通知你的socket.在客户端sockets,你可以在OnRead或OnWrite事件句柄中对这些事件做出反应.在服务器端Scokets,可以在OnClientRead或OnClientWrite事件句柄中对这些事件做出反应.与socket连接相关联的windows socket object在事件句柄的读或写中被当作一个参数.Windows socket object提供一个方法号(number of methods)以允许你通过连接读或写.
/ n5 m7 W9 ?. o% ?通过socket连接读,使用ReceiveBuf或ReceiveText方法.在使用ReceiveBuf方法前,使用Receivelength方法去确定在连接的另一端socket准备发送的字节数(number of bytes).
) u: P6 K' ]: y$ }* v通过socket连接写,使用SendBuf,SendStream,或SendText方法.如果你通过socket发送信息后不在需要socket连接,你可以使用SendStreamThenDrop方法. SendStreamThenDrop在写完所有的信息后将关闭Socket连接,它能够从stream读信息.如果你使用SendStream或SendStreamThenDrop方法,不要释放Stream object, socket在连接结束后会自动释放这个Stream. & f# ?/ P/ X! H/ ~5 Z/ i9 n6 N. h
注意:SendStreamThenDrop将关闭一个独立的客户连接服务,而不是监听连接. B.Blocking connections
+ s, Y0 y$ e& T当你使用的连接是Blocking时,你的Socket必须通过连接发起读或写操作,胜过被动的等待从socket连接发来的通知. 当你的连接末端的读和写操作发生改变时使用Blocking socket.对于客户端sockets,设置ClientType属性为ctBlocking 以便构成一个blocing connection.根据你的客户端应用想完成什么,你可能想建立一个执行线程去完成读或写操作,以便你的应用能够继续执行其他的线程,当它在等待通过连接读或写操作的完成.
! ^0 B/ f/ X( K" E4 f2 A对于服务器sockets,设置ServerType属性为stThreadBlocking以便构成一个blocking connection.因为blocking connections在等待通过连接读或写信息完成时挂起了其他代码的执行,服务器socket控件通常产生一个新的执行线程给每一个客户连接,当ServerType设置为stThreadBlocking时.许多使用Blocking连接的应用都写使用线程(using threads.甚至如果你不使用线程,你可能也想使用(using) TWinSocketStream去读和写. " ]; O ^& Y9 I D! c/ U( u" U
1)using threads
1 }0 W% R: B7 A3 v$ }$ x当使用一个blocking connection进行读或写操作时,客户sockets不会自动产生一个新线程.如果你的客户应用程序没有什么事做,直到读或写信息完成,那么这正是你想要的.如果你的应用包括了一个用户界面,它还需要响应用户的操作,那么,你可能想产生一个独立的线程去读写.当服务器sockets形成一个blocking连接时,他们常常产生独立的线程给每一个客户连接,所以没有客户需要等待直到其他客户完成通过连接读或写操作.在默认情况下,服务器sockets使用TServerClientThread对象去实现为每个连接执行不同的线程.
3 e6 W- d: D" W8 T) O) vTServerClientThread对象模拟发生在non-blocking连接中的OnClientRead和OnClientWrite事件.可是,这些事件发生在监听socket上时,不是本地线程(thread-local).如果客户请求频繁,你将想建立你自己的TServerClientThread子类去提供一个安全线程(Thread-Safe)去完成读和写操作. 1 V4 M, S# S/ K% ^$ R% ?
当写客户线程或写服务器线程时,你能够使用TwinSocketStream去做实际的读写操作. 8 }3 o: ]% U9 {, k$ D
A)写客户端线程
, @9 `1 e) X0 N7 J9 z* e B- J- T/ W为客户端连接写一个线程,定义一个新线程对象,使用新线程对象对话框.你的新线程对象Execute方法的句柄的通过线程连接进行读写操作的细节,可以建立一个TWinSocketStream对象,然后使用它来读或写.
6 `7 i( t( C+ M& ?* Q2 c使用你自己的线程,在OnConnect事件句柄中建立它.关于建立和运行线程的更多信息,请看Executing thread objects. ' Z4 \+ _/ k8 w) k F+ I
例子:这个例子显示一个应用的客户线程在连接确定后向服务器发出写请求.
6 I. | i/ V' Bvoid __fastcall TMyClientThread::Execute() 5 j' d1 X5 _1 n
{ " M8 v4 c0 I) p* k' K+ h
while (!Terminated && ClientSocket1->Active) , c& f8 \; `1 k/ Y" @6 G% Q$ a. [4 }% Q
// make sure connection is active
$ C7 V$ r# Q5 s+ r8 F5 S4 {& \{
: f4 q6 o( j, I: v" xtry
+ P9 D# D* y: l' s{ , y) t+ ^3 m. k% G
TWinSocketStream *pStream = new TWinSocketStream(ClientSocket1.Socket,60000); , \8 y4 Q$ s; j. u1 U. f& o) _
try 2 w$ D3 g }: r' i7 B5 ?" m! g' ]
{
7 b2 f* k3 _7 tchar buffer[10];
, H: \; U" z9 G. z% e* rGetNextRequest(buffer);
# F: V% B/ X3 s// GetNextRequest must be a thread-safe method
2 D$ T7 [8 Q# {$ E- o// write a request to the server ) ]+ o& K3 d0 \' d; T
pStream->Write(buffer,strlen(buffer) + 1); # ?. q0 X7 j9 y) ^; x/ N$ K
// continue the communication (eg read a response) } , I; B3 E/ U- z1 A" w" @
__finally {
* G& O: m+ C7 D& P2 Idelete pStream; ( h. w9 v" z7 D; r- V
}
+ o* E6 F# X% f+ a% N0 p! k2 \& |1 \} / u$ N9 Z" p8 T
catch (Exception &E) - `* j/ M! } `! x, y
{ " d' V0 u& v3 \% {7 ]- j) r
if (!E.ClassNameIs("EAbort")) & y* a* Z) W3 j/ i3 H
Synchronize(HandleThreadException());
' b4 N! i) }# I1 J! \0 t// you must write HandleThreadException
4 |+ n8 [1 o' X1 \* M}
1 [0 u# a8 S7 N! {5 n& v} 6 T1 H+ w% x: x4 A. U& c0 G
} B)写服务器线程
3 @4 b7 i% S$ h0 @( F服务器连接线程由TServerClientThread派生.因为这个,不能使用新线程对象对话框.替代的,手动声明你的线程如下: class PACKAGE TMyServerThread :
' ?( p* N+ h4 C- Vpublic ScktComp::TServerClientThread 8 P& p) R1 N, y
{ ' V& u- ^1 ]0 e5 U/ m' r5 e3 U
public / Q/ p c' y6 `/ ^
void __fastcall ClientExecute(void);
 E% e% G2 P7 U5 `0 F} 注意你将用重载ClientExcute方法替代Execute方法.执行ClientExecute方法必须为客户端连接写一个同样的Execute方法线程.然而,当你从控件栏上放一个客户socket控件到你的应用上时来替代这个方法时.监听服务socket同意一个连接时,服务客户线程必须使用TServerClientWinSocket对象来建立.这可以利用共公共的CientSocket属性.另外,你能够使用HandleException这个protected性的方法,胜过
) L' c6 t2 B, ?! @1 M你自己写你的thread-safe例外操作. 警告:Server sockets会缓存他们使用到的线程.确信ClientExecute方法执行一些必要的初始化操作,以便它们在最后执行时不致于产生不利的结果. 当你使用你的线程时,在OnGetThread事件句柄中建立它.当建立线程,设置CreateSuspended参数为false.
2 ^) c/ L! G0 c6 F! Q l5 G o( r例子:这个例子显示一个为一个应用服务的线程,这个应用是在连接确定后由客户端来的读请求. void __fastcall TMyServerThread::ClientExecute()
" R. x( s' ?% g: s% C0 n8 }{ 9 E) q/ y9 f0 H0 p
while (!Terminated && ClientSocket->Connected) 5 m4 ]1 S- k f, O+ B E! \
// make sure connection is active
$ D# P6 \% [& y% ~5 ?{
$ T4 [3 n, X% o+ ftry d; t3 Z& t3 `7 P3 b y4 j) J6 j
{ + [5 {0 Z0 C3 \5 L* q" Z: i. i
TWinSocketStream *pStream = new TWinSocketStream(ClientSocket, ! A ]: B! d x
60000);
. _5 U; n; H( t, t3 u ctry
8 K2 @( G0 y7 [. Q{
( i% f1 ?2 I D# {% G1 g$ g. Cchar buffer[10];
- x1 q J+ \. I7 Dmemset(buffer, 0, sizeof(buffer));
7 e# i$ }8 F: R$ q; h/ L. e+ F" Z! Kif (pStream->WaitForData(60000)) " o$ n: @+ i6 [. O' a
// give the client 60 seconds to start writing " k: y1 t( [! D6 F
{
' |" Y3 O+ L5 I: [" x8 {if (pStream->Read(buffer, sizeof(buffer) == 0) ClientSocket->Close(); |) }! k' @3 l/ Y* W7 } t
// if can't read in 60 seconds, close the connection
1 P% S6 t$ P& _/ W$ g// now process the request
5 M/ o! i8 ~9 z% a} ) D/ A( R1 b: ]
else
" L- C g K& A6 B# m0 QClientSocket->Close();
8 s+ b" c+ L: ~$ K- u}
3 N: m2 p( e) v5 U$ O__finally { * B; W1 _" Z1 _" O% O; P3 E( L
delete pStream; , U% n V& a8 y/ q0 X3 a [( n
} # ^" R% m6 Z) _ v* G
} ; `/ J1 G. J6 K4 L
catch (...)
! O3 M4 w2 z/ v$ @) m1 g{
3 U5 b# W% F1 C( d# d0 |HandleException();
& t* G* F# A/ p8 ?$ j# w}
, G2 q; ^2 U t2 W7 y} 8 v: }' e& f8 F* B7 D# e
} C.使用TwinSocketStream
( N% b' R8 L" j% K3 U/ q, R* t7 n当为一个blocking连接实现一个线程时,你必须确定在连接的另一端的socket是准备写还是读.Blocking连接不会通知socket当它准备好写或读操作的时候.想看看连接是否准备好,使用TWinSocketStream对象.TWinSocketStream提供一个方法去帮助调整读或写操作时间的选择.调用WaitForData方法去等待,直到socket另一端的
( V! q* I% \) j" u准备好写操作.当读写操作使用TWinSocketStream时,如果读或写操作在指定的时间期限内未能完成,Stream将发生超时.这个超时被当作一个结果,socket应用不会暂停,而是不断的通过一个dropped connection试图读或写. 注意:你不能在non-blocking连接中使用TWinSocketStream 
作者: ilikenba 时间: 2004-9-24 21:45
<>Windows95/98下怎样隐藏应用程序不让它出现在CTRL-ALT-DEL对话框中？ <>* E3 {' o- G& ~+ K/ ~3 j6 B
把你的应用程序从CTRL-ALT-DEL对话框中隐藏的一个简单办法是去应用程序的标题。如果一个程序的主窗口没以标题，Windows95不把它放到CTRL-ALT-DEL对话框中。清除标题属性的最好地方是在WinMain函数里。 <>WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
! V$ v' A( q+ q{
$ G4 a8 f! z2 Jtry
" g+ a( S0 A/ l( L{ 7 D: ]7 k( }% |2 V
Application->Title = "";
6 d4 Y1 q* K9 u7 j: ^" t; t4 GApplication->Initialize();
0 a5 H9 y6 \! x2 YApplication->CreateForm(__classid(TForm1), &Form1); 2 x _, k4 c: S
Application->Run();
/ _; R3 Y0 W+ d3 a}
8 J2 V" c" E* }& Z3 P3 F& N6 Bcatch (Exception &exception) ' N6 ~) E% x) a2 W6 C( G
{ ) d7 q$ y+ S2 }! `
Application->ShowException(&exception); ' |' e+ U' P1 |5 X4 B4 K
}
 T& q* ?% ~. Freturn 0;
3 ~# t2 ?, h% M9 t}
* d/ `9 D. z9 J. m% @另一种方法是：调用RegisterServiceProcess API 函数将程序注册成为一个服务模式程序。 RegisterServiceProcess是一个在Kernel32.dll里相关但无正式文件的函数。在MS SDK头文件里没有该函数的原型说明，但在Borland import libraries for C++ Builder里能找到。很显然，这个函数的主要目的是创建一个服务模式程序。之所以说很显然，是因为MSDN里实质上对这个函数没有说什么。 <>下面的例子代码演示了在Windows95/98下怎样通过使用RegisterServiceProcess来把你的程序从CTRL-ALT-DEL对话框中隐藏起来。 <>//------------Header file------------------------------
8 m# g+ s; O+ S4 _1 Jtypedef DWORD (__stdcall *pRegFunction)(DWORD, DWORD); <>class TForm1 : public TForm
8 l5 r U" g7 H n1 G- n* Q5 {{
( |% i. t7 V' V: R__published: ; S- L" i4 f- S9 O5 h# @
TButton *Button1; ; K& _$ Y$ A0 H" Y
private: : t* ~: s% }. S( W+ y
HINSTANCE hKernelLib;
" {% Q" B2 W0 ]: Y b0 QpRegFunction RegisterServiceProcess; & h* }, f: |6 @5 d' |4 k
public: . ^, a' q I5 r
__fastcall TForm1(TComponent* Owner); - R( ?2 u+ i) } P6 M
__fastcall ~TForm1();
. C) Q4 D9 v1 {3 c: F}; <>5 I0 C6 {+ w; H
//-----------CPP file------------------------------
. H# H( L8 Q I I4 v5 s- A9 c#include "Unit1.h" <>#define RSP_SIMPLE_SERVICE 1 4 i5 F8 f w; C! ?3 D- D4 ^
#define RSP_UNREGISTER_SERVICE 0 <>__fastcall TForm1::TForm1(TComponent* Owner)
7 m" {1 | H7 ?& W* s1 z) w: TForm(Owner) 8 K: a; }$ C$ e8 U
{
6 M/ y1 j4 w) ]4 z4 ?0 Z/ y5 x) JhKernelLib = LoadLibrary("kernel32.dll"); 9 }- E. q/ Y( w3 F# U
if(hKernelLib) , L; W0 f1 h S; \3 }: z
{
; ^# y- D3 s) A* H" @: oRegisterServiceProcess =
9 s+ e6 {# i2 L# O* l(pRegFunction)GetProcAddress(hKernelLib, # k( D% \: \8 J: O7 r) G
"RegisterServiceProcess"); <>if(RegisterServiceProcess)
: Z% X) J, U$ i) ` s' HRegisterServiceProcess(GetCurrentProcessId(),
4 `0 ?' l _* ?6 K3 H; yRSP_SIMPLE_SERVICE);
$ t' C7 s r. I}
/ i; D$ b. D# f0 a. h3 T) r} <>__fastcall TForm1::~TForm1()
: b! \4 M5 e, y- ]/ @{ . ]. R0 X7 W+ F- ]7 {! {( Y
if(hKernelLib)
* G! D! T2 ]- O6 A) R{ 6 s4 Y7 y: `* v/ r* l
if(RegisterServiceProcess)
1 V2 M: J D$ P5 W' G7 X4 [RegisterServiceProcess(GetCurrentProcessId(), # J3 A8 i$ n/ _, ?. [+ L- m
RSP_UNREGISTER_SERVICE); <>FreeLibrary(hKernelLib);
, ~) q$ U$ `/ T$ T} ! I% R" ~1 V3 Y0 k: G1 B$ J
}
6 w3 Y u6 X3 k8 i0 y6 b$ @$ g//------------------------------------------------- 9 V9 X6 c: C) Q( `
注: windows NT下没有RegisterServiceProcess函数。 <>怎样隐藏应用程序的任务条图标 <>
2 g* j3 O2 i8 q1 k$ w首先，请看看这些术语。系统托盘是一个在任务条右角的小方框，在托盘了应用程序可以显示小图标。任务条是可以在屏幕上伸展的工具栏。它就是程序图标所在的位置。想隐藏程序的任务条图标，你可以应用ShowWindow函数并传给它Application->Handle窗口句柄。 <>ShowWindow(Application->Handle, SW_HIDE); 7 D, Z$ {4 E5 F$ ]
若想让任务条图标再出现，只需将SW_HIDE改为SW_SHOW。 <>ShowWindow(Application->Handle, SW_SHOW); / T# c! O$ M8 J4 F6 ?2 V
注: 你可以设置主窗口的Visible属性为false来隐藏它。 <>注: 通过ShowWindow来隐藏窗口的任务条图标是不持久的。某些动作会使任务条图标重现。你可以将隐藏的应用程序窗口设为Tool Window来移走程序的任务条图标而避免它再次出现。Tool windows永远不会有任务条图标。使应用程序窗口成为一个Tool Window有一个副作用：当用户按下Alt-TAB时它将不在程序列表中出现。你可以调用API函数GetWindowLong和SetWindowLong来使应用程序窗口成为一个Tool Window。 <>WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) / p, v9 g. ]8 K6 D; d8 {, x
{ <>DWORD dwExStyle = GetWindowLong(Application->Handle, GWL_EXSTYLE); t- Z, U! P: x9 e# F
dwExStyle |= WS_EX_TOOLWINDOW; : H3 _( v& S& D G+ U' F" i. @, Y
SetWindowLong(Application->Handle, GWL_EXSTYLE, dwExStyle); <>try
- k8 ~3 d( e, I& `{
6 i* U( z1 r3 l7 u9 BApplication->Initialize();
! Y) x9 E+ z3 f* n3 G& l5 D* lApplication->CreateForm(__classid(TForm1), &Form1);
8 b+ W- q5 Q Y( S% vApplication->Run();
 ^/ a# B. v4 H& W9 o7 O} , z9 o! M' Z* S
catch (Exception &exception) , J# L+ y+ ^+ K2 K/ ~$ z. t
{ 1 F' f3 H: m$ a* j! R3 S9 u
Application->ShowException(&exception); " I% ^: f0 L3 I! n/ }
} 4 }6 |# H1 p' C' x( C1 U& c0 g
return 0;
 [$ h+ k, O5 {} <>
9 W) u" W' S' w# v* e) z2 |! a4 g编写自己的Ping.exe程序 <>
# X/ T6 D5 o5 ~' d' O% a f在Windows系统中，我们经常用Ping.exe来测试网络的连通性。 <>　　Ping的实现过程很简单，该命令将引发IP层发送一个简单的IP包，一般是32字节。而目的方收到这个包后，将源地址和目的地址变换一下，重新发送这个包即可，当然还要加一些超时机制。 <>　　其实，我们也可用C++ Builder NetMaster中的NMEcho控件来实现网络连接检测功能。 <>　　首先定义以下控件： <>　　三个Edit控件：一个用于接收远程主机的IP地址或域名，一个用于接收用户设置的超时机制的时间，一个用于设置端口号。 <>　　两个RichEdit控件：一个用于给远程主机发送信息，一个用于接收来自远程主机的信息。 <>　　两个CheckBox控件：用于用户是否自己设定端口号。 <>　　一个Button控件：用于执行测试。 <>　　一个StatusBar控件：用于显示应用程序的状态。 　　程序实现代码如下： 　　void __fastcall TForm1::Button1Click(TObject ?Sender) 　　{ //设置NMEcho控件的标准TCP/IP属性 　　 NMEcho1-〉Host=Edit1-〉Text ; 　　 NMEcho1-〉TimeOut=StrToInt(Edit2-〉Text) ; 　　 if(CheckBox1-〉Checked) 　　　　 NMEcho1-〉Port=StrToInt(Edit3-〉Text); 　　 else 　　　　 NMEcho1-〉Port=7; 　　//TCP/IP中Echo的默认端口号 　　NMEcho1-〉ReportLevel=Status_Basic; 　　 NMEcho1-〉Connect(); //建立连接 　　 RichEdit2-〉Clear (); 　　 for(int i=0;i
1 | u" L! N7 _- ]! A　　//RichEdit1用于给远程主机发送信息 　　RichEdit2-〉Text=RichEdit2-〉Text +NMEcho1-〉Echo(RichEdit1-〉Lines-〉 　　Strings); 　　 NMEcho1-〉Disconnect (); 　　} 　　注意:在调用NMEcho控件的Connect（）方法时，应该确保在接收数据之前连接已经建立。 　　当调用Connect（）方法后，如果用户输入的是域地址而不是IP地址，且域名服务器成功地解析了这个域名，将触发控件的OnHostResoved事件，在此事件的处理中，我们将解析成功的消息在状态栏中显示给用户。具体实现代码如下：　　void __fastcall TForm1::NMEcho1HostResolved(TComponent ?Sender) 　　{ 　　 StatusBar1-〉Panels-〉Items[0]-〉Text="Host Resolved!";　　　　 　　} 　　如果用户输入的远程主机不正确，将触发控件的OnInvalidHost事件，在此事件的处理中，弹出对话框要求用户重新输入远程主机的IP地址或域名地址，然后试图与服务器重建连接。具体代码如下： 　　void __fastcall TForm1::NMEcho1InvalidHost(bool &&Handled) 　　{ 　　 AnsiString s; 　　 if(InputQuery("Invailid host!","Specify a new host:",s)) 　　 { 　　　　 NMEcho1-〉Host=s; 　　　　 Handled=true; 　　 }　　　　 　　} 　　建立连接后，将触发控件的OnConnect事件，在此事件的处理中，我们将连接成功的消息在状态栏中显示给用户。具体实现代码如下： 　　void __fastcall TForm1::NMEcho1Connect(TObject ?Sender) 　　{ 　　 StatusBar1-〉Panels-〉Items[0]-〉Text="Echo has connected host!"; 　　　　} 　　如果在调用Connect（）方法后，在超时时间仍然没有与服务器连接，将触发控件的OnConnectFailed事件，在此事件的处理中，我们将连接失败的消息显示给用户。具体实现代码如下： 　　void __fastcall TForm1::NMEcho1ConnectionFailed(TObject ?Sender) 　　{ 　　ShowMessage("Connection failed!");　　　　 　　} 　　除了NMEcho控件可以实现以上功能外，NetMaster的NMDayTime、NMTime这两个控件也能实现。方法与NMEcho控件一样，区别是NMDayTime和NMTime这两个控件不用首先调用Connect（）方法，它们与服务器的连接是在使用DayTimeStr、TimeStr属性时自动进行的。用C++Builder在WINNT下编制一个Service , P' _# c% d' l8 ]0 L( |. Y8 Y
---- Windows NT与Windows 9x有一个非常重要的区别，即Windows NT提供了很多功能强大的Service(服务)。这些Service可以随着NT的启动而自启动，也可以让用户通过控制面板启动，还可以被Win32应用程序起停。甚至在没有用户登录系统的情况下，这些Service也能执行。许多FTP、WWW服务器和数据库就是以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, 9 K3 x8 R5 o. N- d2 k2 O* v
LPCTSTR lpDisplayName, {2 C' ^# |1 H5 O
DWORD dwDesiredAccess, + B. C7 }: ]1 I/ } J: {6 J8 |
DWORD dwServiceType,
 D) M0 q3 J/ {8 UDWORD dwStartType,
0 c- I' z4 ^* _9 i! LDWORD dwErrorControl, 4 z/ K" ^. w' o5 o4 \; _
LPCTSTR lpBinaryPathName, - s+ q! T3 v* c& O. w# W6 f) d
LPCTSTR lpLoadOrderGroup,
0 P) A6 B/ ^1 `1 {1 bLPDWORD lpdwTagId,
; z0 I4 S: q( e! F+ M: c' k8 p2 Q$ VLPCTSTR lpDependencies,
 K+ r; I4 U! B0 \- u2 d, @3 lLPCTSTR lpServiceStartName, 7 G' H# A( G0 D6 N7 p. [( k
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。
$ C* {/ v8 l0 ^; Z) D. [7 X+ I---- 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 - e0 K% N5 ~+ K) d
SERVICE_CONTROL_PAUSE //暂停Service ! b% `* P/ G. H" D; z- i
SERVICE_CONTROL_CONTINUE //继续Service
9 s: `# N$ d2 J/ N: TSERVICE_CONTROL_INTERROGATE //查询Service的状态 $ F2 Y% ]( i6 Q4 Q
SERVICE_CONTROL_SHUTDOWN //让ControlService调用失效 ---- 参数lpServiceStatus是一个指向SERVICE_STATUS的指针。SERVICE_STATUS是一个比较重要的结构，它包含了Service的各种信息，如当前状态、可接受何种控制命令等等。
5 n/ l4 b8 G' ~+ \0 D! u---- 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)
0 f/ G: y; V7 L" T1 j+ E1 B{ 1 f# Q! d/ {& H6 U% s& S
SERVICE_TABLE_ENTRY ste[2]; , |+ a& Z# a! @ u' p. a- i- w
//一个Service进程可以有多个线程，这是每个　　　　 ( \0 S6 ?* |% x4 U9 x( V- U# G
　　　　　　　　　　　　　　 //线程的入口表 . I+ N6 p, i! H3 d
ste[0].lpServiceName="W.Z.SERVICE"; //线程名字
* g& f+ x' ~3 i+ jste[0].lpServiceProc=ServiceMain;
$ Z) o7 s7 x# F6 X: G: m9 S% w//线程入口地址 + E: q( o6 Z8 ]8 i/ N7 h3 J* [' Y
ste[1].lpServiceName=NULL; : I; k, ` R& m7 Z |# M# ?& n
//最后一个必须为NULL
; P# X2 v* H) aste[1].lpServiceProc=NULL; : R" `5 W7 G* r# R; \' n" F" |! k
StartServiceCtrlDispatcher(ste);
& V1 o( k( ?( V- p% J7 C0 Kreturn 0; 3 I& W1 l3 r6 E5 \; Q" J
} 
7 t3 y7 N" ]3 ?3 T9 E! Q3 Z! g---- main()是Service的主线程。当servie control manager开始一个Service进程时，它总是等待这个Service去调用StartServiceCtrlDispatcher（）函数。main( )作为这个进程的主线程应该在程序开始后尽快调用StartServiceCtrlDispatcher（）。StartServiceCtrlDispatcher（）在被调用后并不立即返回，它把本Service的主线程连接到service control manager，从而让service control manager通过这个连接发送开始、停止等控制命令给主线程。主线程在这时就扮演了一个命令的转发器的角色，它或者调用Handle( )去处理停止、继续等控制要求，或者产生一个新线程去执行ServiceMain。StartServiceCtrlDispatcher（）在整个Service结束时才返回。
+ J0 f5 `& U$ R& ~5 |: ~% U---- ServiceMain（）是Service真正的入口点，必须在main()中进行了正确的定义。ServiceMain( )的两个参数是由StartService（）传递过来的。下面是ServiceMain()的源代码： void WINAPI ServiceMain(DWORD dwArgc,LPTSTR *lpszArgv)
5 i" ]1 h1 ^3 J5 e# R) B* n{
0 c# u3 K! | q6 dssh=RegisterServiceCtrlHandler
* R- M# R6 e5 U+ `6 T("W.Z.SERVICE",Handler); ; n/ c9 ^2 @- r E
ss.dwServiceType=SERVICE_WIN32_OWN
/ a9 q* U% I; d* N( P, M I_PROCESS|SERVICE_INTERACTIVE_PROCESS; 0 o# ^0 Y8 q- \) h
ss.dwCurrentState=SERVICE_START_PENDING;
' a1 y! }) H4 e* [5 W- x( P//如用户程序的代码比较多
, g4 }: k9 X6 D（执行时间超过1秒），这儿要设成SERVICE_
5 v' T, e' Z5 t8 g$ L7 c( vSTART_PENDING，待用户程序完成后再设为SERVICE_RUNNING。 & v* y( K- l9 f3 u; Q& \) t
ss.dwControlsAccepted=SERVICE_ACCEPT_ " |) O$ |1 m% F- H }3 H0 u( w
STOP;//表明Service目前能接受的命令是停止命令。
" A% c* a" B* |$ _# X( ass.dwWin32ExitCode=NO_ERROR;
8 {! p# W! k2 _& `# V2 ess.dwCheckPoint=0; 4 D5 B! O3 S* G. R. J
ss.dwWaitHint=0; 0 X3 a) x+ ~" r8 }9 p$ X) n
SetServiceStatus(ssh, &ss); 8 ~8 [# N0 I& t7 ]: M
//必须随时更新数据库中Service的状态。 Mycode(); //这儿可放入用户自己的代码 ss.dwServiceType=SERVICE_WIN32_OWN_ ! ?! D& U6 J: {% V
PROCESS|SERVICE_INTERACTIVE_PROCESS; & |$ G" V% h3 W0 U
ss.dwCurrentState=SERVICE_RUNNING; % Y* }+ B6 @. x# e1 {
ss.dwControlsAccepted=SERVICE_ACCEPT_STOP; 9 H3 A" P- n8 Z) j3 j! ]8 A( Z
ss.dwWin32ExitCode=NO_ERROR; Z$ S& d* |$ E0 V
ss.dwCheckPoint=0;
$ v$ Z0 m, F+ @' G3 xss.dwWaitHint=0; * D- G1 y( a. |( G
SetServiceStatus(ssh,&ss); Mycode();// 这儿也可放入用户自己的代码 ! B* C" A+ O7 r/ p2 S9 k
} 
' h$ j" I. f% n2 b/ p在ServiceMain（）中应该立即调用 9 V) j5 E- N5 r" _- \& B
RegisterServiceCtrlHandler（）注册一个Handler 3 g8 m8 T/ O9 }2 l; |) t
去处理控制程序或控制面板对Service的控制要求。 + f& b4 E: e" b% m, i" W& {
Handler（）被转发器调用去处理要求，
1 I F8 U0 [: P& c5 D下面是Handler()的源代码:
: D* I; l/ q0 s3 f! K; ivoid WINAPI Handler(DWORD Opcode)
& y$ M, E4 w6 j( ~{ : [7 P |" ?' [2 ^/ \1 Q7 A2 H
switch(Opcode)
5 y% M( E! J- e2 l. J1 J{ , l7 G1 E: q! m, ^2 w% {# H9 [
case SERVICE_CONTROL_STOP: //停止Service
" O. \, t' q8 hMycode（）；//这儿可放入用户自己的相关代码 " b; x, X- l. e* M8 R
ss.dwWin32ExitCode = 0; 8 n1 `, ?& p! j# |
ss.dwCurrentState =SERVICE_STOPPED;
9 ]4 M9 F# M8 S2 `% |( F1 R' d//把Service的当前状态置为STOP 6 d& ]$ T1 n$ X) d' s
ss.dwCheckPoint = 0;
( O$ j+ v* V8 O% v$ rss.dwWaitHint = 0; % h2 {4 f2 d z8 G" l' Z
SetServiceStatus (ssh,&ss);
) s5 T6 j, @2 f5 j7 B" u/必须随时更新数据库中Service的状态 3 g8 r: R% v1 n( J( L
break;
: v1 f2 q9 |; K4 J4 g/ S/ d2 Rcase SERVICE_CONTROL_INTERROGATE:
8 Z ]" N$ l7 L0 d- g7 }7 sSetServiceStatus (ssh,&ss); " B% n% e6 B' R" f) w' f
/必须随时更新数据库中Service的状态 ) p- l, q! |$ w C! c5 h
break;
6 Y8 b9 p' M5 v4 T5 J2 M}
9 g; W" s+ K. [} 
+ r/ G5 }' N( F" v---- 好了，Service本体程序已基本完成，我们接着来看一下Service的控制程序： 0 V0 q; E/ K* [
---- 控制程序是一个标准的window程序，上面主要有四个按纽：Create Service、Delete Service、start、stop，分别用来产生、删除、开始和停止Service。下面是它们的部分源代码： 1. 产生Service
! f9 o7 W& [% X: Mvoid __fastcall TForm1::CreateBtnClick & h# ~# k% W' q, f# J! s
(TObject *Sender) 6 F$ g# a7 ~; k! K6 a# \
{
- A2 F4 q4 u; }: y) L# ~( w. ]- d$ dscm=OpenSCManager(NULL,NULL,
/ N$ L. G. _! ^! r/ f6 RSC_MANAGER_CREATE_SERVICE);
8 z& R! g5 ?; }5 i! Gif (scm!=NULL){ # ^- t( [$ j( l- g+ R
svc=CreateService(scm,
6 {3 @/ S* b% L L- s"W.Z.SERVICE","W.Z.SERVICE",//Service名字
# ~! B7 m/ C6 P/ {6 QSERVICE_ALL_ACCESS,
3 W5 y' }; W# {3 [SERVICE_WIN32_OWN_PROCESS
6 e" ]4 _ Q0 L9 Z2 }0 ]|SERVICE_INTERACTIVE_PROCESS,
5 D+ ~, g, k, _3 z" o1 } DSERVICE_AUTO_START, ; d! Q7 }( ]. V$ u- T
//以自动方式开始
$ L, {4 C; E( Q* HSERVICE_ERROR_IGNORE, * K; n1 H) |% d) \
"C:\\ntservice.exe", //Service本体程序路径，
1 ?3 {* Q4 m: y/ I5 G2 s- H, \必须与具体位置相符 2 k; ]6 I( E* u# M0 p
NULL,NULL,NULL,NULL,NULL);
8 d) N; @/ N5 n# z- Gif (svc!=NULL) : a3 g+ i; S- p$ M) e. P& s
CloseServiceHandle(svc); ( `3 W9 T* O0 ~6 y% ]& `4 Q
CloseServiceHandle(scm);
4 {$ ~/ L$ g. ^. w! g; D3 Z}
$ e8 w y8 O; f; h& \/ w9 |- ^$ d; W} 2. 删除Service % Y, M* f7 A) n5 \( V8 M: B
void __fastcall TForm1:eleteBtnClick / t* Z7 Q. t+ A% h4 h5 O' B
(TObject *Sender) . C+ T, w% s) {2 p4 U
{
3 r1 G) k2 d; q" qscm=OpenSCManager(NULL,NULL, " m3 I, D) V {0 ?
SC_MANAGER_CONNECT);
# Y* i' N L1 K" f" i8 d; N8 Aif (scm!=NULL){
" @( i" J( A2 E u5 K6 _, F) r2 ]svc=OpenService(scm,"W.Z.SERVICE",
# {" h3 i3 E; w0 V# }8 wSERVICE_ALL_ACCESS);
1 }# g9 t' H1 q; l0 o0 j0 V aif (svc!=NULL){
- w2 ]: c k) |QueryServiceStatus(svc,&ServiceStatus); ' [6 U! h! c; ^& H! m
if (ServiceStatus.dwCurrentState==
SERVICE_RUNNING)//删除前，先停止此Service.
8 j9 Y C: L( X% ~# H7 m+ x1 NControlService(svc,
, _5 ~7 H$ l; J+ { ^SERVICE_CONTROL_STOP,&ServiceStatus); / T J ^- j& b: x! a9 _
DeleteService(svc);
1 A1 C) v9 g! O/ R Q# mCloseServiceHandle(svc); 5 s) D: D- e* E' l2 g
//删除Service后，最好再调用CloseServiceHandle
9 L6 R( U" s( K& w}
# W& l8 d8 k7 U# h3 U0 z//以便立即从数据库中移走此条目。 - m* p9 ]( k7 X0 H# H8 S% j: L
CloseServiceHandle(scm);
0 z5 y, ~ Q( K8 [0 R} # N: F( g) w G/ A- @
} 3. 开始Service
8 _; z J i4 C9 ?6 \5 K$ n% Dvoid __fastcall TForm1::StartBtnClick(TObject *Sender) - X: M# ?2 S* a) }
{
* l; R: g# U( G. J$ t1 }scm=OpenSCManager(NULL,NULL,SC_MANAGER_CONNECT); 5 X) ?. Q- R' W9 P& b
if (scm!=NULL){
# a7 D" ]. j( F3 Q1 m% D; @svc=OpenService(scm,"W.Z.SERVICE",SERVICE_START);
( @. k" X% V5 c+ {8 V: n; B2 mif (svc!=NULL){
1 w: A+ }8 x' X* j4 U8 O$ wStartService(svc,0,NULL);//开始Service
; Q; ?. J; f" D0 _CloseServiceHandle(svc);
% Z- f# H% y5 z% ^, Q} / U$ Q( |* \4 E$ g$ r
CloseServiceHandle(scm);
2 F# u$ M' ? U1 e}
* k ^6 `" }' q5 Z# m0 |} 4.停止Service
; Q) Z& F6 F9 Mvoid __fastcall TForm1::StopBtnClick
- E/ t7 B9 U. _9 t3 N; ^ N# N5 _(TObject *Sender)
6 _" J: Z) J7 B! O7 G: c9 J4 J{
: ^7 N5 O, l- e/ kscm=OpenSCManager(NULL,NULL,
" k4 l. w6 S# A2 l( _& wSC_MANAGER_ALL_ACCESS); " M# t. K* G L7 T1 O9 A
if (scm!=NULL){
3 k8 @6 c; U2 g7 A# \$ osvc=OpenService(scm,"W.Z.SERVICE",
4 _; r7 t- F: H5 E: j: N6 m6 hSERVICE_STOP|SERVICE_QUERY_STATUS);
6 z2 B4 q+ H7 \; @2 P& {5 s7 ~* bif (svc!=NULL){
% _2 {; {/ h% \5 v5 T( |: [QueryServiceStatus(svc,&ServiceStatus); , f! s* D$ P" k' n# G, b
if (ServiceStatus.dwCurrentState== 5 |+ @. M$ X; X( D9 z1 X
SERVICE_RUNNING)
2 t- W0 J, j/ M- }7 e$ jControlService(svc, 3 u1 p0 Q% |1 b
SERVICE_CONTROL_STOP,&ServiceStatus);
1 w; j6 a) f3 m9 F3 VCloseServiceHandle(svc); M' y7 D5 U5 |
} / O. W' Q9 w2 s1 Y( P
CloseServiceHandle(scm); , M$ ]( a$ i$ P$ a/ {
}
+ D i: ?) B. }2 g, @( y1 m5 w} 如何在C++ BUILDER中自动关闭WINDOWS屏幕保护 6 Z1 O* u# q f: e; o9 t$ L; e
---- 在实际编程应用中，当程序需要用较长的时间来处理某些计算时，这段时间有可能使WINDOWS启动屏幕保护，这样程序的处理会相对变得更长。那么如何在运行程序时自动关闭屏幕保护呢？ / L& G* k4 @* `! |
---- WINDOWS在启动屏幕保护前会向已激活的程序发送一个WM_SYSCOMMAND消息，并将该消息的WPARAM参数设置为SC_SCREENSAVE。我们可利用C++ BUILDER中的TApplication类的OnMessage事件来处理WINDOWS发来的这条消息，如果在接收到的消息后将handled参数设为true，这个响应的消息值就可以阻止屏幕保护运行。 ---- 在C++ BUILDER 4.0的过程如下： ---- 1、从主菜单中选择File | New APPlication 来创建一个新的空工程文件。然后在Forn 上加上一个Label对象，设置其Caption为"此程序将关闭WINDOWS屏幕保护"。 ---- 2、在程序头文件unit1.h中对成员函数ProcessMessage的声明加到TForm1的定义中。 class TForm1 : public TForm
4 H% g2 A3 W, S! M) S{
# q$ \. A9 U- J( Q__published: // IDE-managed Components
% o: B9 v% n3 u4 aTLabel *Label1; $ u) V0 T) d( F h8 x
private: // User declarations
; G+ g$ g* F7 q+ ]0 mvoid __fastcall ProcessMessage
7 y, K& ~( F! L2 x8 v(TMsg &message,bool &handled);
2 E4 y1 I8 Z. ^5 Gpublic: // User declarations ; h6 K8 S- U6 P% G& z
__fastcall TForm1(TComponent* Owner);
$ H% T7 V2 _2 `; x3 d) S& S}; ---- 3、在unit1.cpp中，在程序中增加ProcessMessage函数语句：
! d3 O+ r4 l1 A' `void __fastcall TForm1:rocessMessage 9 u0 C( y# K* N9 G
(TMsg &message,bool &handled)
2 T+ T& {) E1 }* Q8 o. o{ 2 w) W6 w% Q# Q8 ?1 g e
if(message.message==WM_SYSCOMMAND
5 p/ v/ Q# Q8 X&&message.wParam==SC_SCREENSAVE)
% A7 _0 {& ~* b2 h+ e0 M* x{ 9 P5 i0 j6 U" _, `* V
handled=true;
 R" T; G* r3 P$ n5 `' Z6 V4 [& p}
- q7 Y2 I v, S3 P}
 {- w/ E" C6 O: E7 r3 [4 I+ d---- 4、在TForm1的构造函数增加以下代码： & p1 Q2 V: p1 [- H
__fastcall TForm1::TForm1(TComponent* Owner): TForm(Owner)
9 o9 U# N; p6 q( g. t{ 2 C6 A& v4 M3 ^; c
Application->OnMessage=ProcessMessage;
. o) Q7 y6 U; F/ v. \& K} ! ]: n8 f4 {- T, @) @& X' s
显示/隐藏任务栏图标 
( C' a$ S+ u: p" @9 w---- 标准的Windows应用程序运行时一般都会在任务栏上显示任务图标，用户可直接用鼠标点击任务栏图标进行任务切换，但有些应用程序不使用任务栏图标，如典型的Office工具条，也有些程序可由用户定制显示方式显示或隐藏任务栏图标，如Winamp。我们的程序中也可以做到，只要调用Windows API函数SetWindowLong即可，如下： // 隐藏任务栏图标： ! k3 }! c$ a) L7 p$ B% D
SetWindowLong(Application->Handle,
: ^4 W! _9 P" g _$ }/ wGWL_EXSTYLE, WS_EX_TOOLWINDOW); ! U8 U, x2 B! J" i& s8 Z3 H7 x
// 显示任务栏图标： . G2 s: f3 [ \ y
SetWindowLong(Application->Handle, - R3 C' n \2 I/ [* ]: }9 D, d
GWL_EXSTYLE, WS_EX_APPWINDOW); 
' B( b5 j6 m4 \! b$ T' ^信箱监视程序 1 }1 z2 x# R+ h9 @$ W( _9 n( }1 F: G% C( r
----本文将向大家介绍怎样编写自己的信箱监视程序，程序将直接调用WinSock 函数来进行网络通信。除了具备WinSock 编程知识之外，还必须了解POP3 协议。下面是对POP3 的一个粗略的介绍，读者可以参看RFC 1225 更为详细地了解该协议。 一、关于POP3 协议
4 j4 Z$ Y, s$ b% ~; j+ ^5 C# H----POP3 服务器程序通常在TCP 端口110 提供服务。当客户想要使用服务时，它便与服务器建立一个TCP 连接。一旦连接建立，POP3 服务器就向客户发送一条欢迎消息。然后客户开始给服务器发送命令，服务器则给出相应的回答。POP3 的命令由一个关键词或者关键词加参数组成。每个命令以回车换行（0xD0xA）作为结束标志。对于所有的命令，POP3 服务器都会提供一个回答。服务器的回答由一个状态标志加一些附加信息组成。目前使用的两个标志是“ ＋OK” 和“ －ERR”，分别表示客户的命令是否合法。所有的回答也是以回车换行结束。 # Z. t' G: e `2 Q. i9 {3 w
----与本文讨论的话题相关的四个POP3 命令是USER、PASS、LIST 和QUIT。 USER 命令 : y% D- n$ T4 _& K' c* S" m
格式USER name ----其中name 是用户在该POP3 服务器上的用户标识。客户应该在接到服务器的欢迎消息后或者在上一个 USER 或者PASS 失败之后可以发送此命令。 PASS 命令
 p" S) p* n2 D格式PASS string ----其中string 为该用户的密码。客户在发送了USER 命令并且收到了＋OK 的回答之后方可发送此命令。如果用户名和密码都正确，服务器回答＋OK，否则－ERR。 LIST 命令
1 p/ v z+ S: d7 f2 Z9 |格式LIST ----如果该用户有邮件，则LIST 命令会回答＋OK，并列出所有邮件的标识符和大小（每个邮件一行），最后一个仅包含一个句点的行（0xD0xA0x2E）表示整个回答的结束。如果该用户没有邮件，有些服务器会返回－ERR，有些在可能返回一个＋OK 和一个仅包含一个句点的行。当然，客户必须在PASS 命令通过之后客户程序才能给服务器发送LIST 命令。 QUIT 命令 ----从POP3 服务器上退出登录。 二、实现相关函数
' Q g8 W; l3 Y4 [/ i' q----接下来我们按照POP3 协议所定义的通信规则来实现一个名叫POP3CheckMail 的函数，只要调用此函数，我们就可以检测信箱了。 4 ` y2 ~) y* g: u7 f
----下面的代码是用与Delphi 4 兼容的Pascal 语言实现的，我们必须包含WinSock 单元，并且在调用下列函数之前初始化好WinSock 动态连接库。初始化WinSock 动态连接库的代码如下： ----if WSAStartup( ＄002, wsadata)<>0 then Halt; ----POP3CheckMail 的原型如下： ----function POP3CheckMail(Email,Password:String;var MailList:TStringList;var ErrorMsg:String):Bool; ----参数说明： ----Email 和Password 分别为用户的email 信箱名和口令。 ----变量参数MailList 用于返回邮件的标识和大小，MailList.Count 表示邮件的封数。 ----变量参数ErrorMsg 返回出错消息。 ----以下是POP3CheckMail 及其它所用到的函数的实现代码。 Connect_Server 函数 ----功能：与指定的主机建立一个TCP 连接，返回一个Socket 描述符。参数host 指定主机的名字，Port 指定端口号。 function Connect_Server(host:string;Port:integer):integer;
& V! ?4 L/ _& X: u. S- M( t+ @+ y- Fvar i:integer;
- f1 T% R' }. lp:^LongInt; ! I8 _2 |5 Z6 o4 Q
phe:pHostEnt;
$ w9 r6 `0 r+ v/ T7 _ Lsin:sockaddr_in; 1 D( X1 M4 ^! _3 g9 R5 m* F
begin * V! G5 i" \9 ?6 c' h
sin.sin_family:=AF_INET;
* t; P+ x9 L5 S: H7 Ssin.sin_port:=htons(Port);
% m; y8 L$ W8 _ ?, a/ o: r) Z//Get the IP for host, allowing for dotted decimal , g* H6 s3 [& c
phe:=gethostbyname(pchar(host));
6 u! g* \. r0 _4 J0 S, Eif phe<>nil ; F$ q, A# `1 w: X. V; X- A. r" s
then begin
" M8 v. B: {7 N$ A8 I# kp:=Pointer(phe^.h_addr_list^); " M/ u2 i- F1 ^- Z. }3 r8 a
sin.sin_addr.s_addr:=p^; - _6 k: e9 M2 x* ~. E N
end / s5 a/ G- W. A) ?* E
else begin " C8 W5 n0 q3 Y) _3 I
i:=inet_addr(PChar(Host)); $ q( M6 ]: y0 A$ q6 F6 p
if i<> －1 then sin.sin_addr.S_addr:=i . S: N# T% U; d
end;
# e0 x, {7 B* R* v2 L0 {" U8 N//create a socket
' ]2 s5 ?6 v! b/ CResult:=socket(PF_INET,SOCK_STREAM,0); ! O" `$ {& d9 G) B' |( Q8 l
if (Result=INVALID_SOCKET) then Exit; 5 O$ y# B4 O2 m0 o
//connect to server
) l% k+ p6 c6 d8 x% ~+ Mif Connect(Result,sin,sizeof(sin))=SOCKET_ERROR ' X4 _ a2 P! R" G0 Y) M
then begin {Error handling} end; , g3 D6 ?# `3 Y) `$ i; L
end; Write_Socket 函数 ----功能：向Socket 写入一个字符串。 function Write_Socket(sockfd:Integer; const s:string):Integer; m( s. b" _* o" w) B+ P
begin
$ V- m- d& F1 N2 k+ C! rresult:=Winsock.Send(sockfd,pointer(s)^,Length(s),0) ( d" Y* m+ W5 N5 P/ q7 u2 z. e
end; Socket_Readline 函数 ----功能：从Socket 上读取一行。 function Socket_Readline(sockfd:Integer):String;
) p: T0 A/ O; r. B; K7 K//Read until ＃10 2 N1 M w V6 h- d' j/ M5 e& H
var S:String; buf:array[0..1]of Char; ' i& u* o% ^& H
n:Cardinal;
' T! i* F1 Y/ x6 mbegin
& k( @1 Y& a5 O/ w& g1 Bbuf[0]:= ＃0;buf[1]:= ＃0; S:=‘';
) [/ S, j0 U+ h1 l! b* i, g( Vn:=recv(sockfd,Buf,1,0);
( Y- A# K; t9 C4 ]# |/ zwhile n>0 do begin ' b7 \4 S6 {( X2 \8 `0 A. w
buf[1]:= ＃0; 9 ^: y3 H* i& f: y2 O9 ~; o' C3 n
S:=S ＋buf; 8 [' ?/ `, L2 W, C E1 _
if (buf[0]= ＃10) then Break; 7 F- [& I& s( i$ `
n:=recv(sockfd, buf, 1, 0); , h$ v5 i8 s; v& d+ o
end; * E! U: d9 w; B
Result:=Trim(S); 0 i! j& D' F) u+ H5 F
end; Pop3Response 函数 ----功能：读取POP3 服务器的一行返回信息，如果是“ ＋OK” 则函数返回TURE，如果是“ －ERR” 则返回FALSE。 function Pop3Response(Sockfd:Integer):Bool;
; v. {: `4 t6 w$ |7 a& O+ ^var S: string;
. S6 H* e% \, Dbegin
6 A$ E& |6 i; L. g" B7 uS:=socket_readline(sockfd); 9 \( Z* @( y1 |% \, g
if copy(s,1,3)=‘ ＋OK' then Result:=True
1 z. q5 m& T# Q; Y4 c. w; n: Relse {if copy(s,1,4)=‘ －ERR' then }Result:=False;
# k6 n; r8 f5 H# jend; POP3CheckMail 函数 ----功能：检测名字为email 的信箱，如果有新邮件，则通过变量参数MailList 将每一封邮件的大小返回。 function POP3CheckMail
7 T" F& {, d9 G9 K! T B(Email,Password:String;var MailList: ! h. g8 M' |8 v9 w8 h) n0 ~
TStringList;var ErrorMsg:String):Bool;
 b% `2 t! a; m! Cvar sockfd,i:integer;
. w6 B% j F9 \7 x* @' DS, Host, User:String;
( [" V B: d* n7 Abegin
, Q4 p' O2 R1 u3 b8 y0 aResult:=False; ErrorMsg:=‘'; . [: P" O$ a, o6 ~; }- @5 d
if MailList=nil then Exit;
5 r4 K a" h+ t2 H5 i' OS:=Trim(Email);
# \: ~0 u# ]% S/ ^4 Ai:=Pos(<a href="mailt‘@',Email" target="_blank" >‘@',Email</A>);
0 d1 L# } m/ B& ZUser:=Trim(Copy(S,1,i －1)); 3 m }' n+ P! @& L
Host:=Trim(Copy(S,i ＋1,Length(Email) －i));
+ S* W% g; a0 N3 tMailList.Clear; 5 p- _" I# E2 C K+ B/ |$ D
if (user=‘')or(host=‘') then begin + }" i, A, o" {0 D8 f
ErrorMsg:=‘Invalid email address.';exit; end; ( U4 A7 z* ]2 d$ V* `% X. V8 n
if (Host[1]=‘[')and (Host[Length(host)]=‘]')
& j! |+ I0 L4 `5 \' h* @then begin Host[1]:=‘ ';Host[Length(host)]:= ＃0;end; / C/ J2 {; T$ e
Host:=Trim(host);
' d& h2 x- [* b( m/ X5 Fsockfd:=Connect_Server(Host,110); , u& P+ q1 @% L! f: Y1 t
if not Pop3Response(sockfd)then begin ErrorMsg:= - [; L" ~/ g# }& P. y' X/ k
‘Cannot connect to server';exit; end; 0 _8 z" a* y3 Y: h& B5 b
Write_Socket(sockfd,‘USER ' ＋User ＋＃13 ＃10); 7 Y0 C7 u: [" w$ F. L2 r' f
IF NOT POP3Response(sockfd) then begin ErrorMsg:= ( q& k1 i* \$ h4 v" x" O
‘USER failed'; Exit;end;
' f, N9 Q& X' |4 g+ tWrite_Socket(sockfd,‘PASS ' ＋Password ＋＃13 ＃10);
+ e6 I" B: R oIF NOT POP3Response(sockfd) then begin ErrorMsg:= ' M( [4 r0 D% k" m. M
‘PASS failed'; Exit;end;
. F& \/ y1 R" J. M: y; n lWrite_Socket(sockfd,‘LIST' ＃13 ＃10); 4 a( i& f* C! d
POP3Response(sockfd); S7 C4 T/ I1 d( q
while true do begin
3 w* F. _, T& V$ A% X3 Z1 Q3 R& Ls:=Socket_readline(sockfd); " i8 d1 E5 U* H
if s=‘.' then BREAK;
, X+ g; N8 V7 p7 tMailList.Add(S);
$ J8 Q( r# m$ w0 aend; + I2 u( z, n% C' j& c* q. R5 V
Write_Socket(sockfd,‘QUIT' ＃13 ＃10);
 H; \0 k4 B% JClosesocket(sockfd); 8 _! |+ Y- [/ f; w. f2 G
Result:=True;
/ D* Y& N6 d6 ~2 K; V% Kend; 三、邮件的检测 / U( x0 V; Z3 Q9 [( T/ m
----下面我们来看一个使用POP3CheckMail 函数的简单示例。
/ k% M5 q/ U L1 i2 vvar MailList:TstringList;
6 O* X" u9 [, J9 wErrorMsg:String; " [+ o5 H* B4 d H; M3 E* A6 Y
... + |* \& V3 c2 F5 ~ p
MailList:=TstringList.Create;
7 {* t6 b7 Q1 @! G( |POP3CheckMail(<a href="mailt‘simon_liu@263.net'" target="_blank" >‘simon_liu@263.net'</A>, / e6 I# ^. `4 v( Q! ?1 e8 T' Y
‘mypassword', MailList, ErrorMsg);
# U k. U- S, I0 N( _1 Z1 }If MailList.Count>0 then
% Y; e1 ~ w0 b# r2 B1 KMessageBox(0, Pchar(‘You have ' ＋IntToStr (MailList.Count) ＋ ‘ new messages!'), / K J2 T/ P; p% u% n* y: h
‘New Message!', MB_ICONINFORMATION)
5 N) Q, c- I# a' DElse if ErrorMsg=‘' then MessageBox (0, ‘No message!', ‘',0) 7 Q/ g5 k. J, j; e s
Else MessageBox(0, Pchar(ErrorMsg), ‘Error', 0);
& E' K( z0 c( s( J& c* NMailList.Free; ----如果你仔细阅读了POP3CheckMail 函数的实现代码，你会发现此函数除了可以获取邮件的封数之外，还可以获得每一封邮件的大小。你可以通过POP3CheckMail 函数的变量参数MailList 的Strings 数组来获取邮件的大小。 ----实现了POP3CheckMail 函数，再在此基础上编写一个POP3 信箱的监视程序就变得很简单了。你可以通过一个定时器来定期地调用POP3CheckMail 函数，这样你就可以监视某个email 信箱了。假若你想要同时监视多个email 信箱，只要为每一个信箱创建一个线程并且在线程中定期调用POP3CheckMail 函数即可。你的程序中如果没有使用Delphi 的控件，那么一个完整的信箱监视程序可能只有60K 左右。 C++Building制作闹钟 " B$ j2 G7 j9 p3 k B6 Z3 P- e
---- 大凡热恋中的网虫都曾经陷入下列的困境：约好女/男朋友晚七点半在老地方等，却在计算机面前一直爬行到深夜，等反映过来，朋友早已拂尘而去，又得几天的功夫去陪礼道歉。朋友何不按以下步骤做一简单的闹钟，让你安安心心上网，大大方方约会。你只要在上网的时候打开此应用程序，设置好约会时间（当然也可以是默认好的）即可。时间一到，音乐响起，快去约会吧。 ---- 本闹钟程序有以下组件组成： 序号组件类型组件名称功能
& X9 ^+ j. S: r+ `6 ~1 Tlabel l_Clock_1 显示“输入日期” " D: D+ P0 u8 w( w# s
2 TdateTimePicker dtp_Clock_1 选择日期 N* |+ o' S, x5 _3 [# ~
3 Tlabel l_Clock_2 显示“输入时间” / R( A8 i" h8 T2 P
4 TdateTimePacker tdp_Clock_2 选择时间
1 k& S8 e# o% _: Y4 u' F7 [5 TmediaPlayer mp_Clock 演奏音乐
4 G+ e) @8 h, V' k- d6 Tbutton b_Clock_Open 重新打开
; q# c* k" I9 i2 ?* h' @1 B3 I7 Ttimer t_Clock 定时检测
5 ~! a; i9 k3 K8 q+ F' k8 Tbutton b_Clock_Close 关闭应用程序 ---- 屏幕组件一览表 ---- 屏幕组件一览图 ---- 说明：dtp_Clock_1 的Kind属性设置为dtkDate ， dtp_Clock_2 的Kind属性设置为dtkTime，mp_Clock 的FileName属性设置为你主机上存在的任何mid、wav、avi文件。t_Clock 的Interval属性设置为10。 ---- 事件说明如下： ①、 t_Clock的OnTimer :
' j6 F4 ^# t: `- p+ [{
* Y- E8 O% x1 C/ h6 N//按时触发演示程序 3 q0 A# X1 K9 g( F
struct date d; - }' a, O; x2 v8 i
struct time t; % G9 e( u3 [4 t4 x! w2 P, j/ V5 W; m
AnsiString thour,tmin,tsec; 8 w b+ d4 P# F7 m5 I' W4 \
int dyear;
3 j; r/ [% f/ }int dintyear;
% R) t% u+ L3 s3 {int dmon,dday;
 |& m& { Q) F# \5 D8 m2 ZAnsiString tinthour,tintmin,tintsec; $ U+ S6 E0 v- \0 i' P
AnsiString dintmon,dintday;
& i& s! T' O' ^2 ~1 t//取当天日期 ; S: r! L5 i; e2 I) X; ]
getdate(&d); 2 H4 _" M5 W9 p+ v: _9 t8 K) ]
dyear=d.da_year;
! ?0 y+ n4 }* L, R. kdday=d.da_day; / P( z0 s. s h6 }- j$ p# w
dmon=d.da_mon; ! ~$ D5 \0 [8 p0 w% _) A
dintyear=StrToInt(dint.SubString(1,2));
" w% D0 R6 A9 Y. }3 `9 T, C8 sdintmon=dint.SubString(4,2); + l' h. t8 t* _. M6 C0 N
dintday=dint.SubString(7,2); 9 u; @% C& _ S( H
//取当时时间
' u1 T( F2 Z- d1 T" g/ X5 ~( igettime(&t); * A, K0 F# G! }. z6 R
thour=AnsiString(t.ti_hour); ( {7 j9 X2 x" I% g9 x+ v5 _
tmin=AnsiString(t.ti_min); 5 F/ A- ]' s! ? C
//tsec=AnsiString(t.ti_sec);
- Z! e* w) q0 i n- ?! ?! h; j//tint=AnsiString(DateTimePicker1- >Time);
0 b3 c. ]" c9 p) _" ptinthour=tint.SubString(10,2); & k3 Y( k1 y- b
tintmin=tint.SubString(13,2); . {6 P4 S8 d+ |3 i6 q# |
//tintsec=tint.SubString(16,2); 3 d% Q; H/ w3 i7 N+ t5 r& y
//闹钟服务功能
5 k) H. N" k# d+ Lif ((StrToInt(thour)==StrToInt(tinthour))&&
- Y! x" H7 i; {" i: Y8 {/ H6 c' `' u(StrToInt(tmin)==StrToInt(tintmin)) . p* J3 j7 Y; G0 _$ W, \1 @
&&(StrToInt(AnsiString(dyear).SubString(3,2))
1 ^% b2 _) P1 o& v+ x==dintyear)&&(StrToInt(dmon)==StrToInt(dintmon)) # I4 d9 `; Q9 a8 b: b
&&(StrToInt(dday)==StrToInt(dintday)))
2 t6 g: Z1 j" G{ 9 G- o$ W. a8 p3 J1 v' ~/ f# o1 [
dTimer- >Enabled=false; . o" T f1 f0 I# I& S d" E2 p
MediaPlayer1- >Open();
! Q. d8 ^5 \1 |* VMediaPlayer1- >Play();
; w4 L( q* t& R; ~}
' N3 u8 e1 `: u0 N} 8 J7 D0 _! m: ^1 E: O! Q. E
②、 b_Clock_Open 的OnClick：
! t @: e6 X% C{
+ ?5 T0 k( I: e9 g& C& b2 yt_Clock- >Enabled=true; , s$ G2 l5 H7 i5 a; P$ ^3 L; f% R
}
. r* ]6 Z3 h+ B0 _- Y③、 b_Clock_Close的OnClick
& d! f' ?3 R& P$ A$ s* U& \2 }+ V{
' P$ U' r, b- Z# }" q lApplication- >Terminate();
2 A! L+ ?% z( p) F" N/ Q" y* E} ---- 当然此程序还可以拓展、细化，如我仅将触发条件检测到分，当然它完全可以检测到秒，也可以仅检测到时。 3 [& @/ {6 T0 G( V9 u8 r) T) j' \
拨号上网IP地址的检知 
4 z& R7 `- v% R% m+ H随着INTERNET在世界范围内的迅速普及，上网的人数也越来越多。其中，绝大多数人是通过普通电话线拨号上网的。我们知道，每一台上网的计算机，不论是用何种方式上网，都被分配了一个或多个独立无二的IP地址。对于拨号上网的用户，一般是由其ISP在其每次拨号上网时动态分配一个IP地址，这个地址可能每次都不相同（其原因主要是为了充分利用有限资源）。那么，我们能否通过某种方法随时方便地检知自己上网时的IP地址呢？答案是肯定的。下面我们就用C++BUILDER编制一个小巧的程序来实现这种功能。（注：本程序在局域网中也同样能运行） + Z# @) ~( Y; [( Q; K/ O3 B
---- 首先用BCB的FILE菜单下的New Application创建一个新项目，取名为Ipcheck.bpr。 ---- 然后，在窗体FORM1上添加五个标签（LABEL）和两个按钮(BUTTON),如图所示。 ---- 接下来，双击窗体的OnCreate事件，在其中加上以下程序： void __fastcall TForm1::FormCreate(Tobject *Sender) % A9 C" i' N) |- G% p* z
{
& ]% l- i+ \3 g Y) ~/ tWSAData wsaData; if (WSAStartup(MAKEWORD(1,1),&wsaData)!=0)
& S) I# d* w' }; t& A# M5 Z{ //初始化WINSOCK调用 MessageBox(NULL,"Wrong WinSock
1 a& D, T) V# Z# ?8 l- o" ]Version","Error",MB_OK);
2 ]7 {! Q6 V V/ M7 preturn ; ) J2 C7 E3 L5 c, e$ U y5 s
} Refresh1Click(Sender); //程序一开始，就调检知IP地址 , A. \) g) P0 t7 g* ]3 A7 J& }
} 再双击Refresh按钮，在其中加上以下程序 void __fastcall TForm1::Refresh1Click(Tobject *Sender) " u( @8 G+ _- E1 Z0 I' [, Y
//刷新IP地址 R5 R) `' i# \ H9 \+ [" Q% \
{ 4 g+ B P( d8 b
char HostName[80]; LPHOSTENT lpHostEnt; struct in_addr addr[2]; //本程序假设主机不是多宿主机，即最多只有 // 一块网卡和一个动态IP ! ]& c |6 }) F# ~: i
for (int I=0; I< 2; I++){ & ~* f/ W8 K8 R. J$ Y4 ]6 V" L
memset(&addr[I],0,sizeof(in_addr))； 5 X, z0 C( \, x: M! Q: y* n
//对in_addr结构清0，以利后面填写 } if (gethostname(HostName,sizeof(HostName))==SOCKET_ERROR) { // 得到本主机名 MessageBox(NULL,"Can't getting local host name.","Error",MB_OK); 3 n) M8 _. n0 H: a: ~
return ;
* z: ]3 c/ A+ J$ \* w" C} Label3- >Caption=HostName; lpHostEnt=gethostbyname(HostName);//利用得到的主机名去获得主机结构 if (!lpHostEnt){ MessageBox(NULL,"Yow! Bad host lookup.","Error",MB_OK); return ; } for (int I=0; lpHostEnt- >h_addr_list[I]!=0; I++) //从主机地址表中得到IP地址 { memcpy(&addr[I],lpHostEnt- >h_addr_list[I],sizeof(in_addr)); } Label4- >Caption=inet_ntoa(addr[0]); Label5- >Caption=inet_ntoa(addr[1]); } 再双击Refresh按钮，在其中加上以下程序 void __fastcall TForm1::Button2Click(Tobject *Sender) { WSACleanup(); //释放WINSOCK调用 Close(); } ---- 最后，不要忘了在程序头部加上#include<winsock.h>.....哦。 ---- 好了，程序完成了，编译后就可运行了。本程序在中文WIN95/NT4.0下编译通过。 
6 E4 s- h* X* |! U P用C++ Builder编写Tray程序 . x: v( i5 v1 n1 r7 A
Tray(托盘)是Windows9x任务条上的一个特殊区域，它的技术名称为“任务栏布告区”，一些软件(如金山词霸Ⅲ)运行时会在托盘上放置一个图标，使用户一眼就能知道这个程序正在后台运行，要想激活它也很容易，通常只需单击一下这个图标即可，非常方便。
$ N. p! x& N+ A7 i1 x: G' N" i　　Tray的编程比较特殊，但并不难，主要包括图标、工具提示和消息等三个方面，它是Shell编程的一部分。ShellAPI提供了Shell-NotifyIcon函数，用它可以增加、删除或者修改托盘中的图标，在托盘上放置图标后，Windows Shell会负责把发生在图标上的鼠标事件通知应用程序。Shell-NotifyIcon函数定义如下： 　　WINSHELLAPI BOOL WINAPI Shell-NotifyIcon(DWORD dwMessage,PNOTIFYICONDATA pnid); 　　dwMessage表示要完成的操作：NIM-ADD(增加图标)、NIM-DELETE(删除图标)、NIM-MODIFY(修改图标或提示文本)，pnid是一个指向NOTIFYICONDATA结构的指针，结构的定义如下： 　　typedef struct -NOTIFYICONDATA{ 　　DWORD cbSize;//结构所占的字节数，必须用结构的大小来初始化。 　　HWND hWnd;//接受Tray图标消息的窗口句柄 　　UINT uID;//由应用程序定义的图标ID 　　UINT uFlags;//用来鉴别那些需要改变其值的域，NIF_ICON表示hIcon有效，可用来修改图标，NIF_MESSAGE表示uCallbackMessage有效，用来定义消息，NIF-TIP表示szTip参数有效，可修改工具提示。 　　UINT uCallbackMessage;//应用程序定义的消息 　　HICON hIcon;//Tray图标的句柄 　　char szTip[64];//工具提示的文本 　　}NOTIFYICONDATA; 　　下面我们就通过一个具体例子来说明实现方法，程序运行时不会显示主窗体，只在托盘上增加一个图标，双击图标可关闭程序。 　　程序运行时托盘区显示如下： 　　新建一个工程，放置一个Timer控件到窗体上。打开unit1.h文件，增加头文件说明＃include <shellapi.h>，在TForm1定义的private段增加一些数据成员和方法的声明： 　　unsigned int iconmessage;//定义的消息 　　void AddTrayIcon();//在托盘上增加图标 　　void RemoveTrayIcon();//从托盘中删除图标 　　由于要增加对自定义消息的处理，所以必须重载窗口过程函数WndProc，在TForm1的定义中增加protected段：virtual void --fastcall WndProc(Messages::Tmessage＆ Message); 　　在unit1.cpp中定义相应的成员函数： 　　void TForm1::AddTrayIcon() 　　{ 　　NOTIFYICONDATA icondata; 　　memset(＆icondata,0,sizeof(icondata)); 　　//将结构icondata的各域初始化为0 　　icondata.cbSize=sizeof(icondata); 　　icondata.hWnd=Handle; 　　strncpy(icondata.szTip,″未知状态″,sizeof(icondata.szTip)); 　　icondata.hIcon=Application－>Icon－>Handle; 　　icondata.uCallbackMessage=iconmessage; 　　icondata.uFlags=NIF-MESSAGE|NIF-ICON|NIF-TIP; 　　Shell-NotifyIcon(NIM-ADD,＆icondata); 　　} 　　void TForm1::RemoveTrayIcon() 　　{ 　　NOTIFYICONDATA icondata; 　　memset(＆icondata,0,sizeof(icondata)); 　　icondata.cbSize=sizeof(icondata); 　　icondata.hWnd=Handle; 　　Shell-NotifyIcon(NIM-DELETE,＆icondata); 　　} 　　重载TForm1的WndProc函数，加入对自定义消息的处理代码，这其实相当于创建了TForm类的子类。 　　void __fastcall TForm1::WndProc(Messages::TMessage＆ Message) 　　{ 　　if(Message.Msg==iconmessage) 　　{ 　　 if(Message.LParam==WM-LBUTTONDBLCLK) 　　 { 　　 Application－>Terminate(); 　　//如果双击图标，则关闭应用程序 　　 } 　　 return; 　　} 　　TForm::WndProc(Message);//对于其他的消息，调用基础类的WndProc函数让Windows进行缺省处理。 　　} 　　创建窗体的OnCreate事件句柄: 　　void --fastcall TForm1::FormCreate(TObject ＊Sender) 　　{ 　　iconmessage=RegisterWindowMessage(″IconNotify″); 　　AddTrayIcon(); 　　} 　　这里通过调用RegisterWindowMessage函数来定义一个用户消息，也可以通过WM_USER＋n来获得一个系统没有使用的消息编号。 　　void --fastcall TForm1::FormDestroy(TObject ＊Sender) 　　{ 　　RemoveTrayIcon(); 　　//窗体在关闭时删除托盘中的图标 　　} 　　编写Timer1的Timer事件代码，当用户将鼠标停留在图标上时，显示提示文本： 　　void --fastcall TForm1::Timer1Timer(TObject ＊Sender) 　　{ 　　NOTIFYICONDATA icondata; 　　memset (＆icondata, 0, sizeof (icondata)); 　　icondata.cbSize = sizeof (icondata); 　　icondata.hWnd = Handle; 　　String s=″我的图标!″;//定义提示文本 　　strncpy (icondata.szTip, s.c_str(), sizeof (icondata.szTip)); 　　icondata.uFlags = NIF-TIP ; 　　Shell-NotifyIcon (NIM-MODIFY,＆icondata); 　　} 　　程序运行时不显示主窗体，只在托盘上放置相应的程序图标，从C＋＋ Builder主选单中选择View|Project Source，在WinMain函数的Application→Initialize()语句后增加代码： 　　ShowWindow(Application→Handle,SW-HIDE); 　　Application→ShowMainForm=false; 　　按F9编译并运行程序，托盘上就会出现相应的图标。以上代码在C＋＋ Builder3、Pwin98环境下编译、运行通过。 6 K9 v* x& j; K$ F& E
怎样用代码来最小化或恢复程序 
- k; u8 o' r, p7 ^ N0 f0 p你能够用下面三种方法之一来实现它。
6 v; y) x2 H, U4 m. r- l4 C方法一：发送一条Windows消息到主窗口的Handle属性或 Application->Handle。这条消息就是 WM_SYSCOMMAND，将 wParam 设为 SC_MINIMIZE 或 SC_RESTORE。你可以调用SendMessage API函数来发送消息。 // 设置WPARAM为SC_MINIMIZE来最小化窗口 SendMessage(Application->Handle, WM_SYSCOMMAND, SC_MINIMIZE, 0);　 // 设置WPARAM为SC_RESTROE来恢复窗口 SendMessage(Application->Handle, WM_SYSCOMMAND, SC_RESTORE, 0); 方法二：调用 ShowWindow API 函数。 你必须传送Application对象句柄到ShowWindow函数。如果你传送给ShowWindow函数的句柄是主窗口，那么主窗口将最小化到桌面(desktop)而不是任务条(taskbar)。 // 最小化：传送 SW_MINIMIZE 到 ShowWindow ShowWindow(Application->Handle, SW_MINIMIZE);　 // 恢复：传送SW_RESTORE 到 ShowWindow ShowWindow(Application->Handle, SW_RESTORE); 方法三：调用Application对象的Minimize或Restore函数。 // 调用Minimize最小化应用程序 Application->Minimize();　 // 调用Restore恢复应用程序 Application->Restore(); 调用Application的方法较易用，但发送WM_SYSCOMMAND消息功能更强。 另外，WM_SYSCOMMAND消息允许你最大化程序，改变光标为帮助光标，滚动程序，移动一个窗口，改变窗口大小，甚至模拟Alt-TAB切换到另一窗口。紧记，实现这些功能用API函数更好。 尽管调用ShowWindow也能工作，你大概也不想用它来最小化或恢复程序。当隐藏的窗口被最小化时ShowWindow会引起最小化动画出现。这看上去稍微有点傻，因为动画是从程序主窗口的位置远离中心。 
: E' p8 W8 k: Y( X制作主窗口显示前的版权窗口 在工程文件中选File->New Form新建一个窗口，设计好窗口的外观。
) _2 W5 R& k: Z* j$ M3 \给窗口起名为AboutBox，源文件命名为AboutBox.Cpp 选Project->Options，将新建的窗口从自动建立中去掉。 选View->Project Source，打开工程文件的源文件，加入句子。 #include "AboutBox.h" WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) { DWORD lTime; try { Application->Initialize(); AboutBox=new TAboutBox(AboutBox); AboutBox->Show(); AboutBox->Update(); lTime=GetTickCount(); Application->CreateForm(__classid(TMainForm), &MainForm); while((GetTickCount()-lTime) / 1000 <3); AboutBox->Hide(); AboutBox->Free(); Application->Run(); } catch (Exception &exception) { Application->ShowException(&exception); } return 0; } 
. j6 y N5 P: u3 X% z) a# {判断是否已经联到 internet 
0 J- `/ L u5 E, T/ {& L; T使用 NetMasters Powersock 控件读取本地IP 地址，如果是"0.0.0.0" 说明没有连接。
7 ?$ S" n: i6 }) Y% F# y. e例子： & s: r! j7 [1 r9 g$ h5 v
void __fastcall TForm1::Button1Click(TObject *Sender)
3 U/ E; o4 a; B g{ $ J, \3 ~" y; z- b. u- s1 M- I
if (Powersock1->LocalIP == "0.0.0.0") # c: V d! h9 C7 @
ShowMessage("not connected");
3 Z4 Y% f7 G7 felse
9 t. G' O( t; LShowMessage(Powersock1->LocalIP);
4 m" u3 a. a) e0 ^: }6 u8 j+ [, k} 获取登陆用户名 ) B6 Q: u0 ~' R2 t T
　void __fastcall TForm1::Button2Click(TObject *Sender)
4 |/ v W6 J9 X{
$ ]! y6 E4 b1 eDWORD dwSize = 0; 2 X. y$ q+ {' _1 M6 U; c
// 确定字节所需内存
' v+ @4 y, R) G3 d/ EGetUserName(NULL, &dwSize); / d( O, O: F, ?9 i. ?; {* J* J4 C
// 定义缓冲区
/ W6 S' H* d b2 \6 l7 ^char *szBuf = new char[dwSize];
. G7 [3 b. E2 o2 s- K! H0 JszBuf[0] = '\0';
' T" Z( I& ]& R9 B4 R+ Y5 O// 读用户名 7 _. g) K; }* g4 s. o7 _& y
GetUserName(szBuf, &dwSize); 7 ]% R5 ^# U' e- ?2 }
Label2->Caption = szBuf; , v; N" Y5 @3 B, X8 o0 R. L
delete [] szBuf; 5 N6 P8 n; U5 c/ N& Q" ?
} 隐藏桌面图标 - ^2 x0 o4 O3 a
void __fastcall TForm1::Button1Click(TObject *Sender)
$ }' N+ D4 s' x5 n{
; P8 P& w9 C4 c2 y+ IHWND hDesktop; // 获取桌面句柄
! h; r( o) V( y+ A- ~# WhDesktop = FindWindow("ProgMan", NULL);
% l2 S8 E% |) o// 隐藏桌面上的图标
% M# ^) ^- {7 D6 Q1 hShowWindow(hDesktop, SW_HIDE);
" ?8 t8 n1 x( g! u} 5 F1 S3 Z$ K! _! K- z; ^
//--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) : b) O8 F; B, E- ~6 }
{
9 n: F& G4 l* u/ r# qHWND hDesktop; hDesktop = FindWindow("ProgMan", NULL); # c$ e7 V9 r4 n- M
// 显示桌面上的图标 3 B. Z- C: Y2 b7 i9 E7 y
ShowWindow(hDesktop, SW_SHOW); 0 Y$ k- _2 ^8 m& M1 @5 D
} 程序启动时运行 
+ A/ E' I8 j1 V5 ^$ R! _* Qvoid __fastcall TForm1::Button1Click(TObject *Sender) ) t$ a* o5 Q( S; j O. }$ v/ U( H
{ - n: e' \( q: I0 i7 y2 Z, X
TRegistry* Reg;
9 b) s( E) q' q4 [: wchar AppFileName[256]; if( Edit1->Text=="" ) // 判断文件名是否为空 c$ s( N4 B* E* \6 |
{
- X5 a( a, ~! B$ m, gMessageBox(Handle,"应用程序名称不可以为空。","错误",MB_OK+MB_ICONERROR); - @& X0 z+ @% w4 P8 L" c! Q
exit(0); ! w+ V, r! f1 a/ q# W) }' b
}
4 \3 w6 a$ p. u5 W2 wEdit1->GetTextBuf(AppFileName, 256);
- G. e8 S# u! j# Q- [$ x& y' a3 Z/ f4 sReg = new TRegistry();
9 I+ i$ ]* Q! s7 i6 K- utry
. n+ {7 j6 @ i0 V# x{ & X3 f9 ^7 I5 x# [0 Y
Reg->RootKey = HKEY_LOCAL_MACHINE; - O5 Q2 s1 K, Y$ L
if( Reg->OpenKey("Software\\Microsoft\\Windows\\CurrentVersion\\Run", FALSE) )
7 e6 K+ \9 Y7 ?" [{ # p2 ^1 q6 \, {) r3 {
// 在注册表中添加数值
0 I; n- ?" C! l: ?' v ?" AReg->WriteString("StartUp1",AppFileName);
}
( W6 Q& l) m' Q! Nelse
, e, S" E# Q* ^# c- g7 |& rMessageBox(Handle,"打开注册表失败。","错误",MB_OK|MB_ICONERROR);
- S" h( e6 M [. I0 B- R5 K5 z}
. ~6 O/ X6 X3 }$ d: Mcatch(...)
1 X) j. }* o7 \$ K{
 _1 q* o! l) W4 J6 f* a _, OReg->CloseKey(); % t0 V. D: r* e; p
Reg->Free(); " X% y8 g7 P4 @$ c( M
} 9 i" e9 ^9 X! M" V( p" h
} 控制面板的调用 % T) z& i- u' @
　
; t6 m2 K9 `$ uvoid __fastcall TForm1::Button1Click(TObject *Sender)
- F K {( ~5 `/ y0 z7 q" h6 [5 o{
( @8 v6 S+ S f5 P: n6 hUINT Res; // WinExe的返回结果 // 显示控制面板
1 k: P2 I R* ?$ H) A. ]7 ARes = WinExec("rundll32.exe shell32.dll,Control_RunDLL",9);
; y& Q5 l# M3 M q4 W2 w7 aif( Res==0 ) * j, r4 B0 f1 o8 w$ \; n, u
MessageBox(Handle, "程序超出内存。", "错误", MB_OK|MB_ICONERROR); ( A: }7 G/ V2 B7 J" t2 M) t# F
else if( Res==ERROR_BAD_FORMAT )
$ }+ y, @ }, c8 J) MMessageBox(Handle,"命令错误。", "错误", MB_OK|MB_ICONERROR); # b0 p N* P' i. u5 r
else if( Res==ERROR_FILE_NOT_FOUND ) ( q3 n& b$ J* @' S5 I: z$ l
MessageBox(Handle,"指定文件没找到。", "错误", MB_OK|MB_ICONERROR);
& K. ]) R s+ w1 _* E1 }0 Y4 qelse if( Res==ERROR_PATH_NOT_FOUND ) ( Q' A5 y: ~ n! A
MessageBox(Handle,"指定路径没找到。", "错误", MB_OK|MB_ICONERROR); / {2 D8 D+ `, [' l# ~
} $ Y. b s9 L3 k
//--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) ( B, H; ?: |: k
{ ; B6 _5 ^" D$ _/ a
// 辅助选项 | 键盘 . J) q; C" X9 O: M' v
WinExec("rundll32.exe shell32.dll,Control_RunDLL access.cpl,,1", 9); - L( `, F% ?) U; Y8 H* z* C
} : C" N' M4 W# X$ V
//--------------------------------------------------------------------------- & ]. r, n/ c' q6 {! u2 A/ I* N/ Y1 O
void __fastcall TForm1::Button3Click(TObject *Sender) $ D$ z( ?8 U% W! H
{
9 t5 i( c7 {( n* {2 p3 }// 添加/删除程序属性 | 安装/卸载
4 B# ]" x* D% `5 X5 n9 C3 ]WinExec("rundll32.exe shell32.dll,Control_RunDLL Appwiz.cpl,,1", 9);
/ p: W9 g; U* j8 q: d} . S( h4 I1 J9 |4 ]$ {! _( n g
//---------------------------------------------------------------------------
( Z) z5 A3 J% @# ^; M. \) wvoid __fastcall TForm1::Button4Click(TObject *Sender) 2 g7 ~+ N7 F7 ^
{ ' |+ q, O( k" h# z0 c+ y7 z
// 显示属性 | 背景
/ N" g. S% ]' O4 l$ ?1 g# V' ~WinExec("rundll32.exe shell32.dll,Control_RunDLL desk.cpl,,0",9);
) c& ?" `6 A& ^# I} % G: x. E( Y9 c/ m: a
//--------------------------------------------------------------------------- ! L6 T8 R4 a" f+ Q$ s7 i9 p {
void __fastcall TForm1::Button5Click(TObject *Sender) ; T$ ?, n& x `' P0 T- L1 p
{ $ K3 d" V0 k9 w w5 z
// Internet 属性 | 常规 , p' k. O9 E' k* O c
WinExec("rundll32.exe shell32.dll,Control_RunDLL Inetcpl.cpl,,0",9); ! E' M; |; f6 N, P. Q! U
} , N8 M$ a) n9 w# N
//---------------------------------------------------------------------------
8 ~% T$ `( l% M5 B/ v; i/ ]8 y1 avoid __fastcall TForm1::Button6Click(TObject *Sender)
; G. x0 s# a/ B! o" R! G{ $ `' M) c8 [: n' z
// 区域设置属性 | 区域设置
1 }, f; Q. f$ M4 \/ J/ AWinExec("rundll32.exe shell32.dll,Control_RunDLL Intl.cpl,,0",9); % }6 h& T: ~4 z' K( A% P
} # \ v( p/ h3 X# Z3 s
//--------------------------------------------------------------------------- 5 i1 \* n+ y2 _, Z: d
void __fastcall TForm1::Button7Click(TObject *Sender) 7 P7 i8 ^4 M4 D L5 r
{
* K) O2 m( F0 B- p0 J// 游戏控制器 | 一般
8 M( M/ l8 l: pWinExec("rundll32.exe shell32.dll,Control_RunDLL Joy.cpl,,0",9); 2 {7 m3 a% w; i
}
) U0 C9 t) H7 r9 h//---------------------------------------------------------------------------
1 y8 @% c3 g. Svoid __fastcall TForm1::Button8Click(TObject *Sender) % w8 \+ x2 \3 n5 Y: R- \. M
{
: o6 v( [8 v8 Q9 l$ S1 k% W3 r( U// 鼠标属性 | 按钮
9 ]+ S1 \, ?% s5 h7 e7 t) Y1 iWinExec("rundll32.exe shell32.dll,Control_RunDLL Main.cpl",9); 5 o$ |+ _/ ^+ C# F
}
" r! _3 |* u4 ^! E+ _//---------------------------------------------------------------------------
% ^/ C) a) s3 U, r8 N& l5 U+ O4 ^- lvoid __fastcall TForm1::Button9Click(TObject *Sender) + A: \( s7 ~" C& C1 C0 o
{ ]: g1 W* T1 \1 j
// 多媒体属性 | 音频
7 Q% W- }% u2 {WinExec("rundll32.exe shell32.dll,Control_RunDLL Mmsys.cpl,,0",9);
+ ?. t8 S6 M* U4 B! ^* G} 7 j/ g, H I: {3 Z3 V7 b6 _! A
//---------------------------------------------------------------------------
) s; E4 [9 O6 S& rvoid __fastcall TForm1::Button10Click(TObject *Sender) ; Z. m4 u4 V: J. f- j: ~! y
{
& }. g0 U4 \# c% y, E; B$ }1 ~0 O// 调制解调器属性
% O, n4 H6 ?9 k3 _4 A3 DWinExec("rundll32.exe shell32.dll,Control_RunDLL Modem.cpl",9); 5 b1 Z; z' A7 c4 I8 P
} 3 B1 b. x. G2 }- @6 [2 y
//---------------------------------------------------------------------------
: S- H6 Z: C# X& Bvoid __fastcall TForm1::Button11Click(TObject *Sender)
' C8 s% X% V6 ?3 m{ # i0 i0 H) Z! D* b7 l
// 网络 | 配置
( F2 Q O* T4 A( K, oWinExec("rundll32.exe shell32.dll,Control_RunDLL Netcpl.cpl",9);
1 J1 q6 I, P. ^: {' `} 8 `7 F7 @9 k0 K% v9 l
//--------------------------------------------------------------------------- 9 i2 y9 P% E0 @ v! H
void __fastcall TForm1::Button12Click(TObject *Sender) - B" \1 a0 Q4 \ [
{ & h, u) E3 J0 Z* A3 Q0 O9 R
// 密码属性 | 更改密码 . B* R% \0 w3 e8 C* A& a6 u
WinExec("rundll32.exe shell32.dll,Control_RunDLL Password.cpl",9);
+ s+ ` J! j. v4 {. P7 l$ y; D}
6 h( b! g K; ^+ x! E1 I3 g//---------------------------------------------------------------------------
# G/ f+ o7 M- e" ]$ Q9 c: Lvoid __fastcall TForm1::Button13Click(TObject *Sender)
3 X3 M2 J4 B% v. v{ $ e9 v0 z( I* G6 ^- m' H# q' H# m
// 扫描仪与数字相机属性 | 设备 , f, B+ r, G# L
WinExec("rundll32.exe shell32.dll,Control_RunDLL Sticpl.cpl",9);
# B: r7 E* F$ v}
0 r: p9 E6 Q* v" _//--------------------------------------------------------------------------- 0 l/ F( {- |3 [, L& o
void __fastcall TForm1::Button14Click(TObject *Sender)
4 R7 K: Q% J" E# }' e{ 2 \" u3 c+ i+ w4 F. R" L- `
// 系统属性 | 常规
* ]8 u( z3 J/ p+ y! E. M+ l8 OWinExec("rundll32.exe shell32.dll,Control_RunDLL Sysdm.cpl,,0",9); 7 C# n1 N q. p/ \
}
/ T/ N: r( F6 T3 K( [//--------------------------------------------------------------------------- ! P+ }6 A5 A- D
void __fastcall TForm1::Button15Click(TObject *Sender)
% k j3 O* M) ]. L& m7 n{
 a2 M* @* h4 D& u% T, h# e! f& P// 日期/时间属性 | 日期和时间
 [2 o; J, l, g- UWinExec("rundll32.exe shell32.dll,Control_RunDLL timedate.cpl",9); " X7 T1 e9 P8 j, q4 Q D
}
( v3 P4 C( C L1 m- o' v//--------------------------------------------------------------------------- 5 z# K G6 C) @- O3 z7 n4 N
void __fastcall TForm1::Button16Click(TObject *Sender)
6 q" O% ~" m' P{ 8 M+ A9 x/ u% B4 G1 Z: u' a
// 电源管理属性 | 电源方案 # B P3 R3 H, G @
WinExec("rundll32.exe shell32.dll,Control_RunDLL Powercfg.cpl",9);
( m5 V6 n0 N- B; d7 Z+ O* o0 S} + r# W+ W1 S1 |7 j5 W
//--------------------------------------------------------------------------- 5 |6 h9 L6 W, N1 [* u! `
void __fastcall TForm1::Button17Click(TObject *Sender)
* t. w1 p/ t$ @& w# M! K{ 5 c0 x$ c: d$ k- ~8 j/ D7 v
// 拨号属性 | 我的位置
; T/ \% V1 Q' u, X- cWinExec("rundll32.exe shell32.dll,Control_RunDLL Telephon.cpl",9);
) W& w3 _ Y# X6 H1 F! ]( m} 模拟键盘按键 　 0 r' H2 K1 l8 r$ @
void __fastcall TForm1::Button1Click(TObject *Sender)
" f" ^/ y# W5 G% D) d( L) A{ ! B+ K- k4 w6 N8 i% ~0 L6 t
// 模拟在Edit1组件中按下了字母a键 4 V$ n' G: s. ~: m3 i
PostMessage(Edit1->Handle, WM_KEYDOWN, 65, 0); # e7 E/ I) r( {$ z' @9 ~ k
} , N2 ~+ M1 A& d7 F9 i4 H
//--------------------------------------------------- void __fastcall TForm1::Timer1Timer(TObject *Sender) ; s+ u- x4 T" A' j
{ & d4 H6 |* b) {4 C; ^
// 模拟在窗体Form1中按下了Tab键 ) p' Q% _1 s8 y5 d7 o1 O/ C
PostMessage(Form1->Handle, WM_KEYDOWN, VK_TAB, 0); & a7 Y" |+ a' N2 \2 h: h% L
} : z: ]' f) W- S% w4 R# F
//------------------------------------------ 
, x& r) E0 A3 ~! Q) A让标题栏闪烁 8 V @3 F: ^9 G4 o5 a0 H, J
　
: o: Z; ^* r+ O/ o6 u( X0 [2 Z# ]0 Nvoid __fastcall TForm1::Button1Click(TObject *Sender)
4 M# ~* i( n* j' l( G{
1 G4 ] D5 R5 v y( f% s// 激活定时器
7 f% E( b3 E# S2 g: q9 bTimer1->Enabled = true; " Q2 }; H& p6 }. j2 j3 s- B/ O
} 7 S }5 c3 o* _
//--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender)
; N% D( g% E6 q# l! k1 O h{ $ l0 w& N9 E) u5 p' [" S# s
// 禁止定时器
& X+ ?# I `+ M* T7 FTimer1->Enabled = false; ) {' o) H8 K$ D: L
// 使窗体恢复原状 1 m8 X0 g, |; S) d/ Y0 \
FlashWindow(Handle, false); % m% Y) s$ P+ Z( r, }; Y7 }
}
! \6 i! N: {5 l& P6 U//--------------------------------------------------------------------------- void __fastcall TForm1::Timer1Timer(TObject *Sender) ) V6 I9 |1 N! K% B
{ 2 H* l, ?* G* \
// 使窗体标题栏闪烁 , T" l5 Z. N- Q/ p: O, `
FlashWindow(Handle,True); 8 k: K5 a) x5 v8 z' w/ H: A6 J7 k
Beep(); // 声音提示 9 p I& E% e3 \& r0 B6 ]0 ~& ~
} ) r. z8 b) U# ` Q6 Q- W
启动屏幕保护 
 E: E! _9 F7 N, i& w/ y　 : m; X4 w4 l8 R+ y5 b/ q( j! G/ A
SendMessage(HWND_BROADCAST, WM_SYSCOMMAND, SC_SCREENSAVE, 0); 
/ K/ D- e7 i, }0 q ], L年月日星期的取法 　 AnsiString iYear,iMonth,iDay,iHour,iMinute,iSecond; . s+ A7 o; g, M6 L3 }
iYear=Now().FormatString("yyyy");//取年 7 U! m- G5 E3 F' `" Q" v
iMonth=Now().FormatString("mm");//取月 ( E( F8 k; _/ W4 L
iDay=Now().FormatString("dd");//取日
" H4 {# E ^# \; Z) GiHour=Now().FormatString("hh");//取小时
4 g4 L' g; l. F" a' PiMinute=Now().FormatString("nn");//取分钟
& ]) Y2 I4 J5 K# o# {6 [iSecond=Now().FormatString("ss");//取秒 # i3 ^, P7 A8 k: L6 A
DayOfWeek(Now().CurrentDate()) 
& U0 B% b5 [+ H. s5 q& a2 ]键盘事件 1 K7 B, f& m$ b5 q7 k
　
5 v; Q1 W1 }$ O: B( Z4 n) w0 Wvoid __fastcall TForm1::FormKeyDown(TObject *Sender, WORD &Key, " Q+ ^! u: ~. x
TShiftState Shift) * B/ X3 }3 |3 R5 a7 I
{ / E% q; k2 X# T" N
if( Shift.Contains(ssShift) ) // 如果按下了Shift键则在第一个面板上显示Shift ' f/ l+ q; A! V9 q
StatusBar1->Panels->Items[0]->Text = "Shift"; 2 Y8 Q; ~4 O/ B3 S
if( Shift.Contains(ssAlt)) // 如果按下了Alt键则在第二个面板上显示Alt * y( w. h0 c, e& u/ J
StatusBar1->Panels->Items[1]->Text = "Alt";
* n0 H8 j/ V0 H2 ~/ g" Gif( Shift.Contains(ssCtrl) ) // 如果按下了Ctrl键则在第三个面板上显示Ctrl
: x- e$ t/ F# g! m! QStatusBar1->Panels->Items[2]->Text = "Ctrl"; : ~+ X" E; v" F" N. [ r
if( Shift.Contains(ssAlt)&&(Shift.Contains(ssCtrl))) // 如果同时按下了Alt+Ctrl键则在第二个面板上显示Alt+Ctrl $ W* z' |* w+ L0 ]
StatusBar1->Panels->Items[5]->Text = "Alt+Ctrl";
* M: a5 Z$ e7 c# V+ R8 l! S. a. j} 4 h! }5 `/ D4 ?" f( z; ?0 p
//--------------------------------------------------------------------------- 
8 X- _0 _6 w& E' Hvoid __fastcall TForm1::FormKeyUp(TObject *Sender, WORD &Key, " [+ H% T/ l: T5 _. M$ N5 X* T; M8 \
TShiftState Shift)
/ K- K Q3 f, c; k{
6 G$ W1 N; F( J7 H( Z+ w% r// 在Shift、Alt和Ctrl键弹起时清除状态栏中相应面板上的内容
' {) s4 c" _# Pif( !(Shift.Contains(ssShift)) ) % @- q/ J" J$ O z R/ n8 q
StatusBar1->Panels->Items[0]->Text = ""; 7 J& Z. \& f0 F5 c; M& p* L
if( !(Shift.Contains(ssAlt)) ) " V a5 o, Z+ k5 O0 G% }& q
StatusBar1->Panels->Items[1]->Text = ""; . ~* X# | Z6 h* a) Y$ z
if( !(Shift.Contains(ssCtrl)) ) , X7 c* ^+ B% V( {! K
StatusBar1->Panels->Items[2]->Text = "";
! x3 P/ @# L, Kif( !Shift.Contains(ssAlt)&&(!Shift.Contains(ssCtrl))) . S' f0 \6 E F
StatusBar1->Panels->Items[5]->Text = "";
7 O/ C( H* D4 ^1 Y2 n}
! Q- e! d+ U+ E# V//--------------------------------------------------------------------------- void __fastcall TForm1::FormMouseDown(TObject *Sender, TMouseButton Button, + }* @5 M! [0 @/ t8 Q
TShiftState Shift, int X, int Y)
! M" m' s3 @) w8 p{
& z! B) B$ t5 z J Z( X" j$ R8 Aif( Shift.Contains(ssLeft) ) // 如果按下了左键则在第四个面板上显示left ; a3 |! G) M3 ~! ?5 T( \7 k" X. H
StatusBar1->Panels->Items[3]->Text = "Left";
. S: ~/ P3 X+ ~. U. r. d8 G0 t! \; `9 wif( Shift.Contains(ssMiddle) ) // 如果按下了中键则在第五个面板上显示Middle ' s0 x; M: u" ~
StatusBar1->Panels->Items[4]->Text = "Middle"; * G/ ^% A) Z# } R3 ?
if( Shift.Contains(ssDouble) ) // 如果是双击则在第六个面板上显示Double
" m Q* G I1 j, t$ g6 l/ q" S. \StatusBar1->Panels->Items[5]->Text = "Double";
0 t8 K* E4 } A( i+ K# G- W3 p}
9 b+ C' X& H: c5 A/ ~4 H7 O//--------------------------------------------------------------------------- void __fastcall TForm1::FormMouseUp(TObject *Sender, TMouseButton Button,
 J" r- n( P9 c9 ^TShiftState Shift, int X, int Y)
% ?4 |$ h1 o9 |5 t: B! m{
2 n0 ? A* B, u2 ]; n// 在鼠标按键弹起时清除状态栏中相应面板上的内容
9 X2 U4 K9 P6 @( H4 aif( !(Shift.Contains(ssLeft)) )
" L" r4 c4 C6 E0 T( Z; vStatusBar1->Panels->Items[3]->Text = "";
2 D+ N b$ Y, c6 cif( !(Shift.Contains(ssMiddle)) )
% q. j( O* P( `StatusBar1->Panels->Items[4]->Text = "";
. Y; [5 f( v1 {7 t5 a( K6 Rif( !(Shift.Contains(ssDouble)) )
4 u" M0 H$ O: P2 b7 [3 wStatusBar1->Panels->Items[5]->Text = "";
9 f, y2 n! S4 C7 Q0 o} 　 ' W3 @1 C( i, T. n9 o) v ?
隐藏任务栏 8 m- z( h* L$ U
　 $ a, H. B4 X. V% [7 {
void __fastcall TForm1::Button1Click(TObject *Sender) , } E% B0 ]& l: s# g
{
 v9 N3 v* p1 G0 ^! F/ vHWND WndHandle; // 获取任务栏的窗口句柄 ) S, t6 c. q' j* n% o
WndHandle = FindWindow("Shell_TrayWnd", NULL); # f, N, o# K9 ~2 ^3 e( j
ShowWindow(WndHandle, SW_SHOW); // 显示任务栏 0 d3 {/ U8 B) G1 e
}
! j9 Q! }, O% R; I7 P- w//--------------------------------------------------------------------------- void __fastcall TForm1::Button2Click(TObject *Sender) 5 W5 Z2 Z, P$ l8 k
{ : Z% {2 x9 g# ^ p" t
HWND WndHandle; WndHandle = FindWindow("Shell_TrayWnd", NULL);
. j$ q p& V; g$ [! QShowWindow(WndHandle, SW_HIDE); // 隐藏任务栏
8 _1 k" g6 w9 {4 j} + w" A' c$ K4 c) ]
//--------------------------------------------------------------------------- void __fastcall TForm1::FormCreate(TObject *Sender)
8 [- R7 _6 ^! m4 ]; S* ]# c{
/ r; W5 h' X7 TSetWindowLong(Application->Handle, GWL_EXSTYLE, WS_EX_TOOLWINDOW);
6 r& t2 i$ o4 {8 y; ~% F. m( K& q0 P; l} 禁止关机 
! P& g2 Q# h# u( a4 W( V1.先打开头文件作如下修改： class TForm1 : public TForm 6 \7 L# y7 \* P4 Q" e
{ 4 k: F" f# q" {1 \3 c( B# _
__published: // IDE-managed Components 9 U# Y! l- e) g. K1 R6 Q
private: // User declarations
3 k% q: A( w3 X7 Nvoid __fastcall WMQueryEndSession(TWMQueryEndSession &msg);
& F& T) a1 I k6 n& R1 gpublic: // User declarations
2 E6 ^4 P0 F$ P9 C3 F* s( F__fastcall TForm1(TComponent* Owner);
. K# N, a# }4 c1 G! T& X nBEGIN_MESSAGE_MAP 0 a5 M4 d) s/ |# h: }/ K' B
MESSAGE_HANDLER(WM_QUERYENDSESSION,TWMQueryEndSession,WMQueryEndSession) 2 k- m- {' x2 K6 d& Y6 n
END_MESSAGE_MAP(TForm) ) o! v, v$ u8 p0 ` Y: w
}; ; f! h e) L- a9 Z. U. u
//---------------------------------------------------------------------------
* l x) ~/ z7 Nextern PACKAGE TForm1 *Form1; 2 J$ i8 }+ O- O) C6 u
//--------------------------------------------------------------------------- + Z5 j+ J6 j) @' u9 i" B
#endif 2.然后对unit.cpp文件添加如下代码： void __fastcall TForm1::WMQueryEndSession(TWMQueryEndSession &msg)
1 b6 D" v) g. W; {* s# L{ 2 T& g. _- c/ v3 Y6 D. e
msg.Result = 0; ( e p v0 Z! [9 Y0 z# B% u
ShowMessage("你不能关闭系统"); : q. k& S' V; U8 g
} 　 
; V# X. i$ X$ @3 u' l( y6 n0 a" H怎样以最小化方式启动程序 , o! E$ M: n7 [7 e- N4 Q/ U7 d5 s! V
可以调用Application->Minimize函数来最小化应用程序到任务条。如何你希望你的程序启动时就最小化，只需在调用Run方法前调用Application->Minimize就行了。 WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
8 ^3 O! q5 U0 a7 H& n{ ' G/ j: ?# a, y& c m' ?
try
; p! J5 r. S2 t, C' z. q6 r- K{ ! ?" w4 o9 f- w* i: m
Application->Initialize(); ; x* q4 \4 u! e; q- ~+ s
Application->CreateForm(__classid(TForm1), &Form1);
# N) M) S* `; }7 Y W0 YApplication->Minimize(); //以最小化方式启动 $ p) k7 e- |, r8 y1 L7 G: L
Application->Run(); 8 U* W7 W) M' ^- m! v2 {: Z; V( G
}
3 J5 u. |) E* V6 qcatch (Exception &exception) 0 G! U" j" U( K/ c
{
! b* H* F1 D+ c8 z9 b$ xApplication->ShowException(&exception);
2 _: P' d$ _* q; ^} # _; q8 o Y8 ~0 h3 K
return 0; * A O& _0 t3 B% P6 W; N
} 在Memo中增加一行后，如何使最后一行总能显示 * S" H3 U6 t. S0 J- [ y' J
SendMessage(Memo1->Handle,EM_SCROLL,SB_LINEDOWN,0 ) 
6 \: b# x( K4 Y! q# q设置壁纸方法 通过IActiveDesktop接口来实现 比如设置壁纸，就可以这样 IActiveDesktop *a; CoInitialize(NULL); if(SUCCEEDED(CoCreateInstance( Shlobj::CLSID_ActiveDesktop,NULL,CLSCTX_INPROC_SERVER, IID_IActiveDesktop,(void **)&a))) { WideString c = "C:\\My Documents\\yw2.jpg"; OleCheck(a->SetWallpaper(c.c_bstr(),0)); OleCheck(a->ApplyChanges(AD_APPLY_ALL)); a->Release(); } CoUninitialize(); 其它接口可查看msdn 注意在cpp的第一行加入#define NO_WIN32_LEAN_AND_MEAN 并要#include <shlobj.h> 
作者: sxbg8 时间: 2008-6-26 10:16
go 
作者: 葛玄奥初 时间: 2011-9-29 09:30
看一下看看看$ U' D6 [$ P$ _+ ]& z& B, @2 J& V
8 L% P& a) H6 I+ \( A0 u

9 p3 ]& g2 d% W5 k$ n/ Q' u
5 ~* `0 {" g' h9 Y7 }6 ]8 D* p( o% p4 k. `4 {, {1 h

4 Q2 {3 M; \' j; r

. N/ W: n! w$ Y8 [7 ^) R% z. [3 A w$ u/ y" t5 e
+ F- T3 T/ ?. E
7 o: y6 H5 m. _- N, _' K

9 p) K- \* f N2 E- C' }( J9 `( O d5 P- C" @
qnig.info**的好地方了不用花钱就可以天天**真是不错
作者: wobushichunzhu 时间: 2011-11-24 00:03
非常感谢楼主分享
作者: onestar 时间: 2011-11-29 17:40
不错不错，学习了
作者: sxjm567 时间: 2013-4-11 22:36
回帖是必须的，这个可以有！

欢迎光临数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5