Delphi 指针及其它(转)

Delphi 指针大全
- 1 -
目 录
1 DELPHI 的指针-引用.................................................................................- 1 -
2 delphi 的“引用/值”模型..............................................................................- 5 -
3 谈谈 Delphi 的类型与指针.................................................................... - 13 -
4 Delphi 7 指针数据类型............................................................................ - 17 -
5 delphi 中的Pchar 指针............................................................................. - 19 -
1 DELPHI 的指针-引用
大家都认为，C 语言之所以强大，以及其自由性，很大部分体现在其灵活的指针运用上。因
此，说指针是C 语言的灵魂，一点都不为过。同时，这种说法也让很多人产生误解，似乎
只有C 语言的指针才能算指针。Basic 不支持指针，在此不论。其实，Pascal 语言本身也
是支持指针的。从最初的Pascal 发展至今的Object Pascal，可以说在指针运用上，丝毫不
会逊色于C 语言的指针。
以下内容分为八个部分，分别是
一、类型指针的定义
二、无类型指针的定义
三、指针的解除引用
四、取地址（指针赋值）
五、指针运算
六、动态内存分配
七、字符数组的运算
八、函数指针
一、类型指针的定义。对于指向特定类型的指针，在C 中是这样定义的：
int *ptr;
char *ptr;
与之等价的Object Pascal 是如何定义的呢？
var
ptr : ^Integer;
ptr : ^char;
其实也就是符号的差别而已。
Delphi 指针大全
- 2 -
二、无类型指针的定义。C 中有void *类型，也就是可以指向任何类型数据的指针。Object
Pascal 为其定义了一个专门的类型：Pointer。于是，
ptr : Pointer;
就与C 中的
void *ptr;
等价了。
三、指针的解除引用。要解除指针引用（即取出指针所指区域的值），C 的语法是 (*ptr)，
Object Pascal 则是 ptr^。
四、取地址（指针赋值）。取某对象的地址并将其赋值给指针变量，C 的语法是
ptr = &Object;
Object Pascal 则是
ptr := @Object;
也只是符号的差别而已。
五、指针运算。在C 中，可以对指针进行移动的运算，如：
char a[20];
char *ptr=a;
ptr++;
ptr+=2;
当执行ptr++;时，编译器会产生让ptr 前进sizeof(char)步长的代码，之后，ptr 将指向a[1]。
ptr+=2;这句使得ptr 前进两个sizeof(char)大小的步长。同样，我们来看一下Object Pascal
中如何实现：
var
a : array [1..20] of Char;
ptr : PChar; //PChar 可以看作 ^Char
begin
ptr := @a;
Inc(ptr); // 这句等价于 C 的 ptr++;
Inc(ptr, 2); //这句等价于 C 的 ptr+=2;
end;
六、动态内存分配。C 中，使用malloc()库函数分配内存，free()函数释放内存。如这样的
代码：
int *ptr, *ptr2;
Delphi 指针大全
- 3 -
int i;
ptr = (int*) malloc(sizeof(int) * 20);
ptr2 = ptr;
for (i=0; i<20; i++){
*ptr = i;
ptr++;
}
free(ptr2);
Object Pascal 中，动态分配内存的函数是GetMem()，与之对应的释放函数为FreeMem()
（传统Pascal 中获取内存的函数是New()和 Dispose()，但New()只能获得对象的单个实
体的内存大小，无法取得连续的存放多个对象的内存块）。因此，与上面那段C 的代码等
价的 Object Pascal 的代码为：
var ptr, ptr2 : ^integer;
i : integer;
begin
GetMem(ptr, sizeof(integer) * 20);
//这句等价于C 的 ptr = (int*) malloc(sizeof(int) * 20);
ptr2 := ptr; //保留原始指针位置
for i := 0 to 19 do
begin
ptr^ := i;
Inc(ptr);
end;
FreeMem(ptr2);
end;
对于以上这个例子（无论是C 版本的，还是Object Pascal 版本的），都要注意一个问题，
就是分配内存的单位是字节（BYTE），因此在使用GetMem 时，其第二个参数如果想当然
的写成 20，那么就会出问题了（内存访问越界）。因为GetMem(ptr, 20);实际只分配了20
个字节的内存空间，而一个整形的大小是四个字节，那么访问第五个之后的所有元素都是非
法的了（对于malloc()的参数同样）。
七、字符数组的运算。C 语言中，是没有字符串类型的，因此，字符串都是用字符数组来实
现，于是也有一套str 打头的库函数以进行字符数组的运算，如以下代码：
char str[15];
char *pstr;
strcpy(str, "teststr");
Delphi 指针大全
- 4 -
strcat(str, "_testok");
pstr = (char*) malloc(sizeof(char) * 15);
strcpy(pstr, str);
printf(pstr);
free(pstr);
而在Object Pascal 中，有了String 类型，因此可以很方便的对字符串进行各种运算。但是，
有时我们的Pascal 代码需要与C 的代码交互（比如：用Object Pascal 的代码调用C 写的
DLL 或者用Object Pascal 写的DLL 准备允许用C 写客户端的代码）的话，就不能使用String
类型了，而必须使用两种语言通用的字符数组。其实，Object Pascal 提供了完全相似C 的
一整套字符数组的运算函数，以上那段代码的Object Pascal 版本是这样的：
var str : array [1..15] of char;
pstr : PChar; //Pchar 也就是 ^Char
begin
StrCopy(@str, ’teststr’); //在C 中，数组的名称可以直接作为数组首地址指针来用
//但Pascal 不是这样的，因此 str 前要加上取地址的运算符
StrCat(@str, ’_testok’);
GetMem(pstr, sizeof(char) * 15);
StrCopy(pstr, @str);
Write(pstr);
FreeMem(pstr);
end;
八、函数指针。在动态调用DLL 中的函数时，就会用到函数指针。假设用C 写的一段代码
如下：
typedef int (*PVFN)(int); //定义函数指针类型
int main()
{
HMODULE hModule = LoadLibrary("test.dll");
PVFN pvfn = NULL;
pvfn = (PVFN) GetProcAddress(hModule, "Function1");
pvfn(2);
FreeLibrary(hModule);
}
就我个人感觉来说，C 语言中定义函数指针类型的typedef 代码的语法有些晦涩，而同样的
代码在Object Pascal 中却非常易懂：
type PVFN = Function (para : Integer) : Integer;
Delphi 指针大全
- 5 -
var
fn : PVFN;
//也可以直接在此处定义，如：fn : function (para:Integer):Integer;
hm : HMODULE;
begin
hm := LoadLibrary(’test.dll’);
fn := GetProcAddress(hm, ’Function1’);
fn(2);
FreeLibrary(hm);
end;
附：
Delphi 中指针功能非常强大，所有c 中能实现的指针Delphi 中都能实现. 上面认为Delphi
指针不是强项的只是一种误解(或者对指针的机制一知半解).
由于Pascal 语言的限制, 用Delphi 的指针时很多情况下需要强制类型转换. Delphi 中提供
了很多指针类型, 而且非常方便的是你可以自定义自己的指针类型.
一个经验: 要掌握一种数据类型并且能够灵活应用,一个比较好的办法是别考虑什么类型是
什么名字, 而只需要考虑这种类型的变量将占用多少字节. 凡是字节数相同的类型都可以
认为是同一类型 :-), 提供不同类型只是为了编译器能够更方便的查找错误而已. 比如:
Integer, Pointer, PChar, TSmallPoint 甚至 array [0..4] of Char
你都可以把他们当成是同一类型加以使用(有了这种思路, 可以实现很大的程序灵活性和代
码高效性). 所以我很不理解的是JAVA 中不支持指针(因此我也认为用JAVA 绝对不可能写
出很高效的程序, 而且会有很多C/C++/DELPHI 中用一句话可以完成的工作在JAVA 中需
要用一个复杂过程, 消耗很多额外内存才能达到相同目的). 就事论事, 根据你的问题在
Delphi 中和C 中的解决方案没什么两样.
http://hi.baidu.com/sswanglei/blog/item/3b55d88bcab41d14c8fc7a94.html
2 delphi 的“引用/值”模型
D 中简单的数据类型（如integer,char，record 等）无论作为参数还是变量都是按值传递和
使用的，通常称为值类型。值类型也是直接类型，即每个变量都有自己的存储数据的实际的
Delphi 指针大全
- 6 -
内存空间，更改了变量也就直接更改了它的数值。
D 中复杂的数据类型（如class)则是按引用传递和使用的。引用类型是间接类型，它
存储的是间接数据，即堆该数据的引用（可以理解为指针），也就是存储的是实际数据数据
存储内存的地址。
当这两种变量和参数传递时候，值类型传递的是值的副本，引用类型传递的是引用
的副本。因为，值类型数据存放在栈中，而引用类型数据存放在堆中。处理器直接使用栈指
针分配和访问内存。我们把对象存储在堆中，而把对象的引用和值类型存放在栈中。因为值
类型和对象的引用可以确定其大小和生命期，但是对象无法确定其大小和生命期。而编译器
无法知道对象要从堆中分配多少内存空间，占用多长内存时间。所以，在栈中的变量不需要
程序员手工释放，而堆中的变量需要程序员手工分配空间和销毁。程序中通过对象引用来访
问对象，改变对象引用无法改变对象本身。
D 中对象引用和类引用
一个对象引用就是一个句柄或指针，当你分配一个对象引用给一个变量时候，D 仅
复制引用，而不是整个对象。当程序不再使用该对象时候，应该free 显式将其销毁。一个
对象引用通常以一个变量形式存在，但也有函数或责属性返回值的形式。
同一个类创建的对象，通过类引用都指向同一个类表。
someobj:=Tobj.create;
someobj 就是对象引用，而Tobj 就是类引用。
类引用类型是“类的类”（class of class）类型，也称元类（metaclass）。其构造形
式为：class of type。type 为任何类型。类引用类型的声明不能直接用于变量或者参数声明
中。可以把nil 赋值给任何类引用变量。如果把类看做对象的模板，那么元类就是类的模板。
类引用是引用以个具体类的表达式。类引用在D 中用做生成新对象、调用类方法，
已经测试或者转换对象类型。类引用实现为指向一个关于该类的信息表的指针，特别是类的
虚方法表（VMT)。通常，类引用的函数是一个类的名称，但也可以是类型为元类的变量，
或者返回为类引用的函数或属性。
D 中的对象传递
在D 中，参数传递机制为值传递和引用传递。值传递传递的是数值参数（默认），
引用传递传递的是变量参数（var）。
function getsome(x:integer):integer; 值传递
function getany(var x:integer):integer; 引用传递
值传递getsome(a);中产生的x 是a 的一个副本，数值参数此时就好像是一个局部变
量，其变化不影响a 的值。但是引用传递getany(a)中产生的x 是指向a 的指针，变量参数
在函数中变化，直接影响到a 的值。引用传递时候，要注意变量参数及时传递给多个参数，
Delphi 指针大全
- 7 -
也不会创建他的副本。引用传递能改变传给它的变量的值。
总之，按值传递时候，行参和实参是两个变量；引用传递的时候是同一个变量。
注意的是，对象在做为参数传递的时候，由于我们在传递对象的时候，实际上传递
的都是对象的引用。所以，当对象作为参数传递时候，无论是采用值传递还是引用传递，传
递的都是对象的引用，不同的是值传递会产生一个引用的副本（相当于该对象的一个别名，
绑定的是同一个对象），但是如果修改形参的话，还是会修改实参的值。
D 中对象的克隆
TPersistent 类下的所有对象都是可以克隆的。
:=赋值操作符，是将一个对象引用赋值给一个对象变量（相当于多了一个别名，实体
对象只有一个）；
assign 或assignto 方法可以将对象属性进行赋值，得到两个状态一样的对象。（实
实在在的复制，内存×2，实体对象有两个）。
Delphi 指针大全
Delphi 指针理解
看一个指针用法的例子：
1 var
2 X, Y: Integer; // X and Y 整数类型
3 P: ^Integer; // P 指向整数类型的指针
4 begin
5 X :=17; // 给 X 赋值
6 P := @X; // 把 x 的地址赋给p
7 Y := P^; // 取出p 所指向的数值赋给
y
8 end;
第二行定义了两个变量X,y. 第三行声明了p 是指向整数类型的指针;意味着p 能够指
向x 或者y 的地址.第五行赋给x 值,第六行把x 的地址赋给p.最
后通过p 指向的变量赋值给y.此时,x 和y 有相同的值.
操作符@用来取出变量的地址,也可以取出过程和函数的地址.
Delphi 指针大全
- 8 -
而符号^有两个目标,
当它出现在类型定义的前面时如 ^typename 表示指向这种类型的指针;
当它出现在指针变量后边时 如 point^ 返回指针指向的变量的值;
理解指针比较容易理解面向对象的pascal 语言,因为指针经常在幕后操作.任何要求动态
分配大的内存空间的类型可以用指针类型.例如
,long-string 变量,实际在使用指针进行操作.另外一些高级的编程技术需要使用指针类型.
有时指针是适应object pascal 严格的类型限制的唯一方法.同过一个通用的指针类
型,通过类型转换成不同的指针类型,如下面的例子:
type
PInteger = ^Integer;
var
R: Single;
I: Integer;
P: Pointer; //通用的指针
PI: PInteger;
begin
P := @R; //取出R 的内存地址
PI := PInteger(P); //把通用类型转换成指向整数类型的指针
I := PI^;
end;
当然了,实数和整数的存储格式不同.这种赋值是把原始的二进制数据从R 拷贝到I,而不
进行转换.
保留字nil 是一个特殊的常量可以赋给任何指针类型,当nil 赋給一个指针时,指针什么也
不指向,是一个空指针.
@操作符返回变量的内存中的存储地址,或者是过程函数方法;
1.如果变量,@X 返回的是x 的地址。如果编译选项{$T-}没有打开,着返回的事一个通用的
指针,如果编译选项打开了,着返回的是x 的类型对应的指针.
Delphi 指针大全
- 9 -
2.如果是例程(过程函数),@F 返回的是F 的入口点，@F 的类型是一个指针。
3.当@用在类的方法中时,则方法的名称必须有类名,例如@TMyclass.Dosomething
指针指向TMyclass 的dosomething 方法。
当一个过程变量在赋值语句的左边时，编译器期望一个过程值在赋值语句的右边。这种
赋值使得左边的变量可以指向右边定义的过程或者函数
入口点。换句话说，可以通过该变量来引用声明的过程或者函数，可以直接使用参数的
引用。
var
F: function(X: Integer): Integer;
I: Integer;
function SomeFunction(X: Integer): Integer;
...
F := SomeFunction; // 给f 赋值
I := F(4); // 调用所指向的函数
在赋值语句中，左边变量的类型决定了右边的过程或者方法指针解释。
var
F, G: function: Integer;
I: Integer;
function SomeFunction: Integer;
...
F := SomeFunction; // 给f 赋值
G := F; // 把F 的值拷贝给G
I := G; // 调用函数
第一句获得函数的入口，第二句将指针复制，第三句获得函数的返回值。
有时候还可以这样使用
Delphi 指针大全
- 10 -
if F = MyFunction then ...;
在这里，F 的出现导致一个函数调用；编译器调用F 指向的函数，然后调用Myfunction，
比较结果。这个规则是无论何时一个过程变量（
procedural variable）出现在一个表达式中，它表示调用所指向的函数或者过程。有
时F 指向一个过程（没有返回值），或者f 指向一个需要参
数的函数，则前面的语句会产生一个编译错误。要比较F 和Myfunction 需要用
if @F = @MyFunction then ...;
@F 把F 转换成一个包含地址的无类型的指针变量,@myfunction 返回myfunction 的地
址。
获得一个过程变量的内存地址使用@@。例如，@@F 返回F 的地址。
@操作符通常把一个无类型的指针值赋给一个过程变量，例如：
var StrComp: function(Str1, Str2: PChar): Integer;
...
@StrComp := GetProcAddress(KernelHandle, 'lstrcmpi');
调用GetProcAddres 函数,用strcomp 指向这个值
任何过程变量可以赋成nil，表示指证什么也不指向。但是试图调用一个nil 值的过程变
量导致一个错误，为了测试一个过程变量是否可以赋值
，用标准的赋值函数Assigned
if Assigned(OnClick) then OnClick(X);
===================================================================
======
大家都认为，C 语言之所以强大，以及其自由性，很大部分体现在其灵活的指针运用上。因
此，说指针是C 语言的灵魂，一点都不为过。同时，这种说法也让很多人产生误解，似乎
只有C 语言的指针才能算指针。Basic 不支持指针，在此不论。其实，Pascal 语言本身也
是支持指针的。从最初的Pascal 发展至今的Object Pascal，可以说在指针运用上，丝毫不
会逊色于C 语言的指针。
以下内容分为八个部分，分别是
一、类型指针的定义
二、无类型指针的定义
三、指针的解除引用
四、取地址（指针赋值）
Delphi 指针大全
- 11 -
五、指针运算
六、动态内存分配
七、字符数组的运算
八、函数指针
一、类型指针的定义。对于指向特定类型的指针，在C 中是这样定义的：
int *ptr;
char *ptr;
与之等价的Object Pascal 是如何定义的呢？
var
ptr : ^Integer;
ptr : ^char;
其实也就是符号的差别而已。
二、无类型指针的定义。C 中有void *类型，也就是可以指向任何类型数据的指针。Object
Pascal 为其定义了一个专门的类型：Pointer。于是，
ptr : Pointer;
就与C 中的
void *ptr;
等价了。
三、指针的解除引用。要解除指针引用（即取出指针所指区域的值），C 的语法是 (*ptr)，
Object Pascal 则是 ptr^。
四、取地址（指针赋值）。取某对象的地址并将其赋值给指针变量，C 的语法是
ptr = &Object;
Object Pascal 则是
ptr := @Object;
也只是符号的差别而已。
五、指针运算。在C 中，可以对指针进行移动的运算，如：
char a[20];
char *ptr=a;
ptr++;
ptr+=2;
Delphi 指针大全
- 12 -
当执行ptr++;时，编译器会产生让ptr 前进sizeof(char)步长的代码，之后，ptr 将指向a[1]。
ptr+=2;这句使得ptr 前进两 个sizeof(char)大小的步长。同样，我们来看一下Object Pascal
中如何实现：
var
a : array [1..20] of Char;
ptr : PChar; //PChar 可以看作 ^Char
begin
ptr := @a;
Inc(ptr); // 这句等价于 C 的 ptr++;
Inc(ptr, 2); //这句等价于 C 的 ptr+=2;
end;
六、动态内存分配。C 中，使用malloc()库函数分配内存，free()函数释放内存。如这样的
代码：
int *ptr, *ptr2;
int i;
ptr = (int*) malloc(sizeof(int) * 20);
ptr2 = ptr;
for (i=0; i<20; i++){
*ptr = i;
ptr++;
}
free(ptr2);
Object Pascal 中，动态分配内存的函数是GetMem()，与之对应的释放函数为FreeMem()
（传统Pascal 中获取内存的函数是New()和 Dispose()，但New()只能获得对象的单个实
体的内存大小，无法取得连续的存放多个对象的内存块）。因此，与上面那段C 的代码等
价的 Object Pascal 的代码为：
var ptr, ptr2 : ^integer;
i : integer;
begin
GetMem(ptr, sizeof(integer) * 20);
//这句等价于C 的 ptr = (int*) malloc(sizeof(int) * 20);
ptr2 := ptr; //保留原始指针位置
for i := 0 to 19 do
begin
ptr^ := i;
Delphi 指针大全
- 13 -
Inc(ptr);
end;
FreeMem(ptr2);
end;
对于以上这个例子（无论是C 版本的，还是Object Pascal 版本的），都要注意一个问题，
就是分配内存的单位是字节（BYTE），因此在使用GetMem 时，其第二个参数如果想当然
的写成 20，那么就会出问题了（内存访问越界）。因为GetMem(ptr, 20);实际只分配了20
个字节的内存空间，而一个整形的大小是四个字节，那么访问第五个之后的所有元素都是非
法的了（对于malloc()的参数同样）。
Delphi 指针大全
3 谈谈 Delphi 的类型与指针
内存中的数据除了 0 便是 1, 你把它当作图片、字符、数字等等, 那是你的事, 内存只认识
0 和 1.
Win32 系统除了使用硬内存以外, 还可以从硬盘上开辟虚拟内存;
因为 Win32 的内存地址范围在 4 个 G 以内(0..232-1), 所以它最多能够给一个应用程序
分配 4G 的运行空间; 并且其中的 2G 有系统管理, 实际上程序只有 2G 的自主空间. 还
记得有说 String 最大长度是 2G 吗? 就是这个道理.
有 4G 的内存, 就有 4G 个地址, 也就是最多可以有 (1024*1024*1024*4 - 1 =
4294967295) 个内存地址, 这刚好是 Delphi 中 Cardinal 的最大值, 所以 32 位的指针
类型追到底都是 Cardinal 类型的一个数字.
一个内存地址是 0..4294967295 之间的一个数字, 你可以通过内存地址读取或写入数据;
一个指针要用来索引或标识内存, 它也是0..4294967295 之间的一个数字; 它们虽不相同,
但通过指针可以找到实际存储数据的内存地址, 并按指定的类型去读写它.
譬如:
var
str: string;
Delphi 指针大全
- 14 -
n: Cardinal;
pstr: PString;
begin
str := 'ABCDE';
n := Cardinal(str); {获取内存地址}
pstr := @str; {现在 pstr 是 str 的指针}
{n 与 pstr 的数字结果是(结果是随机的, 知道不一样就行了):}
ShowMessage(IntToStr(n)); {4571092}
ShowMessage(IntToStr(Cardinal(pstr))); {1244652}
{但通过 pstr 可以找到 str}
ShowMessage(pstr^); {ABCDE}
end;
程序运行后, 字符串所在的内存基本上是下面这个样子(以字节为单位), 上例中的 n 标识
着 ↓ 的位置:
↓
A B C D E
换二进制图示一下:
↓
00001010 00001011 00001100 00001101
00001110
如果只看二进制, 这个数据到底是什么很难知道; 再说它为什么非得是字符串"ABCDE"
呢? 这可不一定.
下面的例子中, 我们先是权且把它当作字符串, 但随着指针的移动, 字符串也在变化.
然后, 有分别把它分别用 Byte 指针(PByte) 和 Integer 指针(PInteger) 去读取它, 也会得
到相应的值.
完整示例如下:
Delphi 指针大全
- 15 -
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Button3: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.Button1Click(Sender: TObject);
var
str: string;
ps: PChar;
n: Cardinal;
begin
str := 'ABCDE';
ps := PChar(str);
n := Cardinal(ps);
//n := Cardinal(str); {这行可以代替上面两行}
ShowMessage(IntToStr(n)); {结果是 Windows 随机管理的}
Delphi 指针大全
- 16 -
ShowMessage(PChar(n)); {ABCDE}
ShowMessage(PChar(n+1)); {BCDE}
ShowMessage(PChar(n+2)); {CDE}
ShowMessage(PChar(n+3)); {DE}
ShowMessage(PChar(n+4)); {E}
end;
procedure TForm1.Button2Click(Sender: TObject);
var
str: string;
n: Cardinal;
pb: PByte;
begin
str := 'ABCDE';
n := Cardinal(str);
ShowMessage(IntToStr(n)); {4571140; 这是我这里的结果, 这是随机的}
pb := PByte(n);
ShowMessage(IntToStr(pb^)); {65}
pb := PByte(n+1);
ShowMessage(IntToStr(pb^)); {66}
end;
procedure TForm1.Button3Click(Sender: TObject);
var
str: string;
n: Cardinal;
pint: PInteger;
begin
str := 'ABCDE';
n := Cardinal(str);
ShowMessage(IntToStr(n)); {4571140; 这是我这里的结果, 这是随机的}
pint := PInteger(n);
ShowMessage(IntToStr(pint^)); {1145258561}
Delphi 指针大全
- 17 -
pint := PInteger(n+1);
ShowMessage(IntToStr(pint^)); {1162101570}
end;
end.
上面的第三个程序段的结果或许让你迷惑:
第一个结果, 应该和"ABCD" 有点关系才对啊, 怎么是: 1145258561 ?
第二个结果, 应该和"BCDE" 有点关系才对啊, 怎么是: 1162101570 ?
为什么呢? 这当然没错, 听我解释:
1145258561 转换成十六进制是: 44434241, 写得清楚一点是: $44 $43 $42 $41; 还记得
Intel 等当下流行的 CPU 安排数据是倒着的吗?
自己算算下一个, 用附件中的计算器即可.
4 Delphi 7 指针数据类型
指针类型
访问一个内存变量通常有两种方法：一种是通过名字访问，另一种是通过地址访问。指针是
通过地址访问变量的一种数据类型。
由于动态数据结构的变量必须在程序执行过程中动态生成，不能预先声明，所以无法预先给
这些变量起好名字，也无法通过名字进行访问，因此只能用指针先得到它的地址，然后间接
访问它们。
指针类型的定义如下：
Delphi 指针大全
- 18 -
type 指针类型标识符＝^类型标识符;
可以对指针变量赋值。对指针变量赋值实际上是将新的指针变量所指向的动态存储单元的首
地址赋给该指针，使该指针指向新的动态存储单元。给指针赋值必须类型相同或赋nil（空
值），给指针赋值后，指针原来所指的动态存储单元中还存有数据，只是它已无法被访问。
对指针可以应用比较运算符中的“＝”和“<>”进行比较。两个指针指向同一个动态变量，
则两个指针变量相等，否则即为不等。Delphi 的指针分为 "类型指针" 和 "无类型指针" 两
类.
Delphi 中的类型, 常用的也得有几百个, 我们可以给每种类型定义相应的类型指针.
其实 Delphi 已经为很多类型预定义了指针, 譬如数据类型:
Integer 有对应的 PInteger;
Char 有对应的 PChar;
string 有对应的 PString;
再譬如:
TPoint 有对应的 PPoint;
TColor 有对应的 PColor 等等.
另外, 指针也可以有指针, 譬如: PChar 是字符指针, PPChar 又是 PChar 的指针(这都是
Delphi 预定义的).
总结一下类型与指针的命名规则:
类型约定用 T 打头(Delphi 常规的数据类型除外, 譬如: String);
指针约定用 P 打头;
指针的指针约定用 PP 打头.
类型和指针是不可分的两个概念, 指针本身也是一种类型 - "指针类型".
先认识一下指针相关的操作符(@、^、Addr):
@ @变量获取变量指针
Addr Addr(变量)
^ 指针^ 获取指针指向的实际数据
var Pxxx: ^类型定义 Pxxx 某种类型的指针的变量
type Pxxx = ^类型定义 Pxxx 为某种类型的指针
Delphi 指针大全
- 19 -
如:定义整型指针
var
a :^Integer;
b :^Integer;
也可以用:
var
a Integer;
b Integer;
Object Pascal 认为每一个指针类型是相异的，为了把a 的值赋给b，你必须建立一个新的
类型，示例如下：
type
Pin = ^integer;
var
a,b :pin;
也可以直接写
var
a,b :^integer;
5 delphi 中的Pchar 指针
1．传统的Pascal 字符串
在Pascal 中，典型的字符串是一定长度的字符序列。每一字符串有一设定的长度（缺
省值为255），下面是一个例子：
Var
Address:String;
Code:String[50];
Delphi 指针大全
- 20 -
Address 是一长度为255 的字符串，Code 的最大长度为50。
传统的Pascal 字符串长度不能超过255。
可以用字符串连接操作"+"把字符串连接在一起：
Result:=String1+String2;
2． Delphi 中的长字符串
Delphi 除了支持传统的Pascal 短字符串还支持长字符串。长字符称为ANSIString。长
字符串动态分配内存，即用字符串时才分配字符串所需内存，所以其长度不受限制。在Delphi
中你如果用String1:String 作类型说明，则String1 既可能是短字符串也可能是长字符串，
这取决于编译器中$H 开关的设置。默认值为$H+，代表ANSI 长字符串，VCL 中的组件使
用ANSI 长字符串。长字符串以null 结束，这就说明长字符串与C 语言中的以null 结束的
字符串完全兼容。
可以通过SetLength 函数设置字符串的最大长度：
SetLength(String1,100);用TrimLeft,TrimRight 和Trim 函数分别来消除字符串开头，结尾和
首尾的空白区。
如果Delphi 中的Exended Syntax 已经设置（缺省值），以0 为起点的字符数组就和
指向字符的指针Pchar 完全兼容，因为以0 为起点的字符数组名即指向该字符数组首字符
的指针。可以将字符串直接付值给Pchar 指针。例如：
var
P: PChar;
begin
P := 'Hello world';
end;
这样P 就指向存储字符串'Hello world'并以null 结束的一块内存。
许多Windows 的应用程序接口API 函数要求用Pchar 类型作参数。Pchar 指针在使用
是首先用GetMem(var P: Pointer; Size: Integer)函数申请分配内存，程序结束时用
FreeMem(var P: Pointer[; Size: Integer])函数释放内存。例如：
Var WinDir,SysDirchar;
Begin
GetMem(WinDir,256);{为指针分配内存}
GetWindowsDirectory(WinDir,128);{将Windows 安装目录放至WinDir}
Delphi 指针大全
- 21 -
ShowMessage('Windows directory is'+WinDir);{显示结果}
End;
二：字符串转换
以上介绍了Delphi 中的四类字符串的定义和使用。由于各类函数对字符串参数类型要
求不一，这就需要进行字符串类型转换。
1．可以用StrPas 将以null 结束的字符串转换为Pascal 短字符串。StrpCopy 则完成相反
的转换。
2．因为长字符串以null 结束，所以可以用强制类型转换将长字符串转换成Pchar 类型。
用法是：Pchar(s),s 是一个长字符串。强制类型转换返回一个指向长字符串首字符的指针，
并且所指字符串以null 结束。例如：
Var
Caption,Message:string;
Caption:='Hello World!';
Mssage:='This is a test of long string';
MessageBox(0,Pchar(Message),Pchar(Caption),MB_OK);
小结：在使用Delphi 中的字符串时，要时刻清楚该字符串的类型，以免引起混淆。在
理解字符串时要把字符串与指针，内存分配联系起来，加强理解。

一、指针：指向一个内存地址的变量或参数。
　　
　　二、定义指针的方式如下：
　　
　　 P: Pointer; //定义了可以指向任何类型的指针，Pointer 为无类型指针；
　　 Q, R: ^TType; //定义了指向 TType 类型的两个指针，TType 可是是各种
　　 //基本类型或自己定义的各种类型，也可以如下定义：
　　 // type PType = ^TType;
　　 // var Q, R: PType;
　　
　　三、指针的使用：
　　 P: Pointer;
　　 Q, R: ^TType;
　　 A: TType;
　　
　　 Q:= R; //相同类型可以赋值
　　 P:= R; //可以把任何类型指针赋给无类型指针
　　 R:= P; //可以把无类型指针赋给有类型的指针
　　 Q:= @A; //加 @ 后，得到指向 A 的无类型指针，然后赋给 Q
　　 New(Q); //分配一个 TType 类型的空间，并把地址赋给 Q
　　 Dispose(Q); //释放 Q 所指向的空间
　　
　　四、指针的强制转换
　　 type TType = record ... end;
　　 PType = ^record ... end;
　　 var P: ^Integer;
　　 A: TType;
　　
　　 P:= @A; //加 @ 后，得到指向 A 的无类型指针，可以赋给 P
　　 PType(P).xxx //把 P 转换为 PType 类型，并引用记录中的值
　　 with PType(P)^ do begin ... end; // 注意 ^ 的使用，在上一行中，
　　 //不需要加 ^ (当然加也不错)，编译器可以自动识别，
　　 //而在这一行中，如不加 ^ ，会引起混淆。
　　 
　　 例子(把 string 的一个汉字当作 WideChar 并赋给一个整型变量)：
　　 A: Integer; S: string;
　　 A:= Word(PWideChar(@S[3])^);
　　 // @S[3] 得到 S[3] 的地址，然后把它当作指向 WideChar 的指针，
　　 // 用 ^ 取出一个汉字，再用 Word 强制转换，最后赋给一个整型变量。
　　 // 用 Word 转换的原因是 Word 的字节数和 WideChar 的字节数一样。
　　 // 在 Delphi 中，只要字节数一样的类型，都可以用强制转换，如字节
　　 // 不一样，就要用函数，这也是很合情理的。
　　 // 一定要这么写是让程序员知道自己在干什么，不至于出错，真正的实现
　　 // 是很简单的。
　　
　　五、函数类型
　　 
　　 函数类型也是指针，定义函数类型如下：
　　 type TFunc = function (X: Integer; S: string): Boolean;
　　 TProc = procedure;
　　 var F, G: function(A: Integer): string; 
　　 function Test(B: Integer): string;
　　 使用：
　　 F:= nil; //函数类型是指针
　　 F:= Test; //当函数类型在赋值号左面，右面是一个函数时当作是对函数
　　 //类型赋值，其它情况（如右面不是一个函数或函数类型在左
　　 //面或不是赋值号等），则认为是调用指向的函数，如下面一行
　　 S:= F(3); // 直接调用函数 Test(3);
　　 F:= @Test; // 取 Test 函数的地址并赋给 F，所以这样也正确
　　 @F:= @Test; //对函数类型取地址，得到的是所指向函数的地址，所以这样也正确
　　 @@F ... // 若想取函数类型的地址用两个 @，即 @@
　　 @F = @Test; // 判断 F 是否指向 Test，通过比较两个无类型指针得到
　　 Assigned(F) // 因为 F = nil 中左侧是调用 F，为了判断 F 是否不为空，
　　 // 用 Assigned
　　
　　六、方法指针
　　
　　 这里指的是类内的函数类型，是一对指针，一个指向函数地址，另一个存放
　　实例的引用。
　　 定义如下：
　　 TMethod = procedure (...) of object;
　　 使用：
　　 type TTest = class procedure T(...); end;
　　 var M: TMethod;
　　 M:= TTest.T;
　　 因为这里是一对指针，与其他指针的转换就有些问题，这里就不说了。
　　
　　七、集合、数组、动态数组、记录等
　　
　　 这些是特定的类型，Delphi 没有说他们是指针类型，这和 C 是有区别的
　　（随便什么都可以当指针用）。这一点请特别注意。
　　
　　 要想使他们和指针取得联系，一般要使用地址符 @，其实这也是很方便的，
　　如上面的汉字例子。还有前面讨论的 BlockRead 等例子都是这样。
　　
　　 S: array of record ... end;
　　
　　 SetLength(S, N);
　　 BlockRead(F, S[0], N);
　　 ~~~ 这里没有 @ 符的原因是它是 var 参数，不加 @ 就会把
　　 S[0] 的地址传进去。