Delphi strings (O que, quando e como) - Otimizaes

As verses mais recentes do Delphi oferecem pelo menos 4 tipos de strings. Cada uma delas com
caractersticas e comportamentos prprios, tendo sua aplicabilidade destinada a situaes diferentes.
Esse artigo est dividido em duas partes. A primeira ir descrever esses quatro tipos de strings e suas
caractersticas; a segunda etapa composta por anlises de situaes comuns na programao e que
constituem oportunidades para um otimizaes.

Breve Histrico
ShortString
Este um tipo de string oriundo das primeiras verses do Delphi e herdado do Turbo Pascal, que possuia
este como o nico tipo de string.
A menos que uma alocao manual seja feita, o tipo ShortString reside na stack e no na heap e, do ponto
de vista de alocao de memria, tem o mesmo comportameto que os tipos bsicos alocados
estaticamente (integer, boolean, char, recors, enum, ...).
Quando o tipo ShortString utilizado o Delphi pr-aloca um bloco de 256 bytes e utiliza o primeiro byte
(AStr[0]) para armazenar o tamanho 'utilizado'.
var
AStr: ShortString;

Voc tambm pode especificar um tamanho mximo para as strings, mas esse valor no pode passar 255.
var
s: string[50];
e: string[256]; // error

PChar
A limitao de 255 bytes para string representa um fator crtico para aplicaes do mundo real.
No Delphi 1 foi introduzido o tipo PChar que era um tipo semelhante ao "char *" da linguagem C.
Entretanto, devido a segmentao da memria do Windows ser de 16-bits, o tipo PChar estava limitado a
65535 bytes (64 KB).
Diferentemente do tipo ShortString, PChar no possui um "campo" destinado a armazenar o tamanho da
string, mas possui um terminador "null".

Long String (AnsiString)

No Delphi 2 foi introduzido o tipo AnsiString com a finalidade de prover uma forma eficiente e rpida de
trabalhar com strings grandes (32-bits). Agora era possvel manipular strings com at 2 GB.
Comparando a estrutura do tipo AnsiString podemos dizer que ele uma "forma hbrida" dos tipos PChar e
ShortString. Uma porque ele utiliza um terminador "null" para indicar o final da string (igual ao PChar) e,
segundo, porque adota um campo para armazenar o tamanho da string e o primeiro caracter inicia na
posio 1.
var
s: AnsiString;

Observe o mapa de memria da varivel s, alm do campo "Lenght" esse tipo de sring mantm um outro
campo, "RefCount". Resumidamente, esse campo incrementado sempre que a varivel referencida.
Isso permite ao Delphi gerenciar o tempo de vida da string, liberando a memria quando a string no mais
utilizada.
WideString
WideString foi o ltimo tipo de string adicionado famla Delphi, mais precisamente, introduzido na verso
6. No entanto, somente a partir da verso 2009 que se tornou o tipo padro de string.
A finalidade do tipo WideString o suporte a caracteres Unicode e a diferena reside no fato de que cada
caracter WideString representado por 2 bytes e no 1, como em AnsiString.
var
s: WideString;

O tipo String
No Delphi, o tipo string no nada mais do que um alias para ShortString, PChar, AnsiString ou
WideString, dependendo da verso do Delphi que for utilizado.
Por exemplo, no Delphi 7 o tipo string equivalente a AnsiString; j no Delphi 2009 e, mas recentemente,
no Delphi 2010, string equivalente a WideString.
O uso do tipo string deve ser aplicado com um pouco de cautela, principalmente se retro-compatibilidade
ou portabilidade for uma das necessidades do cdigo fonte produzido.
Tomamos por exemplo o lanamento do Delphi 2009, que trouxe aos usurios o desafio da migrao do
cdigo fonte de manipulao de strings para o formato wide.

Semntica e comportamento
Para o correto uso das string necessrio entender sua semntica e seu comportamento.
a) Exemplo 1
Lembre-se, o tipo ShortString pre-aloca 256 bytes e operaes de atribuio resultaro em cpia do
contedo fonte.
var
s: ShortString;
b: ShortString;
begin
...
s := 'Teste';
b := s;
// O contedo de 's' copiado para 'b'
s[1] := 'X' // A varivel 'b' ainda contm 'Teste'

b) Exemplo 2
O tipo PChar est frequentemente associado a alocao dinnimica e atribuies somente copiam o
ponteiro do destino, no o contedo.
var
s: PChar;
b: PChar;
begin
...

s := 'Teste';
b := s;
// A varivel 'b' aponta para 's'
s[0] := 'X' // Tanto 's' quanto 'b' contm 'Xeste'

c) Exemplo 3
Tanto o tipo AnsiString quanto WideString so semelhantes ao tipo PChar quando uma atribuio direta
feita, ou seja, somente copiado o ponteiro do destino. Alm disso, AnsiString e WideString possuem um
campo RefCount(usado para saber quando a string no mais utilizada) que, na atribuio direta,
incrementado..
Observe o exemplo baixo.
var
s: AnsiString;
b: AnsiString;
begin
...
s := 'Teste';
b := s;
// Ambas apontam para a mesma rea de memria e
//o campo "RefCount' incrementado.

d) Exemplo 4
Vamos tomar o mesmo exemplo anterior, mas com uma linha a mais de cdigo.
var
s: AnsiString;
b: AnsiString;
begin
...
s := 'Teste';
b := s;
// b recebe o ponteiro de 's'e o RefCount incrementado.
s[1] := 'X'; // Faz uma cpia de 'b' com o primeiro byte modificado e
//decrementa o RefCount de 'b'.

Vamos detalhar o trabalho realizado pelo Delphi em cada uma das linhas ilustrando as estruturas em
memria.
Step 1)
s := 'Teste';

feito a alocao de memria para armazena a string. O campo "Lenght" setado para 5 (que o nmero
de caracteres da string) e o campo "RefCount" setado para 1.
A varivel 's' passa a apontar para o incio da string.
Step 2)
b := s;

Observe que a linha de cdigo acima simplesmente copiou o ponteiro da varivel 's' para a varivel 'b' e
incrementou o campo 'RefCount', ou seja, abas as variveis esto apontando para a mesma rea de
memria.
Step 3)
s[1] := 'X';

Aqui a alterao de um simples byte resultou e vrias instrues.

Pelo fato do "RefCount" ser superior a 1, ou seja, por haver mais do que uma referncia, foi realizada a
alocao de uma nova string; copiado o contedo da string original; setado 1 para o "RefCount"; alterado o
primeiro byte para 'X'; atribudo o ponteiro da nova string para a varivel 's'.
Por ltimo, o 'RefCount' da string original decrementado.

Otimizaes no uso de strings

Uso de parmetros do tipo const
A plavrava reservada "const" um modificador usado para definir algo como esttico, que no muda. E
quando associadas com parmetros do tipo string, h um incremento no desempenho que pode ser
perceptvel, dependendo da intensidade de uso.
Vamos tomar como base uma funo simples.
function GetStrSize(s: string): Integer;
begin
Result := Length(s);
end;;

Aqui o parmetro "s" ir incondicionalmente incrementar o campo "RefCount" da string a qual ele est
referenciando antes de iniciar a execuo da primeira linha de cdigo da funo.
Pode parecer um tarefa simples e pouco honerosa para o sistema, mas totalmente desnecessria
porque o parmetro somente utilizado para leitura e nunca para escrita.
Uma cdigo fonte mais eficiente, nesse caso, facilmente obtido apenas especificando o parmetro como
"constante".
function GetStrSize2(const s: string): Integer;
begin
Result := Length(s);
end;

A boa notcia que as otimizaes implementada nos compiladores mais recentes j detectam esse tipo
de situao e geram um cdigo final mais eficiente.
Evitando retorno do tipo string
Quando voc for codificar uma funo na qual pretendido retornar uma string modificada da que
passada por parmetro, aconselhado que seja feito atravs do prprio parmetro. A menos, claro, que
voc necessite do valor original.
function AddChar(const s: string): string;
begin
Result := s + '*';
end;

O exemplo acima, como pode ser notado, apenas acrescenta um caracter no final da string passa por
parmetro.
J a funo abaixo faz a mesma coisa, mas retorna a nova string atravs do prprio parmetro.
procedure AddChar2(var s: string);
begin
s := s + '*';
end;

Tanto o modificador "const" da primeira funo quanto o modificador "var" da segunda funo fazem com
que no seja necessrio o incremento do "RefCount". Entretanto a segunda funo mais eficiente porque
no requer que a string do parmetro seja duplicada, porque a concatenao feita diretamente na string
original.
Postergando condicionais de comparao de string
Uma situao bem corriqueira no dia-a-dia, principalmente quando se est trabalhando com algum tipo de
parser, codificar testes condicionais com mais do que uma validao onde h comparaes string.
var
lFailed: Boolean;
lText: string;
begin
...
if (lText = '') and (not lFailed) then
...
end;

No exemplo acima o primeiro teste do "if" faz uma comparao entre string e o segundo uma
comparao que envolve uma varivel booleana.
Sabendo que uma comparao entre string uma tarefa "onerosa" para o processador, o mais sensato
alterarmos a ordem das condies de forma que os testes mais simples sejam atendidos primeiros. Isso
evita, nesse nosso exemplo, uma comparao de string desnecessria quando a varivel lFailed forFalse.
Esse um tipo de Boas Prticas de Programao pode ser extentido para casos de forma geral que
exigam um processamento extra.
Redundncia de chamadas
Por mais otimizado que a biblioteca do Delphi esteja, a chamada a uma funo de manipulao de string
sempre impem alguma penalidade se comparado com operaes simples, e evitar chamadas
desnecessrias ou redundantes certamente um cuidado bem vindo.
O cdigo abaixo um pequeno trecho retirado de uma mtodo de validao de email. Podemos notar o
uso repetido e redundante da funo "Pos".
function IsValidEmail(const EMail: string): Boolean;
begin
...
if (Pos('@', EMail) <> 0) and (Pos('.', EMail) <> 0) then
begin
if (Pos('@', EMail) = 1) or (Pos('@', EMail) = Length(EMail)) or
(Pos('.', EMail) = 1) or (Pos('.', EMail) = Length(EMail)) or (Pos(' ', EMail) = 0) then
Result := False
...

Esse um exemplo simples que utiliza funes especficas para tratamento de strings, mas o problema
no exclusivo e estende-se para qualquer outro tipo de redundncia.
function IsValidEmail(const EMail: string): Boolean;
var
lPos_Dot: Integer;
lPos_Arroba: Integer;
begin
...
lPos_Dot := Pos('.', EMail);
lPos_Arroba := Pos('@', EMail);
if (lPos_Arroba <> 0) and (lPos_Dot <> 0) then
begin
if (lPos_Arroba = 1) or (lPos_Arroba = Length(EMail)) or
(lPos_Dot = 1) or (lPos_Dot = Length(EMail)) or (Pos(' ', EMail) = 0) then
Result := False
...

A simples adio de duas variveis locais evitou quatro chamadas desnecessrias funo "Pos".

Verificando se uma string est vazia

Existem muitas maneiras de conferir se uma string ou no vazia, mas voc sabe qual delas a mais
eficiente?
Abaixo eu apresento trs das formas mais freqentemente empregadas.
var
lMyStr: string;
begin
lMyStr := Caption;
if lMyStr = '' then
lMyStr := 'Maneira mais eficiente';
if Length(lMyStr) = 0 then
lMyStr := 'Maneira menos eficiente';
if lMyStr[1] = '' then
lMyStr := 'Forma desaconselhada';

Para entender melhor a verdadeira razo do primeiro if conter a forma mais adequada de verificar se um
string est ou no vazia, vou postar o cdigo assemble gerado pelo compilador. Mesmo voc no estando
familiarizado com a linguagem assembly, tenho certeza que ser fcil o entendimento.
O cdigo gerado pelo compilador apresentado logo abaixo da linha do cdigo fonte respectiva e cada um
dos if acima est destacado em uma cor diferente.
fuStrTest.pas.127: if lMyStr = '' then
07992023 837DFC00
cmp dword ptr [ebp-$04],$00
07992027 750D
jnz $07992036
fuStrTest.pas.128: lMyStr := 'Maneira mais eficiente';
07992029 8D45FC
lea eax,[ebp-$04]
0799202C BADC209907
mov edx,$079920dc
07992031 E842F0FFFF
call $07991078
fuStrTest.pas.129: if Length(lMyStr) = 0 then
07992036 8D45FC
lea eax,[ebp-$04]
07992039 E822F0FFFF
call $07991060
0799203E E83DF0FFFF
call $07991080
07992043 85C0
test eax,eax
07992045 750D
jnz $07992054
fuStrTest.pas.130: lMyStr := 'Maneira menos eficiente';
07992047 8D45FC
lea eax,[ebp-$04]
0799204A BA18219907
mov edx,$07992118
0799204F E824F0FFFF
call $07991078
fuStrTest.pas.131: if lMyStr[1] = '' then
07992054 8B45FC
mov eax,[ebp-$04]
07992057 66833800
cmp word ptr [eax],$00
0799205B 750D
jnz $0799206a
fuStrTest.pas.132: lMyStr := 'Forma desaconselhada';
0799205D 8D45FC
lea eax,[ebp-$04]
07992060 BA54219907
mov edx,$07992154
07992065 E80EF0FFFF
call $07991078

Somente observando o nmero de instrues necessrias para cada uma das trs situaes j suficiente
para comprovar que o primeiro if o mais eficiente. Entretanto o segundo if, que utiliza a funo Length,
merece alguns comentrios.
Observe que h duas instrues call (call $07991060 e call $07991080) que so, na verdade, chamadas
para as funes EnsureUnicodeString e UStrLen, respectivamente. Essas funes so compostas por
diversas instrues e, do ponto de vista de micro otimizaes, impem uma penalidade de performance
bastante grande.
Mesmo no tento realizados testes estatsticos mais precisos, posso afirmar que um simples if lMyStr = ''
then incontveis vezes mais rpido que o uso da funo Length.
Novamente ressaltando que isso do ponto de vista de micro otimizaes e para a maioria dos
desenvolvedores o ganho de desempenho seria imperceptvel.