博客园_得闲笔记

电子病历的进展

2012-03-15T05:22:00Z

前一段时间辞职了，去外地旅游了一段时间，总算是回来了，外出没啥特别的多于的感受，放松心情。实际上不怎么放松，呵呵，云南那边的温度和咱们这边的差别太大了，一过去就感冒，囧。然后再就是各个地区，坐车奔波，也挺累的。不过那边的风景确实相当的不错，水特别的好，我们这边是见也见不到的了！以后有机会一定还要过去的，还没去西双版纳呢！比较遗憾。不过我也让那边的导游不爽了，哈哈，俺是铁公鸡，彻底的0消费团，导游把俺们带去的购物点去购买东西，我一点都没买，都是空闲时间自己去买的。。。。。实话说，也不是我不买，而是实在的价格比较坑跌。

回来了，就要开始正正规规的了。放松了一阵子，人也变的懒惰了，目前工作还在寻觅当中，生活更是浑浑噩噩的。真实囧的鸟蛋疼。总算还花了点心思在一直整的电子病历上，之前在公司也就一直在写电子病历的编辑器，那时候由于时间上太仓促，功能上虽然说都整出来了，但是底层的架构方面不是很如意，以至于后来很多的东西都不大好搞。所以辞职出来之后，花了一个多星期，全部重新开始整了，底层架构全部变通，文档格式也全面修正。功能上目前完成了个50%，零零碎碎的！就现在来看，基本上实现了，元素，数据关联，医学特殊表达式，矢量图，以及矢量图中的手术缝合线，矢量图中各种矢量对象的属性设置采用类似Delphi的属性编辑器，痕迹保留，以及鼠标划过元素时元素内容高亮显示等。其他的还有复合元素，元素质控等尚未实现。

记录一下工作发展进度，路过的，不要当真就行了！呵呵

矢量编辑器

本文链接

B编码以及BT种子文件分析

2012-02-11T01:12:00Z

去年年末的时候，有个朋友说要做一个BT协议的上传和下载，要俺帮忙，于是在那个时候搜寻了各种关于种子文件的文件格式资料。顺便整了一个BT格式的分析类库出来。目前，貌似朋友那便没说要继续整BT协议的上传和下载了，估计大概换了协议吧，呵呵。所以这个放在手里也用处不大了，刚好又很久没写博了，这个就作为当年的第一篇开篇博客吧。言归正传，正文开始

说到BT的种子文件格式，首先我们必须要了解的就是Bencoding编码格式。关于这个格式的定义，基本上还是比较简明的，B编码总共只支持4种类型，既整数，字符串，列表和字典。整数以i标记开头以e标记结尾，中间是整数数字，字符串以：标记开头然后根接字符串的长度，最后是字符串内容，列表以l标记开头，以e结尾，字典以d开头以e结尾。列表可以包含任何的BT元素，字典也可以包含任何的BT元素，不过字典的Key必须是字符串。如此以来分析，整数和字符串是两种单元的元素，可以很好的解析，基本上不用分析就能搞定，而列表和字典，则就需要根据给定的字符串进行分析处理了，这个分析实际上也简单，先碰到开头的标记，然后不断的往下判断读取，碰到结尾标记e结束，如果在碰到结尾标记之前还又碰到其他的标记，则可进行递归处理，所以，处理起来也方便了。

B编码解析完成，那么BT种子文件的处理也就简单了。BT种子文件实际上就是由B编码的字典组成，其内部的字典键介绍，可以参考相关资料，这里我摘录一些如下：

Torrent文件内的数据结构分为以下几部分：

announce:Tracker的主服务器

announce-list：Tracker服务器列表

comment:种子文件的注释

comment.utf-8：种子文件注释的utf-8编码

creation date：种子文件建立的时间，是从1970年1月1日00:00:00到现在的秒数。

encoding:种子文件的默认编码，比如GB2312，Big5，utf-8等

info：所有关于下载的文件的信息都在这个字段里，它包括多个子字段，而且根据下载的是单个文件还是多个文件，子字段的项目会不同。

当种子里包含多个文件时，info字段包括如下子字段：

files：表示文件的名字，大小，该字段包含如下三个子字段：

        lenghth：文件的大小，用byte计算

         path：文件的名字，在下载时不可更改

          path.utf-8：文件名的UTF-8编码，同上

以上的三个字段每个文件都有一组值。

name：推荐的文件夹名，此项可于下载时更改。

name.utf-8:推荐的文件夹名的utf-8编码，同上。

piece length：每个文件块的大小，用Byte计算

pieces：文件的特征信息，该字段比较大，实际上是种子内包含所有的文件段的SHA1的校验值的连接，即将所有文件按照piece length的字节大小分成块，每块计算一个SHA1值，然后将这些值连接起来就形成了pieces字段，由于SHA1的校验值为20Byte，所以该字段的大小始终为20的整数倍字节。该字段是Torrent文件中体积最大的部分，可见如果大文件分块很小，会造成Torrent文件体积庞大。

publisher：文件发布者的名字

publisher.utf-8：文件发布者的名字的utf-8编码

publisher-url：文件发布者的网址

publisher-url.utf-8：文件发布者网址的utf-8编码。

另外，当发布单文件时，files字段是没有的，而

lenghth:
name：
name.utf-8:

这三个字段负责描述单文件的属性：大小，名字，名字的utf-8编码。其他项目和多文件相同。

以上的项目即为info字段的全部。

说到info就不得不说INFO_HASH，这个值是info字段的HASH值，20个Byte，同样是使用SHA1作为HASH函数。由于info字段是发布的文件信息构成的，所以INFO_HASH在BT协议中是用来识别不同的种子文件的。基本上每个种子文件的INFO_HASH都是不同的(至少现在还没有人发现有SHA的冲突)，所以BT服务器以及客户端都是以这个值来识别不同的种子文件的。

计算的具体范围是从info字段开始(不包含"info"这四个字节)，一直到nodes字段为止(不包含"nodes"这5个字节和nodes前边表示nodes字段长度的"5:"这两个字节)。另外，INFO_HASH值是即时计算的，并不包含在Torrent文件中。

nodes:最后的一个字段是nodes字段，这个字段包含一系列ip和相应端口的列表，是用于连接DHT初始node。

综上，多文件Torrent的结构的树形图为：

Multi-file Torrent
├─announce
├─announce-list
├─comment
├─comment.utf-8
├─creation date
├─encoding
├─info
│ ├─files
│ │ ├─length
│ │ ├─path
│ │ └─path.utf-8
│ ├─name
│ ├─name.utf-8
│ ├─piece length
│ ├─pieces
│ ├─publisher
│ ├─publisher-url
│ ├─publisher-url.utf-8
│ └─publisher.utf-8
└─nodes

单文件Torrent的结构的树形图为：

Single-File Torrent
├─announce
├─announce-list
├─comment
├─comment.utf-8
├─creation date
├─encoding
├─info
│ ├─length
│ ├─name
│ ├─name.utf-8
│ ├─piece length
│ ├─pieces
│ ├─publisher
│ ├─publisher-url
│ ├─publisher-url.utf-8
│ └─publisher.utf-8
└─nodes

BT类库文件简码：

//B编码支持的数据类型
TDxBenValueTypes = (DBV_String,DBV_Int,DBV_List,DBV_Dictionary);
//B编码的节点，类似于JSON节点,
TDxBenValue = class
private
FParent: TDxBenValue;
protected
function GetType:TDxBenValueTypes; virtual; abstract;
procedure Parser(str: string);virtual;abstract;
function GetAsInteger: Integer;virtual;abstract;
function GetAsString: string;virtual;abstract;
function GetObject: TDxBenValue;virtual;
public
constructor Create;overload;virtual;
constructor Create(str: string);overload;virtual;
property ValueType: TDxBenValueTypes read GetType;
function ToString: string;override;
property Parent: TDxBenValue read FParent;
property AsInteger: Integer read GetAsInteger;
property AsString: string read GetAsString;
property AsValueObject: TDxBenValue read GetObject;
end;

TDxBenInt = class(TDxBenValue)
private
FValue: Integer;
protected
function GetType:TDxBenValueTypes;override;
function GetAsInteger: Integer;override;
procedure Parser(str: string);override;
function GetAsString: string;override;
function GetObject: TDxBenValue;override;
public
constructor Create;override;
function ToString: string;override;
end;

TDxBenString = class(TDxBenValue)
private
FValue: string;
protected
function GetType:TDxBenValueTypes;override;
function GetAsString: string;override;
function GetObject: TDxBenValue;override;
function GetAsInteger: Integer;override;
procedure Parser(str: string);override;
public
function ToString: string;override;
end;

TDxBenDictionary = class;
TDxBenList = class(TDxBenValue)
private
FList: TList;
function GetCount: Integer;
function GetValues(index: Integer): TDxBenValue;
protected
procedure Parser(str: string);override;
procedure ParserToList(var P: Pchar;List: TDxBenList);
procedure ParserToDictionary(var p: PChar;Dict: TDxBenDictionary);
function GetType:TDxBenValueTypes;override;
function GetAsString: string;override;
function GetObject: TDxBenValue;override;
function GetAsInteger: Integer;override;
public
procedure Clear;
constructor Create; override;
constructor CreateFromString(str: string);
destructor Destroy;override;
function ToString: string;override;
property Count: Integer read GetCount;
property Values[index: Integer]: TDxBenValue read GetValues;
end;

TDxBenDictionary = class(TDxBenValue)
private
FDict: TDictionary<string,TDxBenValue>;
function GetCount: Integer;
function GetValues(Key: string): TDxBenValue;
protected
procedure ParserToList(var P: Pchar;List: TDxBenList);
procedure ParserToDictionary(var p: PChar;Dict: TDxBenDictionary);

procedure Parser(str: string);override;
function GetType:TDxBenValueTypes;override;
function GetAsString: string;override;
function GetObject: TDxBenValue;override;
function GetAsInteger: Integer;override;
public
procedure Clear;
constructor Create;override;
destructor Destroy;override;
function ToString: string;override;
property Count: Integer read GetCount;
property Values[Key: string]: TDxBenValue read GetValues;
end;

TDxBtInfo = class(TDxBenDictionary)
private
function GetSingleFile: Boolean;
function GetFiles: TDxBenList;
function GetName: string;
function GetNameUtf8: string;
function Getpublisher: string;
function GetpublisherUtf8: string;
function Getpublisherurl: string;
function GetpublisherurlUtf8: string;
public
property SingleFile: Boolean read GetSingleFile;
property Files: TDxBenList read GetFiles;
property Name: string read GetName;
property NameUtf8: string read GetNameUtf8;
property publisher: string read Getpublisher;
property publisherUtf8: string read GetpublisherUtf8;
property publisherurl: string read Getpublisherurl;
property publisherurlUtf8: string read GetpublisherurlUtf8;
end;

TDxTorrentFile = class
private
FDict: TDxBenDictionary;
procedure ParserStream(Stream: TStream;Dict: TDxBenDictionary);overload;
procedure ParserStreamToList(Stream: TStream; List: TDxBenList);
function GetComment: string;
function GetEncoding: string;
function GetCreator: string;
function Getannounce: string;
function Getannounce_list: TDxBenList;
function GetBtInfo: TDxBtInfo;
function GetCreateDate: TDateTime;
public
procedure Clear;
constructor Create;
destructor Destroy;override;
procedure LoadFromFile(FileName: string);
procedure LoadFromStream(Stream: TStream);
property Comment: string read GetComment;
property Encoding: string read GetEncoding;
property Creator: string read GetCreator;
property announce: string read Getannounce;
property announce_list: TDxBenList read Getannounce_list;
property BtInfo: TDxBtInfo read GetBtInfo;
property CreateDate: TDateTime read GetCreateDate;
end;
implementationend.

在CSDN上，貌似也有一个C版本的解析，不知道他的解析方式是否和我的类似，相关朋友可以一并下载了看看

完整代码下载

本文链接

关于在Delphi中链接VC的obj文件（XE2以上版本）

2011-11-08T04:54:00Z

个人用的少的东西，笔记之，以作记录

实际上老久之前，应该在Delphi中就可以链接使用Obj文件了吧，我用的第一个Delphi版本是D7，我记得他就可以了。至于再往前追述，就不晓得初始来源是哪个版本了。不过对于以前的版本的链接obj只能是OMF这个格式，这个格式是很早很早之前定义的一个文件格式，之后微软都转向了COFF这种格式了，也就是说VC编译出来的OBJ文件都是COFF格式。所以，以前要在Delphi中使用obj就要多走几步路程，要么使用VC编译的obj是COFF格式的，此时要使用COFF2OMF来进行转换，将COFF转换成OMF格式的，要么就是拿到C的源码，使用BCB等工具来编译以生成OMF的格式的obj。然后才能在Delphi中使用{$Link指令进行链接而使用里面的函数。

今天早上，俺在群中偶然听到了Delphi XE2可以支持COFF的obj静态链接了。这也就是说，可以直接使用VC编译生成的Obj文件了。之后写了一个测试的Demo，很简单的函数

#include "stdafx.h"

extern "C" {
extern int add(int x,int y);
}

int add(int x,int y)
{
return x+y;
}

编译生成了obj文件之后给Delphi使用，刚开始没改编译模式，生成的是Debug版本的obj文件，在Delphi中使用的时候，总是会报错误，无法发现add的前置引用，折腾了半天，也没搞好，之后编译成Release版本，在给Delphi使用，则运行成功！不知道是我搞的有问题还是说只能是Release版本可用，总之，发布Release的Obj给Delphi使用是没问题的。

不过这个例子就比较过于简单了，没实际作用，如果真实在开发过程中，那复杂度肯定是天差地别，于是找了一个VC版的Hook库，相对来说，这个库的代码就比较多一些了，而且也引用了好些系统API，比较复合实际开发的目的。我找的这个Hook库是海风月影大大的库，可以从这里下载，编译生成Obj文件之后，拿到Delphi中使用，编译就报了未声名

__imp__LoadLibraryA@4这样的错误，可见，这系统API在Obj中使用的，还不是真的将API函数的地址放入了，只是一个动态的预指定，于是编译的时候就找不到对应的函数了，所以我们需要在链接Obj的时候将这些导入函数在我们的程序中声名，比较蛋疼的是Delphi中的@是关键字，所以这个在VC的函数中，我们就需要将函数全部声名为C版本的函数导出和导入，C版本的会在函数名称前加入一个下划线，同时将WinApi的那套系统函数都在VC中写一个外置函数声名，API函数名字全部换掉，比如原来里面调用的是LoadLibrary这个是在Windows.h中声名的，我们现在不用这个，换一个声名

extern HMODULE __cdecl LoadLibraryExEx(LPCSTR lpLibFileName);

声名一个外部导入函数LoadLibraryExEx，然后将LoadLibrary都改成LoadLibraryExEx，同样道理，将API函数都做对应的处理之后编译

然后在Delphi中再将这些函数作为这个obj的导入函数，

function _LoadLibraryExEx(lpLibFileName: PAnsiChar): HMODULE;cdecl;
begin
Result := LoadLibraryA(lpLibFileName);
end;

这样包装一下，在进入链接Obj的时候，就会找到对应的函数了，搞定之后，还会发现，会报free的这个函数的错误，这个是VC的一个函数，函数在MSVCR70.DLL这个库中，所以也需要包装一下

extern void __cdecl free(void *);

malloc这个函数一样，之后在Delphi中，需要引用到MSVCR70.DLL这个动态库

procedure free(p: Pointer);cdecl;external 'MSVCR70.DLL';

procedure _free(p: Pointer);cdecl;
begin
free(p);
end;

这样就OK了，编译程序，在用通过

至于为何我要将VC中动态库的WINAPI都换成__cdecl的声名模式，可以自己去试一试，看看效果了！主要还是我前面说的Delphi中的@是一个关键字！

当然，这个Free和malloc也可以不用他这个Dll中的函数，可以直接用Delphi的也可以

比如

function _malloc(size_t: DWORD): Pointer;cdecl;
begin
GetMem(Result,Size_t);
end;

procedure _free(p: Pointer);cdecl;
begin
FreeMem(p);
end;

这样就免去了外部DLL的东西了！

源码下载

本文链接

关于Delphi XE2的FMX的一点点研究之消息篇

2011-09-27T01:49:00Z

Delphi XE2出来了一阵子了，里面比较抢眼的东西，除了VCLStyle这个换肤的东西之外，另外最让人眼亮的应该是FMX这个东西了。万一的博客上都连载了一票的关于FMX的使用心得了。我还是没咋去关注，因为技术这个东西，天天在变，跟着他跑，俺伤不起啊！直到今天，看了一下盒子，然后群中也有人说关于FMX在Windows下面如何来发送消息的问题，说发送不了。实际上，FMX这个东西是一套跨平台机制的GUI类库，消息这个东西只是Windows下面的，所以发送消息这个说法应该不算通用。不过加以研究应该可以让Windows,Linux的综合到一个能通用的库中。

随便创建一个FMX的应用程序，上面放几个按钮什么的，然后我们跟踪一下，先看看Application这个东西，可以找到他的实现在FMX.Forms单元中，他和VCL的Application的实现不是一个东西了地。发送消息，那么首先我们应该想到几个常用的函数ProcessMessages,HandleMessage，跟进去看就直到了，然后可以发现HandleMessage的实现

function TApplication.HandleMessage: Boolean;
begin
Result := Platform.HandleMessage;
if not Result then
Idle;
end;

里面有一个Platform的玩意，很显然这个应该是运行时期根据不同的系统平台调用不同的实现机制，俺们是Windows平台，所以跑到他的源码目录看一下，可以发现一个很明显的名称FMX.Platform.Win，对咯，就在这个实现中了。看看TPlatformWin这个玩意的实现，我想如果熟悉Win32编程的，这个应该很明了了。不再多说，然后咱们看窗体的创建找到FMX.Forms中的CreateHandle这个东西，和上面的HandleMessage差不多的一个实现

procedure TCommonCustomForm.CreateHandle;
begin
FHandle := Platform.CreateWindow(Self);
if TFmxFormState.fsRecreating in FormState then
Platform.SetWindowRect(Self, RectF(Left, Top, Left + Width, Top + Height));
end;

都与platform这个平台相关了。不过话说，FMX的这个封装结构是相当的合理的，看代码让人能够一目了然，不说废话，再去看TPlatformWin的CreateWindow的实现。这个的实现和咱们VCL的实现差不多，然后我们最主要的是看看他的最后面有一个

Result := NewFmxHandle;

FHWndMap.Add(Result, Wnd);这样的实现，也就是说CreateHandle之后返回的并不是创建的窗体句柄，而是FMX管理的一个句柄索引。所以这下，咱们可直到了，FMX的Form的Handle不是这个窗口句柄而是FMX自己管理的一个索引。至于要如何获得窗口的真实句柄，在FMX.Platform.Win的最开头提供了一个函数，可实现。function FmxHandleToHWND(FmxHandle: TFmxHandle): HWND;就是这个，这个就可通过这个索引获得真实的Win32的窗口句柄。这些都说完了，那么下面我们就可以开始考究，FMX的这个消息机制了，首先发挥我们的大脑想一想，在Windows下，你所做的任何事情都要通过消息来传递的。所以说FMX这个肯定还是有消息流通的，这个是必须的。但是好多人却说，FMX的消息发送不了，为啥，呵呵这个最主要的，我前面已经说了，首先这个Win32的句柄，你换出来了没得，换出来了的话，那么你这个消息肯定是发送成功了的，否则，肯定失败了。然后我们看看最简单的一个鼠标单击消息，鼠标点窗体上的按钮会触发单击事件，那么这个按钮的鼠标消息是怎么流通的，我们先找Button的基类，一直跟下去，可以发现FMX的Control都是他自身的一套实现方式，但是没见到Win32的消息封装函数，此时俺们在发挥大脑思考一下，FMX的控件从上到下都没有再通过Win32来创建的标准方法，而且FMX的控件都没有句柄，那么我们就应该可以想到了，FMX的一整套控件的消息都是通过他的父Form来作为媒介进行传递转换而实现的，所以我们直接找到FMX的Form实现中的MouseDown过程，可以看到他的实现方式

procedure TCommonCustomForm.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single);
var
P: TPointF;
R: TRectF;
Obj: IControl;
SG: ISizeGrip;
i: Integer;
begin
{ translate coord }
FMousePos := PointF(X, Y);
FDownPos := FMousePos;
{ event }
Obj := IControl(ObjectAtPoint(ClientToScreen(FMousePos)));
if (Obj <> nil) then
begin
if (IInterface(Obj).QueryInterface(ISizeGrip, SG) = 0) then
StartWindowResize
else
begin
P := Obj.ScreenToLocal(ClientToScreen(PointF(FMousePos.X, FMousePos.Y)));
Obj.MouseDown(Button, Shift, P.X, P.Y);
if (Obj.DragMode = TDragMode.dmAutomatic) then
Obj.BeginAutoDrag;
end;
end;
end;

很明确他会获得鼠标按下的位置的FMX控件，然后如果获得了这个控件就调用控件的MouseDown方法，所以到这里，应该就可以很明了的知道FMX的消息是通过Form作为媒介来传递的了，那么由此说来，我们只要通过Form来转我们的消息就可以实现消息的发送了，那么这样，我们先通过消息来触发一个Button的OnClick事件。放2个按钮，然后发送消息给窗体，发送一个Down消息然后发送一个Up消息，这就构成了一个单击事件

SendMessage(FmxHandleToHWND(Handle),WM_LBUttonDown,MK_LBUTTON,MakeLong(trunc(Button1.Position.X + 3),trunc(Button1.Position.Y + 3)));
SendMessage(FmxHandleToHWND(Handle),WM_LBUttonUP,MK_LBUTTON,MakeLong(trunc(Button1.Position.X + 3),trunc(Button1.Position.Y + 3)));

然后触发一下，俺们会发现貌似并没有触发这个OnClick事件，莫非猜测失败？然后我们在找找，找到Controls的MouseUp过程

procedure TControl.MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Single);
begin
ReleaseCapture;
if Assigned(FOnMouseUp) then
FOnMouseUp(Self, Button, Shift, X, Y);
if FPressed and not(FDoubleClick) and PointInRect(PointF(X, Y), LocalRect) then
begin
FPressed := False;
Click;
end;
FPressed := False;
FDoubleClick := False;
end;

里面有一个判断PointInRect(PointF(X, Y), LocalRect),可以知道是这个东西限制了只有光标在鼠标控件位置的时候才会触发OnClick事件咯。这下，可以想一个办法，用一个Timer控件在Timer的OnTimer中加上上面的消息发送代码，然后运行将鼠标移动到按钮上，等一会就会触发Button的OnClick事件了。

我想到这里，大家应该都知道如何给FMX发送消息了把！总归一句话，模拟！

FMX的消息处理过程在FMX.Platform.Win中的

function WndProc(hwnd: HWND; uMsg: UINT; wParam: WPARAM; lParam: LPARAM): LRESULT; stdcall;

函数！

本文链接

VC中pragma指令简介(转)

2011-09-26T00:32:00Z

版权声明：转载时请以超链接形式标明文章原始出处和作者信息及本声明
 http://yangwei.blogbus.com/logs/1550523.html

pragma指令简介
在编写程序的时候,我们经常要用到#pragma指令来设定编译器的状态或者是指示编译器完成一些特定的动作.
下面介绍了一下该指令的一些常用参数,希望对大家有所帮助!
一. message 参数。

message
它能够在编译信息输出窗
口中输出相应的信息，这对于源代码信息的控制是非常重要的。其使用方法为：

#pragma message("消息文本")

当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。
当我们在程序中定义了许多宏来控制源代码版本的时候，我们自己有可能都会忘记有没有正确的设置这些宏，此时我们可以用这条
指令在编译的时候就进行检查。假设我们希望判断自己有没有在源代码的什么地方定义了_X86这个宏可以用下面的方法
#ifdef _X86
#pragma message("_X86 macro activated!")
#endif
当我们定义了_X86这个宏以后，应用程序在编译时就会在编译输出窗口里显示"_
X86 macro activated!"。我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了

二. 另一个使用得比较多的#pragma参数是code_seg。格式如：

#pragma code_seg( [ [ { push | pop}, ] [ identifier, ] ] [ "segment-name" [, "segment-class" ] )
该指令用来指定函数在.obj文件中存放的节,观察OBJ文件可以使用VC自带的dumpbin命令行程序,函数在.obj文件中默认的存放节
为.text节
如果code_seg没有带参数的话,则函数存放在.text节中
push (可选参数) 将一个记录放到内部编译器的堆栈中,可选参数可以为一个标识符或者节名
pop(可选参数) 将一个记录从堆栈顶端弹出,该记录可以为一个标识符或者节名
identifier (可选参数) 当使用push指令时,为压入堆栈的记录指派的一个标识符,当该标识符被删除的时候和其相关的堆栈中的记录将被弹出堆栈
"segment-name" (可选参数) 表示函数存放的节名
例如:
//默认情况下,函数被存放在.text节中
void func1() { // stored in .text
}

//将函数存放在.my_data1节中
#pragma code_seg(".my_data1")
void func2() { // stored in my_data1
}

//r1为标识符,将函数放入.my_data2节中
#pragma code_seg(push, r1, ".my_data2")
void func3() { // stored in my_data2
}

int main() {
}

三. #pragma once (比较常用）

这是一个比较常用的指令,只要在头文件的最开始加入这条指令就能够保证头文件被编译一次

四. #pragma hdrstop表示预编译头文件到此为止，后面的头文件不进行预编译。

BCB可以预编译头文件以加快链接的速度，但如果所有头文件都进行预编译又可能占太多磁盘空间，所以使用这个选项排除一些头文件。
有时单元之间有依赖关系，比如单元A依赖单元B，所以单元B要先于单元A编译。你可以用#pragma startup指定编译优先级，
如果使用了#pragma package(smart_init) ，BCB就会根据优先级的大小先后编译。

五. #pragma warning指令

该指令允许有选择性的修改编译器的警告消息的行为

指令格式如下:
#pragma warning( warning-specifier : warning-number-list [; warning-specifier : warning-number-list...]
#pragma warning( push[ ,n ] )
#pragma warning( pop )

主要用到的警告表示有如下几个:

once:只显示一次(警告/错误等)消息
default:重置编译器的警告行为到默认状态
1,2,3,4:四个警告级别
disable:禁止指定的警告信息
error:将指定的警告信息作为错误报告

如果大家对上面的解释不是很理解,可以参考一下下面的例子及说明

#pragma warning( disable : 4507 34; once : 4385; error : 164 )
等价于：
#pragma warning(disable:4507 34) // 不显示4507和34号警告信息
#pragma warning(once:4385)        // 4385号警告信息仅报告一次
#pragma warning(error:164)        // 把164号警告信息作为一个错误。
同时这个pragma warning 也支持如下格式：
#pragma warning( push [ ,n ] )
#pragma warning( pop )
这里n代表一个警告等级(1---4)。
#pragma warning( push )保存所有警告信息的现有的警告状态。
#pragma warning( push, n)保存所有警告信息的现有的警告状态，并且把全局警告
等级设定为n。
#pragma warning( pop )向栈中弹出最后一个警告信息，在入栈和出栈之间所作的
一切改动取消。例如：
#pragma warning( push )
#pragma warning( disable : 4705 )
#pragma warning( disable : 4706 )
#pragma warning( disable : 4707 )
#pragma warning( pop )

在这段代码的最后，重新保存所有的警告信息(包括4705，4706和4707)

在使用标准C++进行编程的时候经常会得到很多的警告信息,而这些警告信息都是不必要的提示,
所以我们可以使用#pragma warning(disable:4786)来禁止该类型的警告

在vc中使用ADO的时候也会得到不必要的警告信息,这个时候我们可以通过
#pragma warning(disable:4146)来消除该类型的警告信息

六. pragma comment(...)
该指令的格式为
#pragma comment( "comment-type" [, commentstring] )

该指令将一个注释记录放入一个对象文件或可执行文件中,
comment-type(注释类型):可以指定为五种预定义的标识符的其中一种
五种预定义的标识符为:

compiler:将编译器的版本号和名称放入目标文件中,本条注释记录将被编译器忽略
如果你为该记录类型提供了commentstring参数,编译器将会产生一个警告
例如:#pragma comment( compiler )

exestr:将commentstring参数放入目标文件中,在链接的时候这个字符串将被放入到可执行文件中,
       当操作系统加载可执行文件的时候,该参数字符串不会被加载到内存中.但是,该字符串可以被
       dumpbin之类的程序查找出并打印出来,你可以用这个标识符将版本号码之类的信息嵌入到可
       执行文件中!

lib:这是一个非常常用的关键字,用来将一个库文件链接到目标文件中

常用的lib关键字，可以帮我们连入一个库文件。
例如:
#pragma comment(lib, "user32.lib")
该指令用来将user32.lib库文件加入到本工程中

linker:将一个链接选项放入目标文件中,你可以使用这个指令来代替由命令行传入的或者在开发环境中
设置的链接选项,你可以指定/include选项来强制包含某个对象,例如:
#pragma comment(linker, "/include:__mySymbol")

你可以在程序中设置下列链接选项

/DEFAULTLIB
/EXPORT
/INCLUDE
/MERGE
/SECTION
这些选项在这里就不一一说明了,详细信息请看msdn!

user:将一般的注释信息放入目标文件中commentstring参数包含注释的文本信息,这个注释记录将被链接器忽略
例如:
#pragma comment( user, "Compiled on " __DATE__ " at " __TIME__ )

本文链接

企业IM通信软件

2011-06-27T04:27:00Z

朋友做的一套IM通信工具，完全的QQ2011的操作方式，以及界面样式等，实现了各个通信的功能，对于某些企业内部不能使用QQ的，但是又想要一个自己内部的企业部门通信工具的公司，是一个灰常好的选择，支持了支持了QQ通信工具的各种功能（远程，图片，文件发送，即时视频音频通信等完美实现）。以下是软件截图（如果有意向的，可以联系以做进一步详谈！）

本文链接

实现一个模拟CMD.exe命令编辑模式执行与显示的Delphi控件

2011-06-07T15:52:00Z

cmd.exe这个东西是Windows系统自带的执行Dos的一个灰常好的人机命令交互的执行方式，现在很多脚本语言也都带有这种即时解释的人机模式。当下由于工程的需要，也要做一个类似命令解释显示的编辑器，基本上完全模拟Cmd.exe的这种交互模式，昨天，基本上搞定了这种命令行的编辑器，这个东西的复杂之处就是在于编辑文字的处理，显示相对来说要容易的多，而编辑中最麻烦的一环就是多种处理模式，比如选中，粘贴，复制等，选中相对来说应该是最麻烦的，我这个也暂时没实现这几个编辑功能。文字的插入相对比较容易点，记录位置，插入就行了。实际上在中文的输入处理上应该也很麻烦（如果你用的是Delphi2009之前的版本的话），不过，现在用的是Delphi XE作为开发工具，相对来说就要容易很多很多了，因为有了Unicode的支持，可以直接通过WM_Char来获得汉字了，不像以前要处理很多很多代码的。至于命令的显示，就更容易了，计算位置，插入，显示，这个编辑器就完成了，如果加上类似文本编辑器的那种编辑操作的话，就更爽了，如果在加上一个和Delphi写代码一样有代码提示这种命令提示功能就更加爽大发咯！呵呵，不过那些都是后话，目前也就仅仅完成一个基本功能，算是能模拟cmd.exe这种编辑器的90%的功能了吧。目前的控件，算是实现了一个个小小的目的了吧，记录一下日志。同时拟定一个下一步目标，就是编辑功能完善，命令代码提示功能实现。（不过也不晓得要到什么时候了，可能需要这种功能的时候才会要去继续添加这种方式的实现了，毕竟是比较复杂的玩意，就那个选择的，我本来打算实现的，想了一下，多行选择，单行选择，选择文字和非选择文字的截断，分段绘制，我都蛋疼了，所以就暂时不想去实现，也是自己懒吧，^_^！不过无所谓了，目前功能基本上够用了。使用本命令编辑器基本上可以模拟Python,Erlang等直接命令行表达式的执行的小型命令行解释器了，呵呵）来两个图

Demo.exe下载

这就是这个命令编辑器的基本模式，命令可以自己随意定义响应了。然后我通过这个基本模式的控件继承实现了一个Cmd.exe的编辑器控件，可以直接模拟Cmd.exe的命令输入与显示了

设计界面如下

运行的样子

Demo.exe下载

本文链接

C#实现的一个内存Ini类

2011-05-24T01:51:00Z

正式用上C#了，写了一个多星期代码了，感觉上来说，总体还蛮顺手的，直接拿来就写了。只是写的过程中，总是想着对象释放，这个比较蛋疼，我看了一些网上的代码貌似都是有new了，但是后面都没有释放，俺们还是写Delphi之类的习惯了，对象创建一写上，马上要在对应的位置写一个释放。貌似C#不必，但是总不放心，虽然说有垃圾回收机制，但是总怕有个闪失神马的。。。。。这个方面还得多找找相关资料看看具体的工作原理。

C#的很多特性，在写代码的时候是比较爽的，但是，也有时候比较蛋疼，我这写了几天，发现的几个比较蛋疼的就是调用Windows API还有就是以往在Delphi中用习惯的操作类库没得。不晓得，为啥微软不把他的那个NativeMethod的API库开放出来，如果开放了，直接用那个玩意不就可以直接用API咯，现在要用一下，每次都得DLLImport或者自己来封装，蛋疼啊！也可能是我不知道有这样的库吧！-_-!然后就是貌似没见到Ini操作的类库，莫非微软已经不用这个了，虽然说.net自己带有一个配置类可以直接操作，但是有时候这个还是需要的，网上搜索了一下，貌似都是自己封装的类库。这个也比较蛋疼。既然这个没有，那么像Delphi一样的TMemIniFile这个内存Ini操作类库估计就更蛋疼了。实际上这个是非常有必要的，因为很多时候，数据库中可能会存放这样的结构，这样就不会存在一个实际的Ini文件，那么WinAPI就起不了啥作用了，内存Ini解析就显得相当有必要。网上找了一番，确实也没发现内存操作的Ini类库。于是就自己实现了一个内存操作Ini的一个类库，现学现卖，开放给需要的人了，实际上代码并不难-_-!另外，初写C#或许难免有很多位置写的不太规范，希望大家有能给出中肯的指点！

/// <summary>
/// Ini节点
/// </summary>
public class IniSection
{
private Dictionary<string, string> FDictionary;//节点值
private String FSectionName;//节点名称
public IniSection(String SName)
{
FSectionName = SName;
FDictionary = new Dictionary<string, string>();
}

public string SectionName
{
get { return FSectionName; }
}

public int Count
{
get { return FDictionary.Count; }
}

public void Clear()
{
FDictionary.Clear();
}

//增加键值对
public void AddKeyValue(string key, string value)
{
if (FDictionary.ContainsKey(key))
FDictionary[key] = value;
else
FDictionary.Add(key, value);
}

public void WriteValue(string key, string value)
{
AddKeyValue(key, value);
}

public void WriteValue(string key, bool value)
{
AddKeyValue(key,Convert.ToString(value));
}

public void WriteValue(string key, int value)
{
AddKeyValue(key, Convert.ToString(value));
}

public void WriteValue(string key, float value)
{
AddKeyValue(key, Convert.ToString(value));
}

public void WriteValue(string key, DateTime value)
{
AddKeyValue(key, Convert.ToString(value));
}

public string ReadValue(string key,string defaultv)
{
if (FDictionary.ContainsKey(key))
return FDictionary[key];
else
return defaultv;
}

public bool ReadValue(string key, bool defaultv)
{
string rt = ReadValue(key, Convert.ToString(defaultv));
return Convert.ToBoolean(rt);
}

public int ReadValue(string key, int defaultv)
{
string rt = ReadValue(key, Convert.ToString(defaultv));
return Convert.ToInt32(rt);
}

public float ReadValue(string key, float defaultv)
{
string rt = ReadValue(key, Convert.ToString(defaultv));
return Convert.ToSingle(rt);
}

public DateTime ReadValue(string key, DateTime defaultv)
{
string rt = ReadValue(key, Convert.ToString(defaultv));
return Convert.ToDateTime(rt);
}

public void SaveToStream(Stream stream)
{
StreamWriter SW = new StreamWriter(stream);
SaveToStream(SW);
SW.Dispose();
}

public void SaveToStream(StreamWriter SW)
{
SW.WriteLine("[" + FSectionName + "]");
foreach (KeyValuePair<string, string> item in FDictionary)
{
SW.WriteLine(item.Key + "=" + item.Value);
}

}
}

/// <summary>
/// 内存Ini解析
/// </summary>
public class MemIniFile
{
private ArrayList List;//所有节点信息

private bool SectionExists(string SectionName)
{
foreach (IniSection ISec in List)
{
if (ISec.SectionName.ToLower() == SectionName.ToLower())
return true;
}
return false;
}

public IniSection FindSection(string SectionName)
{
foreach (IniSection ISec in List)
{
if (ISec.SectionName.ToLower() == SectionName.ToLower())
return ISec;
}
return null;
}

public MemIniFile()
{
List = new ArrayList();
}

public void LoadFromStream(Stream stream)
{
StreamReader SR = new StreamReader(stream);
List.Clear();
string st = null;
IniSection Section = null;//节点
int equalSignPos;
string key, value;
while (true)
{
st = SR.ReadLine();
if (st == null)
break;
st = st.Trim();
if (st == "")
continue;
if (st != "" && st[0] == '[' && st[st.Length - 1] == ']')
{
st = st.Remove(0,1);
st = st.Remove(st.Length - 1,1);
Section = FindSection(st);
if (Section == null)
{
Section = new IniSection(st);
List.Add(Section);
}
}
else
{
if (Section == null)
{
Section = FindSection("UnDefSection");
if (Section == null)
{
Section = new IniSection("UnDefSection");
List.Add(Section);
}
}
//开始解析
equalSignPos = st.IndexOf('=');
if (equalSignPos != 0)
{
key = st.Substring(0, equalSignPos);
value = st.Substring(equalSignPos + 1, st.Length - equalSignPos - 1);
Section.AddKeyValue(key, value);//增加到节点
}
else
Section.AddKeyValue(st, "");
}
}
SR.Dispose();
}

public void SaveToStream(Stream stream)
{
StreamWriter SW = new StreamWriter(stream);
foreach (IniSection ISec in List)
{
ISec.SaveToStream(SW);
}
SW.Dispose();
}

public string ReadValue(string SectionName, string key, string defaultv)
{
IniSection ISec = FindSection(SectionName);
if (ISec != null)
{
return ISec.ReadValue(key, defaultv);
}
else return defaultv;
}

public bool ReadValue(string SectionName, string key, bool defaultv)
{
IniSection ISec = FindSection(SectionName);
if (ISec != null)
{
return ISec.ReadValue(key, defaultv);
}
else return defaultv;
}

public int ReadValue(string SectionName, string key, int defaultv)
{
IniSection ISec = FindSection(SectionName);
if (ISec != null)
{
return ISec.ReadValue(key, defaultv);
}
else return defaultv;
}

public float ReadValue(string SectionName, string key, float defaultv)
{
IniSection ISec = FindSection(SectionName);
if (ISec != null)
{
return ISec.ReadValue(key, defaultv);
}
else return defaultv;
}

public DateTime ReadValue(string SectionName, string key, DateTime defaultv)
{
IniSection ISec = FindSection(SectionName);
if (ISec != null)
{
return ISec.ReadValue(key, defaultv);
}
else return defaultv;
}

public IniSection WriteValue(string SectionName, string key, string value)
{
IniSection ISec = FindSection(SectionName);
if (ISec == null)
{
ISec = new IniSection(SectionName);
List.Add(ISec);
}
ISec.WriteValue(key, value);
return ISec;
}

public IniSection WriteValue(string SectionName, string key, bool value)
{
IniSection ISec = FindSection(SectionName);
if (ISec == null)
{
ISec = new IniSection(SectionName);
List.Add(ISec);
}
ISec.WriteValue(key, value);
return ISec;
}

public IniSection WriteValue(string SectionName, string key, int value)
{
IniSection ISec = FindSection(SectionName);
if (ISec == null)
{
ISec = new IniSection(SectionName);
List.Add(ISec);
}
ISec.WriteValue(key, value);
return ISec;
}

public IniSection WriteValue(string SectionName, string key, float value)
{
IniSection ISec = FindSection(SectionName);
if (ISec == null)
{
ISec = new IniSection(SectionName);
List.Add(ISec);
}
ISec.WriteValue(key, value);
return ISec;
}

public IniSection WriteValue(string SectionName, string key, DateTime value)
{
IniSection ISec = FindSection(SectionName);
if (ISec == null)
{
ISec = new IniSection(SectionName);
List.Add(ISec);
}
ISec.WriteValue(key, value);
return ISec;
}

public void LoadFromFile(string FileName)
{
FileStream FS = new FileStream(System.IO.Path.GetFullPath(FileName), FileMode.Open);
LoadFromStream(FS);
FS.Close();
FS.Dispose();
}

public void SaveToFile(string FileName)
{
FileStream FS = new FileStream(System.IO.Path.GetFullPath(FileName), FileMode.Create);
SaveToStream(FS);
FS.Close();
FS.Dispose();
}
}

用法很简单

MemIniFile MIni = new MemIniFile();
IniSection ISec = MIni.WriteValue("系统配置", "Con", "链接测试");
ISec.WriteValue("pwd", "124");
ISec.WriteValue("Port", 345);
MIni.SaveToFile("1.ini");

读取

MemIniFile Mini = new MemIniFile();
Mini.LoadFromFile("1.txt");
Mini.ReadValue("系统配置", "pwd", "");

IniSection ISec = Mini.FindSection("系统配置");

ISec.ReadValue("Port", 345);

本内存Ini提供了LoadFromStream和SaveToStream，可以直接从内存加载，这样就可以很容易和数据库等字段结构交互了！

本文链接

一个绘制虚线的非常规函数（常规方法，打印机上绘制不出虚线）

2011-04-28T03:25:00Z

昨天碰到一个灰常的，郁闷之极的问题！在打印机上，竟然使用Delphi的常规方式绘制虚线的时候，竟然显示的始终是实线。

我们常规绘制虚线的方法很简单的，就是指定Canvas的PenStyle为虚线模式就可以了。代码简单了

Canvas.pen.style := psdot;

canvas.pen.color := clred;

canvas.moveto(20,30);

canvas.lineto(800,800);

这样绘制在窗体上，就可以画一条虚线咯。可是用这个绘制到打印机上，就不行了，在打印机画布上，用这个相同的代码，执行之后，实际上打印机打印出来的是实线。在这个破地方蛋疼了半天，打印的代码又多，前后来来回回的找可能出现问题的地方，找了半天都没发现神马问题，于是转而用纯API来写

tempPen := CreatePen(PS_DASH,1,clred);

selectObject(canvas.Handle,tempPen);

MovetoEx(Canvas.Handle,20,30,nil);

lineto(Canvas.Handle,800,800);

deleteobject(tempPen);

这样写了之后，还是一样的蛋疼。显示的还是实线。后来蛋疼的没办法了，找了半天也招不到问题所在！之后在网上谷歌一番。网上提出了一个更加蛋疼的方案，先把虚线画到一个位图上，然后再在打印机上输出位图。很不淡定的方案。看来这个问题，可能就是系统的问题了。于是恨不淡定的自己写了一个绘制虚线的函数。

直线的虚线条绘制，其实简单。X,Y上可以用多个小线段一条一条的模拟过去，如果是倾斜的斜线，可以计算出斜率，然后同时计算X,Y的步进步长，然后在一个一个的绘制小短线段，虚线就由小短线段组成了。

贴代码把

procedure DrawVirtualLine(Cvs: TCanvas;FromP,ToP: TPoint);
var
i: integer;
Xl: Single;
x,y: Integer;
begin
Cvs.MoveTo(FromP.x,FromP.y);
if FromP.x = ToP.X then
begin
i := FromP.Y;
while i <= ToP.Y do
begin
Cvs.LineTo(FromP.x,i + 1);
Cvs.MoveTo(FromP.X,i+4);
Inc(i,4);
end;
end
else if FromP.Y = ToP.Y then
begin
i := FromP.X;
while i <= Top.X do
begin
Cvs.LineTo(i + 1,FromP.y);
Cvs.MoveTo(i + 4,FromP.y);
Inc(i,4);
end;
end
else
begin
Xl := (ToP.Y - FromP.Y)/(ToP.X - FromP.x);
if Abs(xl) >= 1 then
begin
i := FromP.x;
y := FromP.Y;
if FromP.X < ToP.X then
while i <= ToP.X do
begin
Cvs.LineTo(i + 1,y+trunc(Xl));
y := y + Trunc(xl*2);
Cvs.MoveTo(i + 2,y);
Inc(i,2);
end
else
while i >= ToP.X do
begin
Cvs.LineTo(i - 1, y - Trunc(Xl));
y := y - Trunc(xl*2);
Cvs.MoveTo(i - 2,y);
dec(i,2);
end;
end
else
begin
i := FromP.Y;
x := FromP.X;
if FromP.y < ToP.y then
while i <= ToP.Y do
begin
Cvs.LineTo(x+trunc(1/xl),i+ 1);
x := x + Trunc(2/xl);
Cvs.MoveTo(x,i + 2);
Inc(i,2);
end
else
while i >= ToP.Y do
begin
Cvs.LineTo(x - Trunc(1 / Xl),i - 1);
x := x - Trunc(2 / Xl);
cvs.MoveTo(x,i - 2);
Dec(i,2);
end;
end;
end;
end;

用法

Canvas.Pen.Color := clred;
DrawVirtualLine(Canvas,Point(30,80),Point(10,120));
DrawVirtualLine(Canvas,Point(10,120),Point(70,60));
DrawVirtualLine(Canvas,Point(70,60),Point(30,80));

本文链接

VC++动态链接库(DLL)编程深入浅出(四)（转）

2011-04-22T05:47:00Z

　这是《VC++动态链接库(DLL)编程深入浅出》的第四部分，阅读本文前，请先阅读前三部分：（一）、（二）、（三）。

MFC扩展DLL的内涵为MFC的扩展，用户使用MFC扩展DLL就像使用MFC本身的DLL一样。除了可以在MFC扩展DLL的内部使用MFC以外，MFC扩展DLL与应用程序的接口部分也可以是MFC。我们一般使用MFC扩展DLL来包含一些MFC的增强功能，譬如扩展MFC的CStatic、CButton等类使之具备更强大的能力。

使用Visual C++向导生产MFC扩展DLL时，MFC向导会自动增加DLL的入口函数DllMain：

extern "C" int APIENTRY
DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved)
{
// Remove this if you use lpReserved
UNREFERENCED_PARAMETER(lpReserved);
if (dwReason == DLL_PROCESS_ATTACH)
{
　 TRACE0("MFCEXPENDDLL.DLL Initializing! ");
　 // Extension DLL one-time initialization
　 if (!AfxInitExtensionModule(MfcexpenddllDLL, hInstance))
　 return 0;
　 // Insert this DLL into the resource chain
　 // NOTE: If this Extension DLL is being implicitly linked to by
　 //　an MFC Regular DLL (such as an ActiveX Control)
　 //　instead of an MFC application, then you will want to
　 //　remove this line from DllMain and put it in a separate
　 //　function exported from this Extension DLL.　The Regular DLL
　 //　that uses this Extension DLL should then explicitly call that
　 //　function to initialize this Extension DLL.　Otherwise,
　 //　the CDynLinkLibrary object will not be attached to the
　 //　Regular DLL's resource chain, and serious problems will
　 //　result.
　 new CDynLinkLibrary(MfcexpenddllDLL);
}
else if (dwReason == DLL_PROCESS_DETACH)
{
　 TRACE0("MFCEXPENDDLL.DLL Terminating! ");
　 // Terminate the library before destructors are called
　 AfxTermExtensionModule(MfcexpenddllDLL);
}
return 1;　 // ok
}

由于MFC扩展DLL导出函数和变量的方式与其它DLL没有什么区别，我们不再细致讲解。下面直接给出一个MFC扩展DLL的创建及在应用程序中调用它的例子。

6.1 MFC扩展DLL的创建

下面我们将在MFC扩展DLL中导出一个按钮类CSXButton（扩展自MFC的CButton类），类CSXButton是一个用以取代 CButton的类，它使你能在同一个按钮上显示位图和文字，而MFC的按钮仅可显示二者之一。类CSXbutton的源代码在Internet上广泛流传，有很好的“群众基础”，因此用这个类来讲解MFC扩展DLL有其特殊的功效。

MFC中包含一些宏，这些宏在DLL和调用DLL的应用程序中被以不同的方式展开，这使得在DLL和应用程序中，使用统一的一个宏就可以表示出输出和输入的不同意思：

// for data
#ifndef AFX_DATA_EXPORT
#define AFX_DATA_EXPORT __declspec(dllexport)
#endif
#ifndef AFX_DATA_IMPORT
#define AFX_DATA_IMPORT __declspec(dllimport)
#endif
// for classes
#ifndef AFX_CLASS_EXPORT
#define AFX_CLASS_EXPORT __declspec(dllexport)
#endif
#ifndef AFX_CLASS_IMPORT
#define AFX_CLASS_IMPORT __declspec(dllimport)
#endif
// for global APIs
#ifndef AFX_API_EXPORT
#define AFX_API_EXPORT __declspec(dllexport)
#endif
#ifndef AFX_API_IMPORT
#define AFX_API_IMPORT __declspec(dllimport)
#endif
#ifndef AFX_EXT_DATA
#ifdef _AFXEXT
　 #define AFX_EXT_CLASS　 AFX_CLASS_EXPORT
　 #define AFX_EXT_API AFX_API_EXPORT
　 #define AFX_EXT_DATAAFX_DATA_EXPORT
　 #define AFX_EXT_DATADEF
#else
　 #define AFX_EXT_CLASS　 AFX_CLASS_IMPORT
　 #define AFX_EXT_API AFX_API_IMPORT
　 #define AFX_EXT_DATAAFX_DATA_IMPORT
　 #define AFX_EXT_DATADEF
#endif
#endif

导出一个类，直接在类声明头文件中使用AFX_EXT_CLASS即可，以下是导出CSXButton类的例子：

#ifndef _SXBUTTON_H
#define _SXBUTTON_H
#defineSXBUTTON_CENTER-1
class AFX_EXT_CLASS CSXButton : public CButton
{
// Construction
public:
CSXButton();
// Attributes
private:
//Positioning
BOOL　m_bUseOffset;
CPoint　m_pointImage;
CPoint　m_pointText;
int　m_nImageOffsetFromBorder;
int　m_nTextOffsetFromImage;
//Image
HICON　m_hIcon;
HBITMAP　m_hBitmap;
HBITMAP　m_hBitmapDisabled;
int　m_nImageWidth, m_nImageHeight;
//Color Tab
char　m_bColorTab;
COLORREFm_crColorTab;
//State
BOOL　m_bDefault;
UINT　m_nOldAction;
UINT　m_nOldState;
// Operations
public:
//Positioning
int　SetImageOffset( int nPixels );
int　SetTextOffset( int nPixels );
CPointSetImagePos( CPoint p );
CPointSetTextPos( CPoint p );
//Image
BOOLSetIcon( UINT nID, int nWidth, int nHeight );
BOOLSetBitmap( UINT nID, int nWidth, int nHeight );
BOOLSetMaskedBitmap( UINT nID, int nWidth, int nHeight, COLORREF crTransparentMask );
BOOLHasImage() { return (BOOL)( m_hIcon != 0　| m_hBitmap != 0 ); }
//Color Tab
voidSetColorTab(COLORREF crTab);
//State
BOOLSetDefaultButton( BOOL bState = TRUE );
private:
BOOLSetBitmapCommon( UINT nID, int nWidth, int nHeight, COLORREF crTransparentMask, BOOL bUseMask );
voidCheckPointForCentering( CPoint &p, int nWidth, int nHeight );
voidRedraw();
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CSXButton)
public:
virtual void DrawItem(LPDRAWITEMSTRUCT lpDrawItemStruct);
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~CSXButton();
// Generated message map functions
protected:
//{{AFX_MSG(CSXButton)
afx_msg LRESULT OnGetText(WPARAM wParam, LPARAM lParam);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
#endif

把SXBUTTON.CPP文件直接添加到工程，编译工程，得到“mfcexpenddll.lib”和“mfcexpenddll.dll”两个文件。我们用Visual Studio自带的Depends工具可以查看这个.dll，发现其导出了众多符号（见图15）。

　图15 导出类时导出的大量符号 (＋放大该图片)

这些都是类的构造函数、析构函数及其它成员函数和变量经编译器处理过的符号，我们直接用__declspec(dllexport)语句声明类就导出了这些符号。

如果我们想用.lib文件导出这些符号，是非常困难的，我们需要在工程中生成.map文件，查询.map文件的符号，然后将其一一导出。如图16，打开DLL工程的settings选项，再选择Link，勾选其中的产生MAP文件（Generate mapfile）就可以产生.map文件了。

打开mfcexpenddll工程生成的.map文件，我们发现其中包含了图15中所示的符号（symbol）

0001:00000380　?HasImage@CSXButton@@QAEHXZ 10001380 f i SXBUTTON.OBJ
0001:000003d0　??0CSXButton@@QAE@XZ　 100013d0 f　 SXBUTTON.OBJ
0001:00000500　??_GCSXButton@@UAEPAXI@Z　 10001500 f i SXBUTTON.OBJ
0001:00000570　??_ECSXButton@@UAEPAXI@Z　 10001570 f i SXBUTTON.OBJ
0001:00000630　??1CSXButton@@UAE@XZ　 10001630 f　 SXBUTTON.OBJ
0001:00000700 ?_GetBaseMessageMap@CSXButton@@KGPBUAFX_MSGMAP@@XZ 10001700 f　 SXBUTTON.OBJ
0001:00000730 ?GetMessageMap@CSXButton@@MBEPBUAFX_MSGMAP@@XZ 10001730 f　 SXBUTTON.OBJ
0001:00000770?Redraw@CSXButton@@AAEXXZ　10001770 f i SXBUTTON.OBJ
0001:000007d0?SetIcon@CSXButton@@QAEHIHH@Z 100017d0 f　 SXBUTTON.OBJ
……………………………………………………………………..//省略

图16 产生.map文件 (＋放大该图片)

所以，对于MFC扩展DLL，我们不宜以.lib文件导出类。

本文链接