La programmation Win32 en Virtual Pascal avec OWL

• Tableau de caractères (Array of Char) et pointeur pChar sont équivalents;
• Constante tableau de caractères ('Bonjour') et pointeur pChar sont équivalents;
• Les paramètres de type chaîne AZT sont passés aux procédures et fonctions par adresse.

Pour assigner une valeur à une chaîne AZT, on utilise la fonction StrCopy :

StrCopy(Chaine,'Bonjour');

Physiquement, la chaîne 'Bonjour' est copiée dans la chaîne AZT. Il y a donc bien deux exemplaires de la chaîne à l'arrivée !

Il peut être tentant, par analogie avec les Strings, d'assigner une valeur à une chaîne AZT comme ceci :

Chaine := 'Bonjour';   (* Erreur de syntaxe ! *)

Mais le compilateur rejettera cette syntaxe ! Il faut employer StrCopy.

Pour initialiser une chaîne vide, c'est tout simple : il suffit qu'elle commence par le zéro terminal !

Chaine[0] := #0;

De la même manière, on peut tronquer une chaîne en y insérant un zéro terminal :

Chaine[5] := #0;

Pour déterminer la longueur d'une chaîne AZT, on utilise la fonction StrLen :

Longueur := StrLen(Chaine);

Cette fonction compte les caractères de la chaîne jusqu'au zéro terminal.

StrCopy sert également à copier une chaîne 1 dans une chaîne 2 :

StrCopy(Chaine2,Chaine1);

Retenez bien l'ordre des paramètres : destination avant source !
Après exécution de cette instruction, il y a bien deux exemplaires de la chaîne de départ.

Par contre (pour vous torturer un peu les méninges), combien y a-t-il d'exemplaires de la chaîne 1 après exécution de l'instruction suivante ?

Chaine2 := Chaine1;

Réponse : un seul exemplaire, bien sûr ! Cette instruction ne fait que copier l'adresse de la chaîne 1 dans la chaîne 2 et donc les deux pointeurs pointent sur la même chaîne en mémoire.

Pour comparer deux chaînes AZT, vous avez le choix entre StrComp (qui tient compte des majuscules et minuscules) et StrIComp (qui n'en tient pas compte).
La valeur retournée par ces deux fonctions peut être positive, négative ou nulle :

Var Chaine1 : Array [0..40] of Char;
    Chaine2 : Array [0..30] of Char;
    Resultat : Integer;

Resultat := StrIComp(Chaine1,Chaine2);
if Resultat > 0
   then
     WriteLn('Chaine1 > Chaine2')
   else
     if Resultat < 0
        then
          WriteLn('Chaine1 < Chaine2')
        else
          WriteLn('Chaine1 = Chaine2');

Pour déterminer la position d'une chaîne dans une autre, on utilise StrPos.
Alors que la fonction Pos (pour les chaînes à attribut de longueur du Pascal) renvoie un indice, la fonction StrPos retourne un pointeur.

Un petit exemple :

Program POSITION;

Uses WinCRT,Strings;

Var Chaine : Array [0..40] of Char;
    Extrait : Array [0..15] of Char;
    Adresse : pChar;

Begin
  StrCopy(Chaine,'Salut la compagnie !');
  StrCopy(Extrait,'compagnie');
  Adresse := StrPos(Chaine,Extrait);
  WriteLn(Adresse);
  WriteLn('Indice de l''extrait : ',Adresse - Chaine);
End.

Ne tenez pas compte pour l'instant de la déclaration de l'unité WinCRT : elle fera l'objet du chapitre suivant. Compilez et exécutez ce petit programme; vous obtiendrez quelque chose comme ceci :



Tout cela mérite quelques explications.
Tout d'abord, la variable Adresse retournée par l'instruction

Adresse := StrPos(Chaine,Extrait);

porte bien son nom puisqu'elle contient l'adresse de la chaîne 'compagnie' dans la chaîne 'Salut la compagnie !'. Pour bien le prouver, l'instruction

WriteLn(Adresse);

affiche à l'écran : compagnie !, c'est-à-dire à partir de l'adresse Adresse jusqu'au zéro terminal.

Enfin, notre dernière instruction soustrait l'adresse de la chaîne de départ à l'adresse trouvée par StrPos pour donner l'indice de l'extrait. Non, il n'y a pas d'erreur : l'indice du 1er caractère est 0 et non 1 comme pour les chaînes à attribut de longueur : l'indice affiché est bien 9 et non 10.

Pour concaténer deux chaînes AZT, il existe l'instruction StrCat :

Var Chaine1 : Array [0..40] of Char;
    Chaine2 : Array [0..30] of Char;

StrCat(Chaine1,Chaine2);

L'instruction ci-dessus ajoute le contenu de Chaine2 à Chaine1.

Que se passe-t-il si le contenu des deux chaînes mis bout à bout dépasse la taille limite de Chaine1 ? Un beau plantage à courte échéance !

Retenez bien ceci : la plupart des routines de l'unité Strings n'effectuent aucune vérification de débordement !

Il incombe donc au programmeur de prendre ses précautions. Dans le cas présent, une de ces précautions peut être de choisir la variante StrLCat :

Var Chaine1 : Array [0..40] of Char;
    Chaine2 : Array [0..30] of Char;

StrLCat(Chaine1,Chaine2,SizeOf(Chaine1) - 1);

Traduite en langage courant, cette instruction signifie : "ajouter à Chaine1 le contenu de Chaine2 en veillant à ne pas dépasser la taille maximale de Chaine1".

Il est possible de convertir une chaîne AZT en String à l'aide de la fonction StrPas :

Program CONVERS1;

Uses Strings;

Var s : String [7];
    c : Array [0..7] of Char;

Begin
  StrCopy(c,'Bonjour');
  s := StrPas(c);
End.

La conversion inverse se fait avec la fonction StrPCopy :

Program CONVERS2;

Uses Strings;

Var s : String [7];
    c : Array [0..7] of Char;

Begin
  s := 'Bonjour';
  StrPCopy(c,s);
End.

L'allocation dynamique de chaînes AZT permet de tirer parti de la quantité de mémoire disponible dans le tas global de Windows, bien supérieure à la capacité d'un segment de données ou d'un segment de pile.
La fonction StrNew permet d'allouer une chaîne AZT :

Var p : pChar;

p := StrNew('Allocation dans le tas');

Cette instruction alloue l'espace nécessaire dans le tas, y copie la chaîne et retourne l'adresse du bloc alloué. Il y a donc deux copies de la chaîne : une dans le segment de données et l'autre dans le tas.

Le principe de l'allocation dans le tas est économe en mémoire car n'est alloué que l'espace nécessaire pour stocker une copie de chaîne avec le zéro terminal.
Illustration :

Var Chaine : Array [0..255] of Char;
    p : pChar;

Begin
  StrCopy(Chaine,'Allocation dans le segment de donn'#233'es');
  p := StrNew(Chaine);
  WriteLn(p);
  StrDispose(p);
End.

StrNew alloue dans le tas l'espace nécessaire pour stocker non pas 255 caractères (+ le zéro terminal) mais seulement 36 caractères (+ le zéro terminal) !
Notez que si la longueur de la chaîne est nulle ou s'il n'y a plus assez de mémoire dans le tas pour allouer la chaîne, StrNew renverra Nil.
Remarquez que p peut parfaitement être utilisé avec l'instruction WriteLn pour afficher la chaîne allouée dans le tas.

La fonction qui permet de libérer dans le tas l'espace alloué à une chaîne AZT est StrDispose.