来自：http://blog.csdn.net/farrellcn/article/details/9096787
------------------------------------------------------------------------------
很多书籍中说函数参数如果是String类型的，如果在函数内部不改变参数的值，使用 const 修饰符会加快程序的执行速度，至于如何加快的？有的人说是因为 const 函数保证了参数字符串不会被复制。以前也没有对这个问题深入研究，但是在不修改函数参数的时候，总是习惯加上 const 修饰符，前几天在csdn论坛上解答某个人的问题是，发现程序产生的结果和预期的不一样，检查了一遍代码，发现没有什么问题，按理不应该出现错误。于是跟踪调试，发现是用 const 修饰的一个 String 类型的函数参数在该函数中被意外地更改了其内容，这很奇怪啊，因为在函数内部没有修改其值的地方，况且用 const 修饰的参数，如果存在修改其内容的语句，编译都过不去，更何谈执行了。于是，就跟踪代码，查找原因，这一跟踪，发现了一个问题：
跟踪测试代码如下：
var SS: String; procedure test1(const s: String); begin try SS := ‘你好‘; ShowMessage(s); except end; end; procedure TfrmMain.btnTestClick(Sender: TObject); begin SS := ‘Hello‘; test1(SS); end;
var SS: String; procedure test1(const s: String); begin try SS := ‘你好‘; ShowMessage(s); except end; end; procedure TfrmMain.btnTestClick(Sender: TObject); begin SS := ‘Hello‘; test1(SS); end;
代码很简单，按照程序逻辑，ShowMessage(s) 的结果应该显示 "Hello"，有些人看了前面的描述，可能会觉得，好像应显示 "你好"，这些都不对，显示的是乱码！呵呵，吓一跳吧！好了，下面我就来解释下，为什么会显示乱码：
首先，看看加了 const 修饰符到底会有什么不同：
procedure test1(const s: String); begin try SS := ‘你好‘; ShowMessage(s); except end; end;
procedure test1(const s: String); begin try SS := ‘你好‘; ShowMessage(s); except end; end;
在Test1函数的begin处断开，然后看看汇编代码到底干了什么：
上图是在 begin 处加了断点后，程序运行到这里的汇编代码，其中，红色方框中的，就是在 begin 到第一句语句 try 处执行的代码。
再看看不加 const 会怎么样：
procedure test1(s: String); begin try SS := ‘你好‘; ShowMessage(s); except end; end;
procedure test1(s: String); begin try SS := ‘你好‘; ShowMessage(s); except end; end;
在 Test1 函数的 begin 处断开，然后看看汇编代码到底干了什么：
上图就是不加 const 修饰符，程序运行到 begin 处的汇编代码，红色方框中，就是 begin 到第一句语句 try 处执行的代码。
对比上面的两处代码，发现不加 const 修饰符，多了一段代码
mov [ebp-$04],eax mov eax,[ebp-$04] call @LStrAddRef xor eax,eax push ebp push $0045214b push dword ptr fs:[eax] mov fs:[eax],esp
mov [ebp-$04],eax mov eax,[ebp-$04] call @LStrAddRef xor eax,eax push ebp push $0045214b push dword ptr fs:[eax] mov fs:[eax],esp
下面一句一句来解释
mov [ebp-$04],eax
将 eax 寄存器中的内容复制到 ebp-$04 所指向的内存中。
因为eax是函数的第一个参数，也就是字符串参数 s 的内容。在 delphi 中字符串是一个指针，指向在堆中开辟的字符串内容的地址，因此这句的意思就是将字符串参数指针的内容放入 ebp-$04 所指向的位置，因为在程序一开始有
push ebp
mov ebp,esp
esp是栈指针，总是指向栈顶，因此，ebp所指向的内容就是这个函数用到的栈的栈顶的位置。紧接着：
push ecx
push ebx
push esi
push edi
四个压栈指令，导致在栈中预留出了4个位置。ebp-$04 就是栈中第一个预留位置。因此，
mov [ebp-$04],eax
就是将函数参数的第一个参数放入到栈中。
mov eax,[ebp-$04]
call @LStrAddRef
这两句完成了一个功能，就是调用@LStrAddRef函数，在system单元翻看@LStrAddRef函数完成的功能
function _LStrAddRef(var str): Pointer; {$IFDEF PUREPASCAL} var P: PStrRec; begin P := Pointer(Integer(str) - sizeof(StrRec)); if P <> nil then if P.refcnt >= 0 then InterlockedIncrement(P.refcnt); Result := Pointer(str); end; {$ELSE}
function _LStrAddRef(var str): Pointer; {$IFDEF PUREPASCAL} var P: PStrRec; begin P := Pointer(Integer(str) - sizeof(StrRec)); if P <> nil then if P.refcnt >= 0 then InterlockedIncrement(P.refcnt); Result := Pointer(str); end; {$ELSE}
其中用到了PStrRec，其结构如下
type
PStrRec = ^StrRec;
StrRec = packed record
refCnt: Longint;
length: Longint;
end;
简单解释下：
先解释下 StrRec 结构，在delphi中，String类型的数据，实际上就是一个 StrRec 结构的数据再加上字符串本身的内容，其中 refCnt 表示字符串被引用的次数，length 是字符串的长度。refCnt 的作用是：当其值为0的时候，表示这个字符串没有任何一个地方使用了，这时，delphi 会在适当的时候释放这个字符串所占用的内存。
再说下 LStrAddRef 函数完成的功能，首先得到指向传入字符串所对应的StrRec结构体的指针，然后判断这个结构体是否为空，如果不为空，再判断这个结构体中的 refCnt 是否大于等于0，如果是，就将其加一，然后返回指向这个字符串本身的指针。
好了
mov eax,[ebp-$04]
call @LStrAddRef
所完成的功能就是让字符串 ebp-$04 中保存的字符串的引用计数加一，而 ebp-$04 中保存的，恰好是函数第一个参数传入的内容，也就是说，这两句完成的是让传入的字符串参数的引用计数加一
xor eax,eax
push ebp
push $0045214b
push dword ptr fs:[eax]
mov fs:[eax],esp
这几句是与delphi实现的异常处理有关，在这里不做说明了，和本文讨论的内容关系不大。
问题描述到这里，我们可以看到，使用 const 修饰和不使用 const 修饰的差别：不使用 const 会让函数参数多了一个增加引用计数的过程。好了，记住这个结论。实际上，问题就出在这里
首先分析下程序的流程：
procedure TfrmMain.btnTestClick(Sender: TObject); begin SS := ‘Hello‘; test1(SS); end;
procedure TfrmMain.btnTestClick(Sender: TObject); begin SS := ‘Hello‘; test1(SS); end;
为全局的字符串变量 SS 赋值为"Hello"，然后以 SS 为参数调用Test1函数。
procedure test1(const s: String); begin try SS := ‘你好‘; ShowMessage(s); except end; end;
procedure test1(const s: String); begin try SS := ‘你好‘; ShowMessage(s); except end; end;
在 Test1 函数中，修改 SS 的内容，并显示参数S的内容
整个流程并不复杂，下面，在汇编下，看看是怎么完成的：
在 SS := "Hello" 处下断点，跟踪。
为 SS 赋值的语句为上面红框框出来的部分，调用了@LStrAsg函数完成了赋值功能，下面是@LStrAsg函数
//两个参数，第一个参数为目标字符串，也就是要赋值的字符串 //第二个参数是原始字符串，也就是要赋值的原始值 procedure _LStrAsg(var dest; const source); {$IFDEF PUREPASCAL} var S, D: Pointer; P: PStrRec; Temp: Longint; begin S := Pointer(source); //得到指向原始字符串的地址 if S <> nil then begin P := PStrRec(Integer(S) - sizeof(StrRec)); //得到指向原始字符串的 StrRec 结构指针 //当原始字符串为常量时，其引用计数为-1 //这种时候，会引起字符串的复制操作 if P.refCnt < 0 then // make copy of string literal begin Temp := P.length; //获得原始字符串的长度 S := _NewAnsiString(Temp); //开辟一块大小为原始字符串长度的内存 Move(Pointer(source)^, S^, Temp); //将原始字符串的内容复制到新开辟的内存中 P := PStrRec(Integer(S) - sizeof(StrRec)); //将 P 设置为指向新字符串的 StrRec 结构指针 end; InterlockedIncrement(P.refCnt); //增加 P 所指向的字符串的引用计数 end; //设置目标字符串 D := Pointer(dest); //保存指向目标字符串原来的指针到 D Pointer(dest) := S; //设置目标字符串为 S 指向的字符串 //如果原来的目标不为空，则将其引用计数减一 //减一之后，如果引用计数为零，则释放这个字符串占的内存 if D <> nil then begin P := PStrRec(Integer(D) - sizeof(StrRec)); if P.refCnt > 0 then if InterlockedDecrement(P.refCnt) = 0 then FreeMem(P); end; end; {$ELSE}
//两个参数，第一个参数为目标字符串，也就是要赋值的字符串 //第二个参数是原始字符串，也就是要赋值的原始值 procedure _LStrAsg(var dest; const source); {$IFDEF PUREPASCAL} var S, D: Pointer; P: PStrRec; Temp: Longint; begin S := Pointer(source); //得到指向原始字符串的地址 if S <> nil then begin P := PStrRec(Integer(S) - sizeof(StrRec)); //得到指向原始字符串的 StrRec 结构指针 //当原始字符串为常量时，其引用计数为-1 //这种时候，会引起字符串的复制操作 if P.refCnt < 0 then // make copy of string literal begin Temp := P.length; //获得原始字符串的长度 S := _NewAnsiString(Temp); //开辟一块大小为原始字符串长度的内存 Move(Pointer(source)^, S^, Temp); //将原始字符串的内容复制到新开辟的内存中 P := PStrRec(Integer(S) - sizeof(StrRec)); //将 P 设置为指向新字符串的 StrRec 结构指针 end; InterlockedIncrement(P.refCnt); //增加 P 所指向的字符串的引用计数 end; //设置目标字符串 D := Pointer(dest); //保存指向目标字符串原来的指针到 D Pointer(dest) := S; //设置目标字符串为 S 指向的字符串 //如果原来的目标不为空，则将其引用计数减一 //减一之后，如果引用计数为零，则释放这个字符串占的内存 if D <> nil then begin P := PStrRec(Integer(D) - sizeof(StrRec)); if P.refCnt > 0 then if InterlockedDecrement(P.refCnt) = 0 then FreeMem(P); end; end; {$ELSE}
从这个函数中可以看到，为 SS 赋值为 ‘Hello‘ 的过程是：因为 ‘Hello‘ 为常量，其引用计数为-1，因此，先开辟了一块内存，然后将 ‘Hello‘ 这个字符串的内容复制到新内存中，因为 SS 在赋值前是空(上图中，下面红框框出来的地方就是SS的原始值，可以看到，其内容为0)，因此没有执行减少引用计数的部分代码。
顺便看看为新字符串开辟内存空间的_NewAnsiString函数吧
//传入字符串的长度，返回新分配的内存 function _NewAnsiString(length: Longint): Pointer; {$IFDEF PUREPASCAL} var P: PStrRec; begin Result := nil; if length <= 0 then Exit; //开辟一块内存，其大小是 Length 加 StrRec 结构的长度加1 //之所以要加1，是为了在字符串的最后加入一个#0，以便和PChar类型兼容 //后面的((length + 1) and 1) 是为了地址对齐而加入的，暂时不用理会 GetMem(P, length + sizeof(StrRec) + 1 + ((length + 1) and 1)); //返回新开辟的内存，注意，这里不是返回其首地址， //而是跳过了 StrRec 结构 Result := Pointer(Integer(P) + sizeof(StrRec)); P.length := length; //设置新字符串长度为传入的长度 P.refcnt := 1; //设置引用计数为1 //为字符串的最后面加入#0 PWideChar(Result)[length div 2] := #0; // length guaranteed >= 2 end; {$ELSE}
//传入字符串的长度，返回新分配的内存 function _NewAnsiString(length: Longint): Pointer; {$IFDEF PUREPASCAL} var P: PStrRec; begin Result := nil; if length <= 0 then Exit; //开辟一块内存，其大小是 Length 加 StrRec 结构的长度加1 //之所以要加1，是为了在字符串的最后加入一个#0，以便和PChar类型兼容 //后面的((length + 1) and 1) 是为了地址对齐而加入的，暂时不用理会 GetMem(P, length + sizeof(StrRec) + 1 + ((length + 1) and 1)); //返回新开辟的内存，注意，这里不是返回其首地址， //而是跳过了 StrRec 结构 Result := Pointer(Integer(P) + sizeof(StrRec)); P.length := length; //设置新字符串长度为传入的长度 P.refcnt := 1; //设置引用计数为1 //为字符串的最后面加入#0 PWideChar(Result)[length div 2] := #0; // length guaranteed >= 2 end; {$ELSE}
这个函数没什么好说的，看看加入的注释就知道怎么回事了。这里可以看到，所有新字符串的引用计数都为1
赋值结束后，SS 的内容由 0 变成了 $00B23E4C，这可以从下面的图中看到。
好了，给 SS 赋值为 ‘Hello‘ 就到这里
下面看看调用 Test1 的部分
调用前
在图中可以看到，为 test1 传递参数就是 SS 的内容，即 $00B23E4C，这个地址指向的就是字符串‘Hello‘
并且，从图中可以看到，调用函数 test1 之前，字符串 ‘Hello‘ 的引用计数是 1，长度是 5
调用后
调用后，从图中可以看到，全局变量 SS 中保存的依然是 $00B23E4C
从上图中看 $00B23E4C 地址中的字符串，其引用计数依然是 1。
这里需要注意的是：已经有两个地方引用到了这个地址，一个是 SS，另一个就是用 const 修饰的常量参数。
从这里可以看出，用 const 修饰的字符串参数，不会引起字符串的引用计数的变化，这点很重要，问题其实就出在这里。
当在函数中改变了全局变量的值，会发生什么事情呢？我们看看下图
从图中可以看到，SS 的内容已经变为 $00B23E60 了，为什么会这样呢？我们还是来看看赋值函数 @LStrAsg 都做了些什么吧。
结合着 图4 和 图5 给出的信息我们看到，调用@LStrAsg前，SS 的内容不为空，其内容是 $00B23E4C，而这个地址就是字符串 ‘Hello‘ 所在的内存，并且，其引用计数为 1。因此，函数 @LStrAsg 的第一个参数不为空，也就是说，目标字符串不为空。因为这次赋值依然是将一个常量赋值给 SS 因此，依然会分配一块新的内存，并将新字符串的内容复制到这块内存中，再将新内存的地址给 SS 。在向下执行的时候，问题来了，因为原始的 SS 不为空，因此进入了下面这段代码：
//如果原来的目标不为空，则将其引用计数减一 //减一之后，如果引用计数为零，则释放这个字符串占的内存 if D <> nil then begin P := PStrRec(Integer(D) - sizeof(StrRec)); if P.refCnt > 0 then if InterlockedDecrement(P.refCnt) = 0 then FreeMem(P); end;
//如果原来的目标不为空，则将其引用计数减一 //减一之后，如果引用计数为零，则释放这个字符串占的内存 if D <> nil then begin P := PStrRec(Integer(D) - sizeof(StrRec)); if P.refCnt > 0 then if InterlockedDecrement(P.refCnt) = 0 then FreeMem(P); end;
取出原始字符串(也就是 ‘Hello‘ 字符串)，的 StrRec 结构中的内容，因为其引用计数为 1 ，所以执行
if InterlockedDecrement(P.refCnt) = 0 then
减 1 后刚好是 0，因此就执行了
FreeMem(P);
看到了吧，‘Hello‘ 这个字符串被释放了。
从下面的图中，也可以看到，确实被释放了
也就是说，当程序执行完了
SS := ‘你好‘
之后，原来的 ‘Hello‘ 被释放了。
但是，这个函数的参数还是一个指向原来 ‘Hello‘ 的地址，因此，这参数就变成了一个无效的指针，因此，随后的
ShowMessage(s);
也就成了显示一个无效字符串的内容的语句，所以出来的是乱码。
这就是为什么当使用 const 修饰的字符串参数，为什么会出这个问题的原因。
而不使用 const 修饰的函数，因为在最开始的部分，调用了 @LStrAddRef ，导致字符串 ‘Hello‘ 的引用计数变成了 2，因此，当执行
if InterlockedDecrement(P.refCnt) = 0 then
时，其引用计数虽然被减1，但是因为原始值是二，因此不会执行
FreeMem(P);
好了，这个问题就说到这里。
上面写的东西有点多，导致看起来比较乱，简单来说：
使用 const 修饰的字符串参数，delphi在编译的时候，不会为其加入更改引用计数的代码，导致了当改变了参数原始的字符串的时候，参数所指向的字符串被意外释放，致使参数变成了无意义的字符串指针，因此会显示出乱码；而不采用 const 修饰的参数，则因为改变了引用计数，所以就不会出问题。
也许有的人会认为，既然是全局参数，在函数内部直接就可以访问到，干吗还要用参数传进来啊？
其实，这不是什么问题，一般情况下，也不会发生这种情况，但问题是，代码不是一个人的代码，A写的代码，可能B要修改，C也要修改，那么改来改去，就有可能会出现上面的情况。
全局变量这种比较敏感的使用方式往往遭人诟病，但是，类中的成员变量，一样会涉及到这个问题。只要是能被函数直接访问到的生存期自管理变量，当其作为参数传入到函数中时，如果使用 const 修饰，都会出现这个问题。
还有一种情况，就是多线程，如果使用了const 修饰，当某个生存期自管理变量被当做参数传入到线程的某个函数中时，另外一个线程更改了这个生存期自管理变量的值，这时候，前一个线程中的那个参数就会出现非法访问。这个问题更加隐蔽了。
这种问题比较隐蔽，而且错误也出的莫名其妙，因为按照正常逻辑，是不会出问题的。
这种问题出在Delphi中的生存期自管理的变量当中，如果是 variant 或者接口类型的变量，也采用 const 修饰，那估计也会出现这个问题。
另外，还有一种情况也和引用计数有关，模型如下:
procedure abc(Value: String); var p: PChar; begin p := PChar(Value); p^ := ‘a‘; end; var s, s1, s2, s3, s4: String; begin s3 := ‘1234‘; s4 := ‘5678‘; s := s3 + s4; //这里产生了内存复制 s1 := s; //这里没有产生内存复制，仅仅是引用计数加1 abc(s1); end;
procedure abc(Value: String); var p: PChar; begin p := PChar(Value); p^ := ‘a‘; end; var s, s1, s2, s3, s4: String; begin s3 := ‘1234‘; s4 := ‘5678‘; s := s3 + s4; //这里产生了内存复制 s1 := s; //这里没有产生内存复制，仅仅是引用计数加1 abc(s1); end;
上面的代码，应该是函数 abc 内部的代码不会影响到调用函数的部分外面，也就是调用之后，s和s1应该是不变的，但是在调用完 abc 之后，s 和 s1 的内容也被改变了！！
也就是说，从s到s1再到参数Value，Delphi始终没有进行copy-on-write，仅仅是改变了引用计数，操作Value也就是操作 s 和 s1 指向的字符串。但是从代码的形式上看，s1 := s;的本意就是把s的内容给s1，而从函数abc的声明上看，是传值调用，应该是把s1的值(也就是字符串本身)复制一份给Value，从逻辑上，操作Value不应该对s1或者s有影响，但是，实际上确实有影响。
这个错误应该是很隐蔽的！
如果把上面的abc函数换成下面的函数
procedure abc(Value: String); var p: PChar; begin p := @Value[1]; //在这里，引起了内存字符串复制操作，也就是 Value 被分离出来 p^ := ‘a‘; end;
procedure abc(Value: String); var p: PChar; begin p := @Value[1]; //在这里，引起了内存字符串复制操作，也就是 Value 被分离出来 p^ := ‘a‘; end;
那么s1和s的内容都不会被改变了。
这应该说是Delphi在进行copy-on-write时候没有考虑到的遗漏呢，还是应该说本来就是这个样子呢？
（以上的程序仅仅是临时写的测试程序，基本没有什么应用的价值，算是为了测试而测试吧）
Delphi 中 函数参数中的 const 修饰符的本质以及注意事项
原文：http://www.cnblogs.com/del88/p/5413691.html