Strings et PChars en Delphi

Date de publication : 09/08/2005

Par Adrien Reboisson (Site perso)
 

Lorsqu’un ami qui écrivait des DLL renvoyant des chaînes de caractères passées sous la forme de PChar commença à trouver normal que Delphi lève des violations d’accès où renvoie parfois des valeurs incohérentes (mettant cela sur le dos d’une gestion des chaînes approximatives de Windows, bien sûr !), j’ai finalement décidé de terminer ce petit document destiné à éclaircir les idées de certains Delphistes. Il n’a pas vocation d’expliquer en totalité les mécanismes utilisés pour gérer les différents types de chaînes que vous pourrez rencontrer en tant que programmeur Delphi, mais pourra vous éclaircir les idées et vous permettre d’éviter les erreurs courantes lors des conversions de chaînes Delphi en chaînes C.

I. Généralités

A. Les chaînes Delphi

procedure TForm1.Button1Click(Sender: TObject);
var
  S: string;
begin
  S := 'Hello, world'; //Hello, world affecté à S
  ShowMessage(S);
  S := 'Bonjour, monde'; //Changement de contenu..
  ShowMessage(S);
  S := S + '!'; //Concaténation...
  ShowMessage(S);
  [...]
end;

B. Les chaînes C

• A se positionner sur le premier caractère de la première chaîne (la case du tableau d’index 0),
• A se positionner sur le premier caractère de la seconde chaîne,
• Avancer dans la première chaîne jusqu’à atteindre le caractère #0, représentant la fin de la chaîne,
• Avancer dans la première chaîne, copier dans cette dernière la valeur situé à la position courante de la seconde chaîne, avancer dans les deux chaînes jusqu’à atteindre le caractère #0 de la seconde chaîne,
• Placer le caractère #0 en fin de la première chaîne pour mettre à jour sa fin.

C. Quelques précisions sur le type string

• Un compteur de longueur qui, comme son nom l’indique, contient le nombre de caractères utilisés par la chaîne. Cela explique donc que le #0 en fin de chaîne soit inutilisé. En découle deux conséquences :
• Une chaîne Delphi peut stocker n’importe quelles données, même binaires, puisque aucun caractère n’est utilisé dans la chaîne pour marquer sa fin,
• La taille maximum d’une chaîne Delphi correspond à la valeur maximum autorisée pour ce champ. Pour une variable de 32 bits, on a donc une taille maximum correspondante d’environ 4 gigaoctets.
• Un compteur de références utilisé pour gérer l’allocation mémoire. Puisque ce type peut contenir de gros volumes de données… autant les allouer de manière plus ou moins « intelligente ». Ainsi, lorsqu’une chaîne est déclarée, son pointeur est assigné à nil, ce qui représente la chaîne vide (‘’). Lorsqu’un texte est affecté à la chaîne la première fois, il y a copie et mise à 1 du compteur de références. Maintenant, si cette variable est assignée à une autre variable de type string, au lieu de faire une copie inutile (à ce stade, les deux variables pointant le même texte !)… le pointeur de la seconde chaîne va pointer la première chaîne. Aucune copie n’est faite, mais le compteur de références est incrémenté et passe à 2. Si la seconde chaîne est maintenant modifiée, elle ne peut plus pointer sur la première : on effectue la copie (5) obligatoire et on décrémente le compteur de référence. Enfin, le compteur de références est également décrémenté lorsque la variable sors de la portée dans laquelle elle a été déclarée (par exemple, lorsque la chaîne est déclarée comme variable temporaire dans une fonction et que cette dernière est quittée). Lorsque ce compteur atteint zéro, la mémoire qui lui est attribuée est libéré. Ainsi donc fonctionne cette gestion automatique dans laquelle vous n’avez encore une fois (heureusement) aucun besoin d’intervenir.

procedure TForm1.Button2Click(Sender: TObject);
var
  NiceString: string;
begin
  NiceString := 'Hello, world !';
  NiceString[2] := #0;
  ShowMessage(NiceString);
end;

    DrawText(Canvas.Handle, PChar(Msg), Length(Msg)+1, TextRect,
      DT_EXPANDTABS or DT_CALCRECT or DT_WORDBREAK or
      DrawTextBiDiModeFlagsReadingOnly);

D. Duplication de chaînes

var 
  A, B: AnsiString; 
begin 
  A := 'Hello World';
  B :=A;   //A and B désignent la même zone mémoire
  UniqueString(B);  //Crée une nouvelle copie de "Hello World" à une autre nouvelle adresse

II. Le type PAnsiChar et l'opérateur PChar()

A. Présentation et règles essentielles

procedure TForm1.Button1Click(Sender: TObject);
var
  S: string;
  P: PChar;
begin
  S := 'Hello !';
  MessageDlg(IntToStr(Longword(S)), mtWarning, [mbOK], 0);
  P := PChar(S);
  MessageDlg(IntToStr(Longword(P)), mtWarning, [mbOK], 0);
end;

• Il faut dimensionner la chaîne AnsiString de manière explicite grâce à SetLength() en fonction de la taille maximale que devrait renvoyer la fonction utilisant la chaîne. La mémoire est allouée pour contenir le nombre de caractères passé en paramètre à SetLength, le nombre de caractères est mis à jour tout comme le délimiteur (#0) de fin de chaîne (et c'est une des rares fois où SetLength() a besoin d'être utilisé sur un type AnsiString !)
• On obtient ensuite de manière naturelle un pointeur utilisable avec PChar() que l'on passe à la fonction qui en a besoin.
• La nouvelle taille de la chaîne n'étant pas remise à jour après l'appel, il faut de nouveau utiliser SetLength() sur la chaîne pour la redimensionner.

var
  S: string;
begin
  SetLength(S, MAX_SIZE);  // avant de transtyper en PChar, vérifiez que la chaîne n'est pas vide
  SetLength(S, GetModuleFilename(0, PChar(S), Length(S)));
end;

Function GetSomething: Pchar;
var
  S: string;
begin
  S := Function1;
  Result := Pchar(S);
end;

B. A propos de l'allocation mémoire

• Allouer manuellement ou automatiquement une zone dans la mémoire,
• Assigner son adresse au pointeur,
• Accéder aux " cases " mémoires de la zone pour lire ou écrire des caractères (Delphi propose des fonctions à cet usage),
• Libérer la zone (et ne plus utiliser le pointeur, car il ne désigne plus rien de valide).

var
  P: PChar;
begin
  P := 'Hello !';

C. DLL et PAnsiChars

procedure ShowNiceMessage(AString: PChar); stdcall;
begin
  MessageDlg(AString, mtWarning, [mbOK], 0);
end;

procedure TForm1.Button7Click(Sender: TObject);
var
  S: string;
begin
  S := 'Hello world !';
  ShowNiceMessage(PChar(S));
end;

III. Allocation et utilisation de chaînes C

A. Allocation sur la pile

function TForm1.GetFileName: string;
var
  LFileName: array [0..1023] of char;
begin
  GetModuleFileName(0, LFileName, SizeOf(LFileName));
  Result := LFileName;
end;

B. Allocation sur le tas

function TForm1.GetFileName2: string;
const
  cstMaxChars = 4096; //taille du tampon
var
  LFileName: PChar; //pointeur sur le tampon
Begin
  //1 allocation de la zone via GetMemory
  LFileName := GetMemory(cstMaxChars * SizeOf(Char));
  //2 Appel de la fonction
  GetModuleFileName(0, LFileName, cstMaxChars);
  //3 Conversion implicite et automatique en AnsiString
  Result := LFileName;
  //4 Libération de la mémoire
  FreeMemory(LFileName);
end;

C. Manipulation de PAnsiChars

procedure foo(ADest: Pchar; ACount: Integer);
begin
  StrPLCopy(ADest, 'Use the source, Luke', ACount);
  //Place dans ADest une chaîne quelconque. 
end;

function TForm1.CountChars(AString: PChar; AChar: Char): Integer;
var
  I: Integer;
begin
  Result := 0;
  if AString = nil then Exit; //Pointeur nul: on sort.
  I := 0;
  while not (AString[I] = #0) do //Jusqu'à la fin
  begin
    if AString[I] = AChar then
      Inc(Result);
    Inc(I);
  end;
end;

function TForm1.StringLen(AString: PChar): Integer;
begin
  Result := 0;
  if AString = nil then Exit;
  while true do
  begin
    if (AString + Result)^ = #0 then
      Exit
    else
      Inc(Result);
  end;
end;

procedure TForm1.Button4Click(Sender: TObject);
var
  P: PChar;
begin
  1. P := 'Hello';
  2. P[1] := 'd';
  3. StrPCopy(P, 'World);
end;

D. Allocations inter-modules

procedure GetAppDirectory(ADir: PChar; ACount: Integer); stdcall;
var
  LDir: string;
begin
  LDir := { Fonction renvoyant un String }
  StrPLCopy(ADir, LDir, ACount);
end;

procedure FooBar;
var 
  Lbuffer: array [0..512] of char; //On suppose que le dossier ne peut dépasser 512 caractères
begin
  GetAppDirectory(LBuffer, SizeOf(LBuffer)); //Ou directement 512 à la place du SizeOf().
  //On peut utiliser LBuffer comme un string ou un tableau...
  if not (LBuffer = '') then
    with TFileStream.Create(IncludeTrailingBackSlash(LBuffer) + 'test.dat', fmCreate) do
  //... code
end;

IV. Conclusion