分类 Delphi 下的文章

sqlitesimpledelphi修正以支持Unicode,Delphi 2010 测试通过

  早先在我的博文Delphi 2010下使用sqlitesimpledelphi连接SQLite数据库及中文乱码问题的解决中曾提到sqlite的包装库sqlitesimpledelphi,及其简单Unicode支持修正

  之前的解决方案都是为了快速解决sqlitesimpledelphi的Unicode乱码问题而设计的,实际应用确实不太顺手,这几天咬咬牙抽出时间将其完全Unicode话,这样原相关接口都不用改变,直接调用就可以了,这样就不用使用UTF8Encode和UTF8Decode来进行相关数据传递了。

  这里贴出来,有需要的朋友可以下载测试使用。注意我没有加入Ansi和Unicode通用代码,所以修正后的库只支持Unicode,如果有朋友需要Ansi版的,可以直接使用原作者的代码。

  简单贴张图,截取自原演示程序,只是实际的sql字符串修改为Unicode的,并包含汉字:
1.png

源代码及测试程序下载:
源码库

(转)Delphi关键字

absolute

它使得你能够创建一个新变量, 并且该变量的起始地址与另一个变量相同.

Var
Str: string[32];
StrLen: Byte absolute Str;//这个声明指定了变量StrLen起始地址与Str相同.
   //由于字符串的第0个位置保存了字符串的长度, 所以StrLen的值即字符串长度.
Begin
Str := 'abc';
Edit1.Text := IntToStr(StrLen);
end;

abstract

它允许你创建抽象的方法, 包括有抽象方法的类称为抽象类.Abstract关键字必须与Virtual或Dynamic关键字同时使用, 因为抽象方法必须被覆盖式实现.抽象类不能实例化, 抽象方法不能包含方法体.

type TDemo = class
private   
protected
      procedure X; virtual; abstract;
public
      constructor Create;
      destructor Destroy; override;
published
end;

and

一、表示逻辑与

if (a>0) and (b>0) then

二、表示位运算

Var
a,b,c: Integer;
Begin
c := (a and b);
end;

使用And表示逻辑时, And左右的表达式必须用小括号括起, 以避免以生条件的冲突.

例如:

if a>0 and b>0 then

编译器可能会理解为:
if a>(0 and b)>0 then
或:
if (a>0) and (b>0) then

但是实际编译时, 编译器会产生一个冲突, 报告错误.
并且第一种可能包含了a > b > c的形式, 这在Delphi中不被支持.所以使用And运算符时必须使用括号, 以区分左右的条件.表示位运算时也必须加上括号, 将And以及左右参数括起.


array

Array用于表示数组, 任何的对象都能被声明成数组.数组分为静态和动态的2种.
静态数组
var Arr1: array [1..10] of Integer;
动态数组, 由于声明时不知其元素个数, 所以必须在后期用SetLength方法设置数组的大小var Arr2: array of Integer;
数组作为参数时, 不能传入数组的大小, 只能传入数组名, 然后用Length方法获取数组的元素个数

function X(A: array of Integer): Integer;
Var
i: Integer;
Begin
    Result := 0;
    for i := 0 to Length(A)-1 do
        Result := Result + A[i];
end;

as

As用于将一个对象转换为另一个对象

procedure BtnClick(Sender:TObject);
Begin
    (Sender as TButton).Caption := 'Clicked';
end;

对于对象填充接口的转换, 必须用As进行
(HTTPRIO as IExp).GetConnection;
As不能用于数据类型的转换, 下面的代码是错误的:

Var
i: Integer;
s: string;
Begin
s := (i as string);
end;
//正确写法是:s := string(i);

asm

Asm关键字用于插入汇编代码, 使用汇编代码时, 必须使用asm...end;的结构, 而非begin...end;

function IntToHex(Value: Integer; Digits: Integer): string;
Asm
    CMP EDX, 32
    JBE @A1
    xor EDX, EDX
@A1:
    PUSH ESI
    MOV ESI, ESP
    SUB ESP, 32
    PUSH ECX
    MOV ECX, 16
    CALL CvtInt
    MOV EDX, ESI
    POP EAX
    CALL
    ADD ESP, 32
    POP ESI
end;

assembler

Assembler关键字用于支持早期的汇编, 如80386等.它和Asm的区别:
Asm允许使用Win32汇编, 而Assembler只允许80x86汇编, 它不允许Invoke语句的出现.
function IntToHex(AValue: Int64): string;
assembler;


automated

Automated访问区分符用于描述一个自动类型的成员, 它能够使程序的版本向下兼容.ComObj单元内的成员及其实例不能使用Automated访问区分符.
Type
TDemo = class
Automated Str:WideString;
end;
在程序的下一个版本中, 将Str做了修改, 变成
Type
TDemo = class
automated Str: AnsiString;
End
则新版本的Str变量能够接受旧版本的WideString型数据, 并自动转换成AnsiString.在实际开发中, 如果没有特殊的需要, 一般不用automated访问区分符.


begin

begin关键字用于表示一段程序或一个结构的开始, 必须用end关键字来结束.
procedure X;
Begin
ShowMessage('A Demo');
end;
一般的结构, 如If, For, While等也需要用begin关键字来标出结构起始点
for i:=1 to 100 do
Begin
sum := sum + i;
if sum > 1000 then Break;
end;


case

Case语句用于完成条件选择, Case语句的的被选择对象必须是有序类型, 包括整型, 枚举类型, 字符型等.Case语句必须由end结束,如果没有相符合的选择项, 可以加入else来作出通用选择.

function GetDays(AYear,AMonth: Integer): Integer;
Begin
    case AMonth of
    1,3,5,7,8,10,12:
        Result := 31;
    4,6,9,11:
    Result := 30;
    2:
    Begin
        if IsLeapYear(AYear) then
            Result:=29
        Else
            Result:=28;
    end;
    Else
        Result:=0;
end;

cdecl

Cdecl是函数调用协定的一种, 它规定了从C或C++编写的DLL中调用函数所必须遵守的规则.它可以将C或C++中的数据类型转换为Delphi的.
例如C++中的代码:

int X(int i)
{
    return i*2;
}

这个函数被编译在Demo.dll中, 用Delphi调用时必须使用:
function X(i: Integer): Integer; Cdecl; external 'Demo.dll';


class

Class关键字用于声明或继承一个类, 也可以使类和接口同时继承.另外, Class关键字也能用于声明类通用方法, 使得父类可以从类内访问子类的方法.
Type
ClassDemo = class(TObject)
Private
Public
constructor Create;
end;
如果用class声明方法, 则该方法在类与相关类中都可以使用, 譬如:
Type
ClassA = class
Private
Public
procedure Y;
end;
Type
ClassB = class(ClassA)
Private
Public
class procedure X;
end;
则在使用时ClassA能够直接访问ClassB的X方法
procedure ClassA.Y;
Begin
Self.X;
end;
此时父类将子类的class方法作为自身的方法进行调用.


const

Const关键字用于声明常量, 使用const声明的数据将不能在程序中被改变.也可以用来声明函数参数, 用const指定的参数不允许在函数中改变.
const MyFileName = 'Delphi';
const MyInteger = 100;
用Const声明常量不需要指出其数据类型, 系统会自动判断类型, 并作自动调整.函数中可以用const声明不可更改的参数:
function X(const i: Integer): string; // 此时在函数操作过程中, i的值不可改变.


constructor

constructor关键字用来声明一个类的构造函数, 当类被实例化时, 首先调用此函数.构造函数一般用Create表示, Create方法能够连带类中存在的CreateWnd方法.
Type
ClassDemo = class(TObject)
Private
fValue: Integer;
Public
constructor Create;
end;
constructor ClassDemo.Create;
Begin
fValue := 0;
end;


contains

Contains关键字指出了某个包(Package)是否包含某个文件.用Contains引入的文件必须被添加到包文件中, 它可以避免关键文件的引用丢失.
package DATAX;
requires rtl, clx;
contains Db, DBLocal, DBXpress;
end.


default

Default关键字用于指出一个属性的默认值,只有有序类型的属性才允许默认值的存在,否则必须在构造函数中初始化属性值.
Type
ClassDemo = class
Private
fValue: Integer;
Published
property Value: Integer read fValue write fValue default 0;
end;
它也可以指出一个类的默认属性
property strings[Index: Integer]: string read GetString write PutString; Default;


destructor

Destructor用于标识析构函数, 析构函数在类被释放时自动调用。析构函数只允许覆盖, 再不允许重载。析构函数通常用Destroy作为函数名.
Type
ClassDemo = class(TComponent)
Public
destructor Destroy;override;
end;
由于TComponent类中也有Destroy方法, 所以要将其重写。但是若要重载析构函数, 则不允许, 下面代码是错误的:
destructor Destroy; overload;


dispid

DispId关键字被用在DispInterface接口中, 用于指定特定的适配序号.在DispInterface接口中, 适配序号必须是唯一的, 如果不指定DispId, 则系统会自动分配适配序号给接口内每一个方法.可以通过适配序号访问DispInterface接口中的方法.
Type
IStringsDisp = dispinterface
['{EE05DFE2-5549-11D0-9EA9-0020AF3D82DA}']
property ControlDefault[Index: Integer]: Olevariant dispid 0; default;
function Count: Integer; dispid 1;
property Item[Index: Integer]: Olevariant dispid 2;
procedure Remove(Index: Integer); dispid 3;
procedure Clear; dispid 4;
function Add(Item: Olevariant): Integer; dispid 5;
function _NewEnum: IUnknown; dispid -4;
end;


dispinterface

DispInterface用于声明一个特定的适配器接口, 这个适配器能够接受标准系统接口中传入传出的数据.用DispInterface声明的接口不能被继承, 只能够被引用.DispInterface中方法只能调用, 并且必须被动态绑定.可以通过DispId为接口内方汉分配适配序号.DispInterface仅能用于Windows平台, 如果在Linux下进行开发, 则此关键字会自动被系统屏蔽.通常情况下, 不使用DispInterface.实例请参见DispId


div

Div用于求两数之整数商.用于Div运算的两个数值必须均为整型, 其运算结果也为整型.
Var
a,b,c:Integer;
Begin
a := 20; b := 3;
c := a div b; {6}
end;


do

Do关键字用于For, While, On, With语句, 构成特定的结构。
For语句:
for i := 1 to 100 do sum:=sum+i;
While语句:
while i < 100 do
Begin
 sum := sum + i;
Inc(i);
end;
On语句(异常处理):
Try
 i := StrToInt(s);
Except
 on exception do
ShowMessage('Error!');
end;
With语句:
with Memo1.Lines do
Begin
 Clear;
 Append('abc');
 Append('123');
end;


downto

DownTo关键字用于For语句, 指明循环变量是递减的.
for i := 100 downto 1 do
ListBox1.Items.Add(IntToStr(i));
在For语句中, 循环变量递增用To关键字, 递减用DownTo关键字.


dynamic

Dynamic用于声明一个动态的方法, 动态方法可以被覆盖, 并且可以使代码大小尽可能的减少(区别于Virtual).
procedure X(i: Integer); dynamic;


else

else用于引导程序的运行方向, 它可以与If, Case和On语句联用, 当条件不满足时, 转到else下运行
If语句(在If语句中, else前不允许有分号):
if a > b then
c := a
Else
c:=b;
Case语句:
case Tag Of
1:Result:=1;
2:Result:=2;
3:Result:=3;
Else
Result:=0;
end;
On语句(异常处理):
Try
i := StrToInt(s);
Excpet
on EZeroDivide do
Result := 1;
on EOverflow do
Result := 2;
Else
Result := 0;
end;


end

End用于结束一个语句块或是一个单元.它可以与begin, Case, Class, Interface, Asm, Unit, Package等相匹配.对于语句块(局部结束), End后必须添加分号.而对于单元或包(全局结束), end后必须添加句号.在If语句中else关键字前的End后不允许添加符号.
procedure X;
Begin
 with Button1 do
 Begin
if Button1.ShowHint then
   Button1.Caption := 'Hinted'
Else
   Button1.Caption := 'Not Hinted';
end;
end;
End;
在包内使用End来结束:
package DATAX;
requires rtl, clx;
contains Db, DBLocal, DBXpress;
end.


except

except关键字用于异常处理, 必须用在try语句内, 如果发生异常, 则执行except后的语句
Try
i := StrToInt(s);
Except
ShowMessage('Error!');
end;


export

export标明了函数调用协定, 指出函数可以被输出, 输出的函数能被本地或远程调用.其他程序可以用dll的形式调用程序内的函数.它是向下兼容的.
function Add(a,b: Integer): Integer; export;
如果这个程序被编译为Demo.exe, 并且另一个程序需要调用这个函数, 可以使用以下语句function Add(a,b: Integer): Integer; stdcall; external 'Demo.exe';


exports

exports用于输出对象, 它必须被用在接口和实现之间, 可以同时输出多个项, 项与项之间用逗号分开.
library Demo;
function X(i: Integer): string; stdcall;
begin
 Result:=IntToStr(i);
end;
exports X;
begin
end.
如果输出的对象被重载, 则必须给对象起个别名, 并注明参数.
library Demo;
function X(i: Integer): string; overload; stdcall;
begin
 Result := IntToStr(i);
end;
function X(s: string): Integer; overload; stdcall;
begin
 Result := StrToInt(s);
end;
exports X(i: Integer) name 'x1', X(s: string) name 'x2';
begin
end.


external

external关键字用于引用一个外部的或是OBJ内的方法.
{$L Demo.OBJ}
procedure X(i:Integer);external;
如果是从dll或外部程序中引用, 则可以使用以下代码:
function A(FileName: string): string; external 'Demo.dll';
如果被引用的函数被重载, 则必须另外指出引用的名称.
function A(Name: string): string; overload; stdcall; external 'Demo.dll' name 'A1';
function A(Code: Integer): string; overload; stdcall; external 'Demo.dll' name 'A2';
使用External关键字时, 必须注意大小写, 否则将出现错误.


far

far标明了函数调用协定, 指出函数可以被远程调用.其他程序可以用dll的形式调用程序内的函数.它是向下兼容的.
function Add(a,b: Integer): Integer; Far;
如果这个程序被编译为Demo.exe, 并且另一个处于其他计算机的程序需要调用这个函数, 可以使用以下语句:
function Add(a,b: Integer): Integer; stdcall; external 'Demo.exe';


file

file关键字指出了文件操作类型, 文件必须被声明为file, 如果在File后追加Of和文件类型, 则文件可以被定义为读写指定类型数据.
type
TPerson = record
PName: string[32];
PAge: Integer;
end;
var
PFile: file of TPerson;


finalization

finalization关键字标识了单元被释放时所要调用的方法, 通常是释放掉单元中不能自动释放的对象, 也可以不用.finalization最常用的情况是对OLE对象做反初始化.
initialization
ActiveX.OleInitialize(nil);
finalization
ActiveX.OleUninitialize;


finally

finally关键字指出了异常处理中最后必须要调用的方法, 不论是否发生异常, finally后的语句总是在try语句结束时执行.
try
Node := Node.GetNext;
Edit1.Text := Node.Text;
finally
 Node := nil;
end;


for

For关键字引出For循环结构, 用于做指定次数的循环.
for i := 1 to 100 do sum := sum + i;
如果循环变量是递减的, 则可以用DownTo关键字
for i := 100 downto 1 do Inc(sum);


forward

Forward关键字用于方法的前置定义.只定义方法声明, 然后在程序的后面对方法进行实现.这么做有利于代码的可读性, 可以将所有的声明放在一起, 然后将所有的实现也放在一起.
function X(i: Integer): Integer; forward;
procedure Y(s: string); forward;
function X;
begin
Result := i * 2;
end;
procedure Y;
begin
WriteLn(s);
end;
用Forward前置声明的方法在实现时不需要再输入方法的参数和返回值, 直接使用方法名即可.


function

Function用于声明函数
function X(i: Integer): Integer;
它也可以用于动态函数的声明
type
 TFun = function(i: Integer): Integer of object;
动态声明时, 不需要指出函数名, 只需要指出参数和返回类型就可以, 具体的函数名可以在后期绑定.


goto

Goto语句用在跳转行号, 可以跳转到当前结构层内任意位置.必须在声明处用label关键字声明行号.由于Goto语句会破坏程序的结构, 不推荐使用.
var
 a,b: Integer;
label X,Y;
begin
 if a > b then
goto X
else
goto Y;
X:
 WriteLn('a > b');
Y:
 WriteLn('b > a');
end;


if

If关键字引出If条件语句, 用于对条件进行判断.
var
 a,b: Integer;
begin
 a := 2;
b := 3;
 if a>b then
WriteLn('a=' + IntToStr(a))
else
WriteLn('b=' + IntToStr(b));
end;
If语句的通常结构是If...Then...else, else语句也可以不要.在If语句内如果有多个子语句, 则必须用begin...End结构进行区分.
if a > b then
begin
 WriteLn('a>b');
 WriteLn('a=' + IntToStr(a));
 WriteLn('b=' + IntToStr(b));
End
else
 WriteLn('b>a');


implementation

Implementation标识了单元中的实现部分, 单元的基本结构为:
Unit
...
Interface
...
implementation
...
end.
函数体, 过程体等必须写在implementation关键字后.如果在implementation后引用对象, 则对象是非公开的, 仅能供单元自身使用.
implementation
uses frmAbout;
begin
FormAbout.Show;
end;
一个完整的单元必须拥有implementation部分.


implements

Implements指出了一个属性从接口继承, 此时属性被转换成接口对象.通过接口动态绑定属性, 并动态的设定属性值.
type
 IMyInterface = interface
procedure P1;
procedure P2;
end;
TMyImplclass = class
procedure P1;
procedure P2;
end;
TMyclass = class(TInterfacedObject, IMyInterface)
FMyImplClass: TMyImplClass;
property MyImplClass: TMyImplclass read FMyImplclass implements IMyInterface;
procedure IMyInterface.P1 = MyP1;
procedure MyP1;
end;
通过implements声明后, 可以在类声明时指出接口中方法的实体, 如上例中的:
procedure IMyInterface.P1 = MyP1;


private

Private标明了类内元素的访问区分权限, 被Private区分的元素只能被本类内部访问.


procedure

Procedure用于声明过程
procedure X(i: Integer);
它也可以用于动态函数的声明
type
 TProc = procedure(i: Integer) of object;
动态声明时, 不需要指出过程名, 只需要指出参数就可以, 具体的过程名可以在后期绑定.


program

Program关键字用于指出一个工程为应用程序.控件库编译后生成exe文件, 可以直接执行
program Project1;
uses
Forms,
Unit1 in 'Unit1.pas' ;
{$R *.res}
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Application.Run;
end.


property

Property关键字用于声明属性, 属性分为显式属性和隐式属性两种,
只有声明在published访问区分符下的属性才是显式属性, 可以直接在对象查看器中查看.
type
 TDemo = class
 Private
  fValue: Integr;
 Published
  property Value: Integer read fValue write fValue;
 end;
事件也是属性的一种, 可以在published区分符下用Property进行声明
type
 TOnTextChange=procedure (Sender: TObject) of object;
 TDemo = class
 private
  fEvent: TOnTexChange;
 published
  property OntextChange: TOnTextChange read fEvent write fEvent;
 end;


protected

Protected标明了类内元素的访问区分权限, 被Protected区分的元素只能被本类内部和其子类访问.


public

Public标明了类内元素的访问区分权限, 被Public区分的元素能够被类内和类外任何对象访问.


published

Published标明了类内元素的访问区分权限.
被Published区分的元素能够被类内和类外任何RTTI对象访问
只在声明在Published区分符下的属性才能够成为显式属性并在对象查看器中显示.


raise

Raise语句用于抛出异常,
如果希望通过外部程序处理异常, 或是在异常发生时重新将异常抛出, 可以使用Raise语句.
function GetString(i: Integer): string;
begin
 if i < 0 then
  raise exception.Create('Integer Cannot smaller than 0');
 Result := IntToStr(i);
end;
在异常处理中, 可以重新抛出异常
try
 i := StrToInt(s);
except
 on E: exception do
  raise exception.Create(E.Message);
end;


read

Read用于标识属性中读取所使用的成员或方法.
private
 fValue: Integer;
published
 property Value: Integer read fValue;
上例中即表明Value属性的值从fValue成员上读取.


readonly

ReadOnly关键字用于标识一个对象是否只读.
property ReadOnly;
当ReadOnly设为True时, 不允许用户手动修改属性, 只能通过其他对象来操作.


record

record关键字用于声明一个结构体记录,
一个结构体可以视为一个不需要实例化的对象, 拥有自己的成员.
type
 TPerson = record
  PName: string[32];
  PAge: Integer;
 end;


register

Register标明了函数调用协定, 指出函数在被调用时可以在注册表内留下记录.它是向下兼容的.
function Add(a,b: Integer): Integer; Register; Register
关键字还用于向控件库或是IDE注册控件或是专家工具.
procedure Register;
begin
 RegisterComponents('Sample', [TDemo]);
end;


reintroduce

Reintroduce用于重新发布方法, 通常用于继承时, 如果要覆盖的方法是静态方法, 或是需要修改方法的参数等, 必须用Reintroduce进行重发布.
对于Virtual或Dynamic方法, 可以直接用Override进行覆盖.
type
 TClassA = class
  procedure X;
 end;
 TClassB = class(TClassA)
  procedure X; reintroduce;
 end;
 TClassC = class(TClassB)
  procedure X(i: Integer); reintroduce;
 end;


repeat

repeat关键字用于引出repeat循环结构, 该循环必须先执行一次循环体, 然后再对循环条件进行判断.repeat必须与Until关键字联合使用.
i := 0;
repeat
 sum := sum + i;
 Inc(i);
until(i >= 100);


requires

Requires关键字指出了编译Package时的必备条件.若Requires的条件未满足, 则不允许编译包.
package DATAX;
requires
rtl,
clx;
end.


resourcestring

ResourceString用于声明资源字符串, 资源字符串可以在被声明的结构内使用.
ResourceString
 CreateError = 'Cannot create file %s';
 OpenError = 'Cannot open file %s';
 LineTooLong = 'Line too long';
 ProductName = 'Borland Rocks';
 SomeResourceString = SomeTrueConstant;


safecall

Safecall是函数调用协定的一种, 它规定了被COM调用的函数所必须遵守和规则.
在编译时, Safecall声明的函数被编译成COM接口兼容的.
procedure X(s: WideString); safecall;
在编译后成为:
procedure X(s: PAnsiString);


set

Set关键字用于声明集合类, 集合类允许用集合运算符, 如in等进行操作.
type
 TCol = (cA,cB,cC);
 TCols = set of TCol;
操作时允许使用加减符号来添加或删除某个集合元素
var
 Cols: Tcols;
begin
 Cols := Cols + [cA,cB];
end;


shl

SHL表示向左移位, 左移的位数即乘以2的幂数
var
 x: Integer;
begin
 X := 2 shl 3; {16}
end;


shr

SHR表示向右移位, 右移的位数即除以2的幂数
var
 x: Integer;
begin
 X := 16 shr 2; {4}
end;


stdcall

Stdcall是函数调用协定的一种, 它规定了能让程序调用的函数所应遵守的规则.
Stdcall关键字必须在主调方和被调方之间形成配对.
例如, 被调方函数:
Library Demo;
function X(i: Integer): Integer; stdcall;
begin
 Result := i * 2;
end;
exports
 X;
begin
end.
主调方函数:
function X(i: Integer): Integer; stdcall; external 'Demo.dll';
同时需要注意, 使用Stdcall关键字时, 被调函数是大小写敏感的, 此处极容易出错.


stored

Stored用于指出一个属性的值是否能被保留, 若指定了True, 则允许对属性值进行赋值撤销的操作.
property Value: string read fValue write fValue stored True;


string

String是一个数据类型, 它代表了字符串.
var
 Str: string;


then

Then关键字用于If语句中, 当If条件成立时, 执行Then后的语句.
var
 a,b: Integer;
begin
 if a > b then
  WriteLn('a')
 else
  WriteLn('b');
end;


threadvar

Threadvar标识了一个随线程启动而创建的变量,
如果用Threadvar声明变量, 则在程序结束前必须手动释放其占用的空间.
threadvar S: AnsiString;
S := 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
S := ''; //S := ''; 即释放变量S所占用的内存.


to

To关键字用于For语句, 指明循环变量是递增的.
for i := 10 to 100 do
 ListBox1.Items.Add(IntToStr(i));
在For语句中, 循环变量递增用To关键字, 递减用DownTo关键字.


try

try语句用于异常处理, 对于有可能发生异常的语句, 可以放在try结构下, 以便对其进行异常保护.
try
 i := StrToInt(s);
except
 ShowMessage('Error');
end;


type

Type关键字用于声明各种对象, 用Type关键字声明的对象, 在传递时按引用传递.
type
 TDemo = class
 end;
type也用来声明枚举类型或是按引用传递的变量.
type
 TCol = (cA,cB,cC);
 TInt = Integer;


unit

//Unit标识了单元的开头, 单元的基本结构为
Unit
...
Interface
...
implementation
...
end.
Unit Unit1;
Interface
 uses Classes;
implementation
end.
一个完整的单元必须拥有Unit作为开头.


until

Until关键字用于判断repeat循环结构的循环条件,
如果循环条件为真, 则退出循环.Until必须与repeat关键字联合使用.
i := 0;
repeat
 sum := sum + i;
 Inc(i);
until(i >= 100);


uses

Uses用于引用一个外部的单元, 并且能够使用该单元中的公共部分.
Uses语句通常放在一个单元的接口或是实现部分.
Interface
 uses Classes;
Implemention
 uses frmAbout;


var

var关键字用于声明一个变量或是对象, 用var声明的变量接值传递.
var
 i: Integer;
 s: string;
var也可以用于标识按引用传递的方法参数
function X(var i: Integer): Integer;
上述函数中的参数i即按引用传递, 它的值可以在函数执行时被改变, 并返回主调函数.


varargs

varArgs标识了引用参数, 它必须和Cdecl关键字联用, 表明允许调用的函数使用引用传递.
function printf(Format: PChar): Integer; cdecl; varargs;
上述代码从C++的类库中引用了Printf函数, 并允许按引用的方式传入参数.


virtual

Virtual用于声明一个虚方法,
虚方法可以被覆盖, 并且可以使程序运行速度尽可能的快(区别于Dynamic).
procedure X(i: Integer); virtual;


while

While关键字用于引出While循环语句, 循环前先进行循环条件的判断, 如果条件为真则执行循环.
i := 0;
while i < 100 do
begin
 sum := sum + i;
 Inc(i);
end;


with

With关键字用于将相同的对象集合起来处理, 它可以省去输入大量重复的代码, 使代码看上去比较精简.
with Form1.Memo1.Lines do
begin
 Clear;
 Append('abc');
 Append('def');
 SaveToFile('C:\demo.txt');
end;
上面这段代码如果不使用With语句, 则显得非常冗余复制内容到剪贴板代码:
Form1.Memo1.Lines.Clear;
Form1.Memo1.Lines.Append('abc');
Form1.Memo1.Lines.Append('def');
Form1.Memo1.Lines.SaveToFile('C:\demo.txt');


write

Write用于标识属性中写入所使用的成员或方法.
private
 fValue: Integer;
published
 property Value: Integer write fValue;
上例中即表明Value属性的值写入到fValue成员上.


writeonly

writeonly关键字用于标识一个对象是否只写.
property writeonly;
当writeonly设为True时, 不允许用户读取属性, 只能通过其他对象来操作.


xor

Xor用于取异或, 当两个操作数相等时, 返回False, 不等时返回True.
var
 a,b: Integer;
begin
 a := 2; b := 3;
 if a xor b then
  WriteLn('a xor b')
 else
  WriteLn('a not xor b');
end;
Xor也用于计算异或值
WriteLn(IntToStr(3 xor 5)); {6}

Delphi和VC混合编程总结

  项目开发到了最后阶段,内核基本成型,Demo开发最终提上日程。

  为了尽快完成Demo开发,毕竟Demo只是为了演示,所以决定使用Delphi来完成,因为做界面Delphi的效率是相当高的。而我们的内核引擎是使用C++开发,VC编译,这就涉及到了Delphi和VC的混合编程,这里将这几天来的经验总结共享出来,需要的时候可以随时查看。

  目前的程序结构是这样的,内核使用dll封装为SDK,交付兄弟部门或者其他公司做二次开发,Demo采用Delphi主调内核,并实现结果呈现。

首先,在接口一层,要保证Delphi能够和VC进行数据交互,所以需要对应相关的数据类型。

同时这里不推荐在接口函数层使用复杂数据类型,因为如果参数和返回值过于复杂,是不能简单通过基本类型来进行传递的,这样编译器内部就会进行编码,以完成复杂数据类型的传递。但是不同的语言,甚至不同的编译器的内部实现不同,很容易导致复杂数据类型数据传递失败,而产生无效传递的情况,切记切记。

基本类型对照表如下:

VC Delphi
int Integer
unsigned int Cardinal
char Byte
wchar_t WideChar
int* PInteger
unsigned int* PCardinal
char* PByte
wchar_t* PWideChar

在数据类型对应的情况下,才能保证类型能够正确传递

其次,接口函数调用规范的统一

由于函数调用过程中函数参数要通过堆栈进行传递,而参数在堆栈中所占空间的释放问题由谁进行,直接导致函数调用规范的提出,这就是我们知道的stdcal,cdcel,pascal,fastcal等调用规范,为了保证参数的正确传递和结果的正确获取,需要在两种语言中统一调用规范。

这里使用stdcal,没有什么特殊的理由来选择这个,目的只有一个,那就是统一,以保证参数传递正确

最后,Delphi中声明VC动态链接库的导出函数

格式举例:

原型:

const wchar_t* __stdcall testW(const wchar_t* waveFile, const wchar_t* waveFmt, const wchar_t* grammarList, const wchar_t* params, int *recogStatus, int *result);
function test(waveFile:PWideChar;
                          const wav_Fmt: PWideChar;
                          const grammarList:PWideChar;
                          const params:PWideChar;
                          recogStatus:PInteger;
                          func_result:PInteger): PWideChar;stdcall;
                                                 external “qisr.dll” name 'testW';

简单解释一些函数声明的含义:
function 用于定义函数
external 关键字用于定义导出该函数的动态链接库名
name 用于定义动态链接库中导出函数的导出名

如果有VC链接库开发经验的朋友可能会发现,为什么Delphi中没有类似VC中对应于dll的lib导入库呢?这里简单解释一下,其实VC中与dll配套的lib文件起到的作用也就是告诉连接器静态链接导出函数的时候,从哪里获取导出函数入口地址用的,实际没有实体代码,这里Delphi中的声明代码其实起到的也就是这个作用。由于lib没有实体代码,所以很容易通过dll获取对应的lib导入库。

(转)Delphi属性Property学习应用总结

Property是一个很有意思的语法特性,它使得方法具有了字段的调用特征,并赋予字段执行动作的能力。

如果你使用过C++ Builder来写基于VCL的程序,我想很多人都会注意到这样一点,比如:
edt.Text = "test"; 这个时候edt文本框的内容会随之改变,但是“理论”上Text应该只是改变了Text所在的内存数据而已,为什么会导致窗口更新界面着一些列动作?

这就是因为Property这一特性,Property是Borland为C++扩展的语法特性,目的在于使C++ Builder能够方便的使用VCL库,毕竟VCL是使用Object Pascal写的。

有些扯远了,言归正传,这里还是总结一下在Delphi中如何使用Poperty这一语法特性。

如果学习过C#的朋友应该会很容易理解,因为C#的属性就是学习自Delphi,毕竟C#和Delphi是同一个设计者。

定义一个属性Property的基本格式如下:
property 属性名 : 属性值类型 read 属性读函数/属性值变量 write 属性写函数/属性值变量

这里简单解释一下:
1。Property是属性定义关键字。

2。属性的特征类似于字段,所以属性名就像字段名,属性值类型就像字段的值类型

3。属性读函数,是属性被“读取”时所执行的操作,这样在执行“取值”操作时,具备了执行其他动作的可能。
另外,属性值变量,可以是Property所在类能够访问的任何变量,如果使用了属性值变量,则相当于属性值直接从值变量中获取,这和直接赋值是没有什么差别的

4。属性写函数,是属性被“写入”时所执行的操作,这样在执行属性“赋值”操作时,具备了执行其他动作的可能。比如:写入edt的Text属性时,窗口会同时执行界面更新操作。
另外,属性值变量和3中所述类似,如果使用了,就相当于将传来的属性值直接赋值到对应的属性值变量

这里的函数是真正的函数,不像C#中那样的getter和setter,所以会有些难以理解。

5。属性读函数的函数声明:
function 读函数名: 属性值类型;

其中读函数名可以自定义,只要和属性声明中一样即可,该函数的返回值就是读属性操作时实际获取的值。

6。属性写函数声明(其实是一个子函数):
procedure 写函数名(value : 属性值类型)

其中写函数名可以自定义,只要和属性声明中一样即可,该函数参数value,就是对属性赋值时传递过来的实际值。

7。读函数和写函数必须设置一个,如果只设置读函数,而没有设置写函数(同时去掉write关键字),这样的属性就是只读属性,同理也可以设置只写属性

8。为了保证属性公开性的同时掩盖读写函数的可见性,可以将读写函数设置为私有,而将属性设置为共有,这样可以避免将读写函数本身暴露给调用者,否则就不太拉风了。

举例:

TxKernelSearchThread = class(TThread)
   private
    keyword_list: TStringList;
     procedure SetKeyword(value: UnicodeString);
   public
    property Kerword:UnicodeString write SetKeyword;
    。。。
end;

procedure TxKernelSearchThread.SetKeyword(value: UnicodeString);
begin
  if value = '' then Exit;
  ExtractStrings([' '],[' '],PWideChar(value),Self.keyword_list);
end;

上面是一个只写属性的例子。

属性的一个很重要的应用就是VCL中的控件属性,以及事件属性等,这也就解释了为什么向文本框的Text属性赋值,会更新界面操作,这正是因为属性将字段和函数的特征结合了起来。

Delphi中使用TThread进行多线程开发总结

最近项目的Demo开发使用Delphi 2010,其中使用了多线程开发技术

这里采用VCL的TThread类完成多线程开发,直接使用CreateThread的办法之前用过很多,这里就当练习,试试采用TThread类

TThread类类似VC中的CThread,主要是采用面向对象思想对CreateThread封装了一层,方便多线程的代码编写,线程执行所需要的相关参数可以很方便的设置,线程的操作和线程状态的获取也很方便。至于内部原理,有兴趣的话可以看看VCL源代码,这里就不深入探讨了。

所使用TThread完成多线程开发,可以按照如下步骤进行:

1。从TThread派生一个类,例如TxDerivedThread,并重载Execute函数,多线程的核心代码主要就在该函数中

2。如果在线程执行中需要设置相关执行参数,则可以在派生类TxDerivedThread中添加字段,并使外部调用者有办法修改,比如使用公共字段,设置Setter函数,或者公共Property。这些字段在Execute函数中是可以访问到的,这样就达到了对函数设置执行参数的目的。

但是因为在构造线程类对象时,线程默认会自动执行,而不会挂起,这样外界就没有了设置参数的时机,所以如果需要设置线程执行参数,则需要重载构造函数Create,在其中调用TThread的构造函数,并传递参数True,使线程创建后立即挂起,然后设置相关参数,最后再将线程Resume即可,这样外部就能够控制线程的创建了

例如如下的派生类:

TxKernelBuildThread = class(TThread)
private
    main_form: HWND; // 主界面窗口句柄
    procedure SetMainForm(value: HWND);
protected
    procedure Execute; override;
。。。
public
    property MainWnd: HWND write SetMainForm;
。。。
end;

constructor TxKernelBuildThread.Create(suspend: Boolean);
begin
    inherited Create(suspend);
end;

在构造时调用者将suspend传递为True,这样线程在创建之初就会挂起,调用者就有机会设置参数了

例如如下的字段设置函数:

procedure TxKernelBuildThread.SetMainForm(value: HWND);
begin
    if value = 0 then
    begin
        Exit;
    end;
    Self.main_form:=value;
end;

在线程创建之后,就可以设置相关的参数,并在线程执行过程中使用:

例如:

procedure TxKernelBuildThread.Execute;
var
fmt: UnicodeString;
params: UnicodeString;
ret: Integer;
begin
   PostMessage(main_form,THREAD_INDEX_START,Self.id,0);
。。。
end;

这样就完成了线程执行参数的传递工作。

至于线程执行结果的获取,也可以采用类似的方法。

3。如果要控制线程的执行,比如挂起,恢复,终止;或者获取线程的状态,比如是否完成,是否挂起等,都有相关的封装函数。

操作函数:Suspend;Resume;Terminate;等

状态获取:ReturnValue;Terminated;Finished;Suspended;等

其他详细函数,可以查看CDN(类似于MSDN,Embarcadero确实比Borland勤快很多了,呵呵)

4。其他的线程同步操作,主要也就是临界区,互斥体,信号量等,这些就不讨论了,比较基本,以后有机会再补上吧。