Routines standard et entrées-sorties
Remonter à Guide du langage Delphi - Index
Ces rubriques décrivent les entrées/sorties (E/S) de fichier et de texte et décrit les routines de la bibliothèque standard. La plupart des procédures et fonctions listées ici sont définies dans les unités System et SysInit qui sont implicitement utilisées avec chaque application. Les autres sont construites dans le compilateur mais sont traitées comme si elles étaient dans l'unité System.
Certaines routines standard sont définies dans des unités comme SysUtils qui doivent être listées dans une clause uses pour les rendre utilisables dans les programmes. Par contre, vous ne pouvez pas spécifier System dans une clause uses ni modifier l'unité System ou tenter de la reconstruire explicitement.
Remarque : Pour les nouveaux programmes, vous voudrez probablement utiliser les fonctions et les classes de gestion des fichiers dans les unités System.Classes et System.SysUtils. System.Classes.TStream et ses classes descendantes sont actuellement recommandées pour la gestion de fichiers générale dans Delphi (pour les routines associées, voir Flux, lecteurs et concepteurs). Pour la gestion des fichiers texte, TStreamReader et TStreamWriter sont recommandés par rapport à Write et Writeln. Catégories de l'API - Index contient les listes des routines et des classes associées.
Remarque : BlockRead et BlockWrite ont des paramètres non typés, ce qui peut être la source d'une corruption de la mémoire. Les deux méthodes dépendent du paramétrage de la taille d'enregistrement, effectué implicitement par un appel précédent de Reset ou Rewrite. L'utilisation des flux donne un niveau supérieur de flexibilité et de fonctionnalités au programmeur.
Sommaire
Entrées et sorties de fichiers
Le tableau suivant liste les routines d'entrées et de sorties.
Procédures et fonctions d'entrées et de sorties
Procédure ou fonction | Description |
---|---|
Ouvre un fichier texte existant en ajout. | |
Assigne le nom d'un fichier externe à une variable fichier. | |
Lit un ou plusieurs enregistrements d'un fichier non typé. | |
Ecrit un ou plusieurs enregistrements dans un fichier non typé. | |
Change le répertoire en cours. | |
Ferme un fichier ouvert. | |
Renvoie le statut fin-de-fichier d'un fichier. | |
Renvoie le statut fin-de-ligne d'un fichier texte. | |
Efface un fichier externe. | |
Renvoie la position en cours au sein d'un fichier typé ou non typé. | |
Renvoie la taille en cours d'un fichier ; non utilisé pour les fichiers texte. | |
Vide le tampon d'un fichier texte de sortie. | |
Renvoie le répertoire en cours d'un lecteur spécifié. | |
Renvoie une valeur entière indiquant le statut de la dernière fonction d'E/S effectuée. | |
Crée un sous-répertoire. | |
Lit une ou plusieurs valeurs d'un fichier dans une ou plusieurs variables. | |
Fait la même chose que Read puis passe au début de la ligne suivante du fichier texte. | |
Renomme un fichier externe. | |
Ouvre un fichier existant. | |
Crée et ouvre un nouveau fichier. | |
Retire un sous-répertoire vide. | |
Déplace la position en cours d'un fichier typé ou non typé sur un composant spécifié. Non utilisé avec les fichiers texte. | |
Renvoie le statut fin-de-fichier d'un fichier texte. | |
Renvoie le statut fin-de-ligne d'un fichier texte. | |
Assigne un tampon d'E/S à un fichier texte. | |
Tronque un fichier typé ou non typé à la position en cours dans le fichier. | |
Ecrit une ou plusieurs valeurs dans un fichier. | |
Fait la même chose que Write, puis écrit un marqueur fin-de-ligne dans le fichier texte. |
Une variable fichier est une variable dont le type est un type fichier. Il y a trois catégories de fichiers : typés, texte et non typés. La syntaxe de la déclaration des types de fichier est donnée dans Types de fichier. Notez que les types de fichier sont seulement disponibles sur la plate-forme Win32.
Avant de pouvoir utiliser une variable fichier, il faut l'associer à un fichier externe en appelant la procédure AssignFile. Un fichier externe est typiquement un fichier disque nommé, mais ce peut aussi être un périphérique comme le clavier ou l'écran. Le fichier externe stocke des informations écrites dans le fichier ou fournit les informations lues dans le fichier.
Une fois établie l'association avec un fichier externe, la variable fichier doit être ouverte pour la préparer à des entrées ou des sorties. Un fichier existant peut être ouvert via la procédure Reset, et un nouveau fichier peut être créé et ouvert via la procédure Rewrite. Les fichiers texte ouverts avec Reset sont en lecture seule et les fichiers texte ouverts avec Rewrite et Append sont en écriture seule. Les fichiers typés et les fichiers non typés permettent toujours la lecture et l'écriture, qu'ils soient ouverts avec Reset ou Rewrite.
Tout fichier est une suite linéaire de composants, chacun ayant le type de composant (ou d'enregistrement) du fichier. Ces composants sont numérotés à partir de zéro.
L'accès aux fichiers se fait normalement de manière séquentielle. C'est-à-dire que si un composant est lu en utilisant la procédure standard Read ou écrit en utilisant la procédure standard Write, la position en cours dans le fichier passe au composant suivant dans l'ordre numérique. Il est possible d'accéder directement aux fichiers typés et non typés en utilisant la procédure standard Seek, qui déplace la position en cours dans le fichier sur un composant spécifié. Les fonctions standard FilePos et FileSize peuvent être utilisées pour déterminer la position en cours dans le fichier et la taille du fichier en cours.
Quand un programme termine le traitement d'un fichier, le fichier doit être fermé en utilisant la procédure standard CloseFile. Une fois un fichier fermé, son fichier externe associé est mis à jour. La variable fichier peut alors être associée à un autre fichier externe.
Par défaut, tous les appels des procédures et fonctions standard d'entrées / sorties sont automatiquement vérifiés pour détecter les erreurs et, si une erreur s'est produite, une exception est déclenchée (ou le programme s'arrête si la gestion des exceptions n'est pas activée). Cette vérification automatique peut être activée ou désactivée en utilisant les directives de compilation {$I+} et {$I-}. Quand la vérification des E/S est désactivée (c'est-à-dire quand une procédure ou une fonction est compilée à l'état {$I-}, une erreur d'E/S ne provoque pas le déclenchement d'une exception ; pour vérifier le résultat d'une opération d'E/S, vous devez alors appeler la fonction standard IOResult.
Vous devez appeler la fonction IOResult pour effacer une erreur, même si l'erreur ne vous concerne pas. Si vous n'effacez pas l'erreur et si {$I-} est l'état en cours, la prochaine fonction d'E/S appelée échoue avec l'erreur IOResult en souffrance.
Fichiers texte
Cette section décrit brièvement les entrées/sorties utilisant des variables fichier ayant le type standard Text.
A l'ouverture d'un fichier texte, le fichier externe est interprété d'une manière particulière : il est supposé représenter une suite de caractères formatés en lignes. Chaque ligne est terminée par un marqueur fin-de-ligne (un caractère retour-chariot éventuellement suivi d'un caractère de passage à la ligne). Le type Text est distinct du type Char.
Les fichiers texte utilisent des variantes de Read et Write qui permettent de lire et d'écrire des valeurs qui ne sont pas de type Char. De telles valeurs sont automatiquement converties vers ou depuis une représentation caractère. Par exemple, Read(F, I), où I est une variable de type Integer, lit une suite de chiffres, l'interprète comme un entier décimal et la stocke dans I.
Il existe deux variables fichier texte standard, System.Input et System.Output. La variable fichier standard System.Inputest un fichier en lecture seule associé à l'entrée standard du système d'exploitation (typiquement, le clavier). La variable fichier standard System.Output est un fichier en écriture seule associé à la sortie standard du système d'exploitation (typiquement, l'écran). Avant le début de l'exécution d'une application, les variables System.Input et System.Output sont automatiquement ouvertes, comme si les instructions suivantes étaient exécutées :
AssignFile(Input, ); Reset(Input); AssignFile(Output, ); Rewrite(Output);
Remarque : Pour les applications Win32, les variables d'E/S orientées texte ne sont disponibles que dans les applications console, c'est-à-dire les applications compilées avec l'option Générer une application console cochée sur la page Liaison de la boîte de dialogue Options de projet ou avec l'option de ligne de commande -cc du compilateur. Dans une application GUI (non console), toute tentative de lecture ou d'écriture en utilisant System.Input ou System.Output produit une erreur d'E/S.
Certaines des routines standard d'E/S fonctionnent avec des fichiers texte qui n'ont pas nécessairement besoin d'avoir une variable fichier spécifiée explicitement comme paramètre. Si le paramètre fichier est omis, les variables System.Input ou System.Output sont utilisées par défaut, selon que la fonction ou la procédure est orientée entrée ou sortie. Par exemple, Read(X) correspond à Read(Input, X) et Write(X) correspond à Write(Output, X).
Si vous spécifiez un fichier lors de l'appel d'une des routines d'entrée ou de sortie fonctionnant sur les fichiers texte, le fichier doit être associé à un fichier externe en utilisant AssignFile et ouvert en utilisant Reset, Rewrite ou Append. Une erreur se produit si vous passez un fichier ayant été ouvert avec Reset à une procédure ou une fonction orientée sortie. Une erreur se produit aussi si vous passez un fichier ayant été ouvert avec Rewrite ou Append à une procédure ou une fonction orientée entrée.
Fichiers non typés
Les fichiers non typés sont des canaux d'E/S de bas niveau utilisés essentiellement pour l'accès direct aux fichiers disque, quel que soit le type et la structuration. Un fichier non typé est déclaré avec le mot file et rien de plus. Par exemple :
var DataFile: file;
Pour les fichiers non typés, les procédures Reset et Rewrite autorisent un paramètre supplémentaire afin de spécifier la taille d'enregistrement utilisée dans les transferts de données. Pour des raisons historiques, la taille d'enregistrement par défaut est de 128 octets. Une taille d'enregistrement de 1 est la seule valeur qui reflète correctement la taille exacte de tout fichier. En effet, il ne peut pas y avoir d'enregistrement partiel quand la taille d'enregistrement est de 1.
A l'exception de Read et Write, toutes les procédures et fonctions standard des fichiers typés sont aussi autorisées sur les fichiers non typés. Au lieu de Read et Write, deux procédures, BlockRead et BlockWrite, sont utilisées pour des transferts de données rapides.
Pilotes de périphérique de fichier texte
Vous pouvez définir vos propres pilotes de périphérique de fichier texte pour vos programmes. Un pilote de périphérique de fichier texte est un ensemble de quatre fonctions qui implémentent complètement une interface entre le système de fichiers Delphi et un périphérique.
Les quatre fonctions qui définissent chaque pilote de périphérique sont Open, InOut, Flush et Close. L'en-tête de chaque fonction est de la forme :
function DeviceFunc(var F: TTextRec): Integer;
où DeviceFunc est le nom de la fonction (c'est-à-dire Open, InOut, Flush ou Close). La valeur de retour d'une fonction d'interface de périphérique devient la valeur renvoyée par IOResult. Si la valeur de retour est zéro, l'opération a réussi.
Pour associer les fonctions d'interface de périphérique à un fichier spécifique, vous devez écrire une procédure Assign personnalisée. La procédure Assign doit assigner les adresses des quatre fonctions d'interface de périphérique aux quatre pointeurs de fonction dans la variable fichier texte. De plus, elle doit stocker la constante magique fmClosed dans le champ Mode, stocker la taille du tampon du fichier texte dans BufSize, stocker un pointeur sur le tampon du fichier texte dans BufPtr et effacer la chaîne Name.
En supposant, par exemple, que les quatre fonctions d'interface de périphérique s'appellent DevOpen, DevInOut, DevFlush et DevClose, la procédure Assign ressemble à ceci :
procedure AssignDev(var F: Text); begin with TTextRec(F) do begin Mode := fmClosed; BufSize := SizeOf(Buffer); BufPtr := @Buffer; OpenFunc := @DevOpen; InOutFunc := @DevInOut; FlushFunc := @DevFlush; CloseFunc := @DevClose; Name[0] := #0; end; end;
Le champ CodePage doit être défini sur DefaultSystemCodePage pour les fonctions d'interface de périphérique à utiliser par la RTL. Ces fonctions d'interface de périphérique doivent effectuer la gestion de tout caractère spécial; si nécessaire.
Les fonctions d'interface de périphérique peuvent utiliser le champ UserData de l'enregistrement du fichier pour stocker des informations privées. Ce champ n'est jamais modifié par le système de fichiers du produit.
La fonction Open
La fonction Open est appelée par les procédures standard Reset, Rewrite et Append pour ouvrir un fichier texte associé à un périphérique. En entrée, le champ Mode contient fmInput, fmOutput ou fmInOut pour indiquer si la fonction Open a été appelée par Reset, Rewrite ou Append.
La fonction Open prépare le fichier en entrée ou en sortie, selon la valeur de Mode. Si Mode spécifie fmInOut (indiquant que Open a été appelée par Append), sa valeur doit être changée en fmOutput avant la fin de Open.
Open est toujours appelée avant toutes les autres fonctions d'interface de périphérique. Pour cette raison, AssignDev initialise seulement le champ OpenFunc, laissant l'initialisation des vecteurs restants à Open. En se basant sur Mode, Open peut ensuite installer des pointeurs sur les fonctions orientées entrée ou sur les fonctions orientées sortie. Cela évite aux fonctions InOut, Flush et à la procédure CloseFile d'avoir à déterminer le mode en cours.
La fonction InOut
La fonction InOut est appelée par les routines standard Read, Readln, Write, Writeln, Eof, Eoln, SeekEof, SeekEoln et CloseFile dès qu'une entrée ou une sortie sur le périphérique est nécessaire.
Si Mode a la valeur fmInput, la fonction InOut lit jusqu'à BufSize caractères dans BufPtr^ et renvoie le nombre de caractères lus dans BufEnd. De plus, elle stocke zéro dans BufPos. Si la fonction InOut renvoie zéro dans BufEnd en tant que résultat d'une requête d'entrée,Eof prend la valeur True pour le fichier.
Si Mode a la valeur fmOutput, la fonction InOut écrit BufPos caractères de BufPtr^ et renvoie zéro dans BufPos.
La fonction Flush
La fonction Flush est appelée à la fin de chaque Read, Readln, Write et Writeln. Elle peut éventuellement vider le tampon du fichier texte.
Si Mode a la valeur fmInput, la fonction Flush peut stocker zéro dans BufPos et dans BufEnd afin de vider les caractères restants (non lus) du tampon. Cette fonctionnalité est rarement utilisée.
Si Mode a la valeur fmOutput, la fonction Flush peut écrire le contenu du tampon exactement comme la fonction InOut, ce qui garantit que le texte écrit dans le périphérique apparaît bien immédiatement sur le périphérique. Si Flush ne fait rien, le texte n'apparaît pas sur le périphérique tant que le tampon n'est pas plein ou que le fichier n'est pas fermé.
La fonction Close
La fonction Close est appelée par la procédure standard CloseFile afin de fermer un fichier texte associé à un périphérique. Les procédures Reset, Rewrite et Append appellent aussi Close si le fichier qu'elles ouvrent est déjà ouvert. Si Mode a la valeur fmOutput, le système de fichiers appelle la fonction InOut avant d'appeler Close, afin de garantir que tous les caractères ont bien été écrits sur le périphérique.
Gestion des chaînes terminées par null
La syntaxe étendue du langage Delphi permet aux procédures standard Read, Readln, Str et Val d'être appliquées à des tableaux de caractères de base zéro, et aux procédures standard Write, Writeln, Val, AssignFile et Rename d'être appliquées à des tableaux de caractères de base zéro et à des pointeurs de caractères.
Fonctions de gestion de chaînes terminées par null
Les fonctions suivantes sont fournies pour la gestion des chaînes terminées par null.
Fonctions de gestion de chaînes terminées par null
Fonction | Description |
---|---|
Alloue sur le tas un tampon de caractères d'une taille donnée. | |
Renvoie la taille d'un tampon de caractères alloué en utilisant StrAlloc ou StrNew. | |
Concatène deux chaînes. | |
Compare deux chaînes. | |
Copie une chaîne. | |
Libère un tampon de caractères alloué en utilisant StrAlloc ou StrNew. | |
Copie une chaîne et renvoie un pointeur sur la fin de la chaîne. | |
Renvoie un pointeur sur la fin d'une chaîne. | |
Formate une ou plusieurs valeurs dans une chaîne. | |
Compare deux chaînes sans sensibilité à la casse. | |
Concatène deux chaînes avec une longueur maximale donnée pour la chaîne résultante. | |
Compare deux chaînes pour une longueur maximale donnée. | |
Copie une chaîne jusqu'à une longueur maximale donnée. | |
Renvoie la longueur d'une chaîne. | |
Formate une ou plusieurs valeurs dans une chaîne avec une longueur maximale donnée. | |
Compare deux chaînes pour une longueur maximale donnée sans sensibilité à la casse. | |
Convertit une chaîne en minuscules. | |
Déplace un bloc de caractères d'une chaîne dans une autre. | |
Alloue une chaîne sur le tas. | |
Copie une chaîne Pascal dans une chaîne terminée par null. | |
Copie une chaîne Pascal dans une chaîne terminée par null avec une longueur maximale donnée. | |
Renvoie un pointeur sur la première occurrence d'une sous-chaîne donnée au sein d'une chaîne. | |
Renvoie un pointeur sur la dernière occurrence d'un caractère donné au sein d'une chaîne. | |
Renvoie un pointeur sur la première occurrence d'un caractère donné au sein d'une chaîne. | |
Convertit une chaîne en majuscules. |
Les fonctions standard de gestion de chaînes ont un équivalent multi-octet qui implémente aussi le tri des caractères en tenant compte des paramètres régionaux. Le nom des fonctions multi-octets commence par Ansi-. Ainsi, la version multi-octet de StrPos est AnsiStrPos. La prise en charge des caractères multi-octets dépend du système d'exploitation et est basé sur les paramètres régionaux en cours.
Chaînes de caractères étendus
L'unité System propose trois fonctions, WideCharToString, WideCharLenToString et StringToWideChar, que vous pouvez utiliser pour convertir des chaînes de caractères étendus terminées par null en chaînes longues de caractères simples ou double-octets.
L'affectation effectuera aussi la conversion entre les chaînes. Par exemple, les deux lignes suivantes sont valides :
MyAnsiString := MyWideString; MyWideString := MyAnsiString;
Autres routines standard
Le tableau suivant liste les fonctions et les procédures des bibliothèques de produits, le plus souvent utilisées. Il ne constitue pas un inventaire exhaustif de toutes les routines standard.
Autres routines standard
Procédure ou fonction | Description |
---|---|
Renvoie un pointeur sur un objet spécifié. | |
Alloue un bloc mémoire et initialise chaque octet à zéro. | |
Calcule l'arc-tangente du nombre donné. | |
Déclenche une exception si l'expression passée n'est pas évaluée à true. | |
Teste à nil (non assigné) un pointeur ou une variable procédurale. | |
Génère un bip standard. | |
Force le contrôle à quitter une instruction for, while ou repeat. | |
Renvoie la position du caractère contenant un octet spécifié dans une chaîne. | |
Renvoie le caractère correspondant à une valeur entière spécifiée. | |
Ferme un fichier. | |
Effectue une comparaison binaire de deux images mémoire. | |
Compare des chaînes, avec sensibilité à la casse. | |
Compare des chaînes par valeur ordinale, sans sensibilité à la casse. | |
Renvoie le contrôle sur l'itération suivante des instructions for, while et repeat. | |
Renvoie une sous-chaîne d'une chaîne ou un segment d'un tableau dynamique. | |
Calcule le cosinus d'un angle. | |
Convertit une variable monétaire en chaîne. | |
Renvoie la date en cours. | |
Convertit une variable de type TDateTime en chaîne. | |
Convertit une variable de type TDateTime en chaîne. | |
Décrémente une variable ordinale ou une variable pointeur typé. | |
Libère la mémoire d'une variable allouée dynamiquement. | |
Renvoie l'adresse à laquelle l'exception en cours a été déclenchée. | |
Quitte la procédure en cours. | |
Calcule l'exponentielle de X. | |
Remplit des octets contigus avec une valeur spécifiée. | |
Initialise une variable allouée dynamiquement. | |
Convertit une valeur à virgule flottante en chaîne. | |
Convertit une valeur à virgule flottante en chaîne, en utilisant le format spécifié. | |
Renvoie une sortie formatée en utilisant une chaîne de format ressourcée. | |
Assemble une chaîne formatée à partir d'une série de tableaux. | |
Assemble une chaîne à partir d'une chaîne de format et d'une série de tableaux. | |
Formate une valeur date-heure. | |
Formate une valeur à virgule flottante. | |
Libère la mémoire allouée. | |
Alloue de la mémoire dynamique et un pointeur sur l'adresse du bloc. | |
Initie la terminaison anormale d'un programme. | |
Renvoie l'octet de poids fort d'une expression, sous la forme d'une valeur non signée. | |
Renvoie la plus grande valeur de l'étendue d'un type, d'un tableau ou d'une chaîne. | |
Incrémente une variable ordinale ou une variable pointeur typé. | |
Initialise une variable allouée dynamiquement. | |
Insère une sous-chaîne à une position spécifiée, dans une chaîne. | |
Renvoie la partie entière d'un nombre réel. | |
Convertit un entier en chaîne. | |
Renvoie la longueur d'une chaîne ou d'un tableau. | |
Renvoie l'octet de poids faible d'une expression, sous la forme d'une valeur non signée. | |
Renvoie la plus petite valeur de l'étendue d'un type, d'un tableau ou d'une chaîne. | |
Convertit une chaîne ASCII en minuscules. | |
Renvoie la plus grande valeur signée d'un tableau d'entiers. | |
Renvoie la plus grande valeur signée d'un tableau. | |
Renvoie la plus petite valeur signée d'un tableau d'entiers. | |
Renvoie la plus petite valeur signée d'un tableau. | |
Crée une variable mémoire allouée dynamiquement et la référence avec un pointeur spécifié. | |
Renvoie la date et l'heure en cours. | |
Renvoie la valeur entière ordinale d'une expression de type ordinal. | |
Renvoie l'index du premier caractère mono-octet d'une sous-chaîne spécifiée, dans une chaîne. | |
Renvoie le prédécesseur d'une valeur ordinale. | |
Convertit une valeur en pointeur. | |
Génère des nombres aléatoires au sein d'une étendue spécifiée. | |
Réalloue une mémoire allouable dynamiquement. | |
Renvoie la valeur d'un réel arrondie au nombre entier le plus proche. | |
Définit la longueur dynamique d'un tableau ou d'une variable chaîne. | |
Définit le contenu et la longueur de la chaîne donnée. | |
Affiche un message d'exception avec son adresse. | |
Renvoie le sinus d'un angle en radians. | |
Renvoie le nombre d'octets occupés par une variable ou un type. | |
Renvoie une sous-section d'un tableau. | |
Renvoie le carré d'un nombre. | |
Renvoie la racine carrée d'un nombre. | |
Convertit un nombre entier ou un nombre réel en chaîne. | |
Convertit une chaîne en valeur monétaire. | |
Convertit une chaîne au format date (TDateTime). | |
Convertit une chaîne au format TDateTime. | |
Convertit une chaîne en valeur à virgule flottante. | |
Convertit une chaîne en entier. | |
Convertit une chaîne au format heure (TDateTime). | |
Renvoie une chaîne ASCII en majuscules. | |
Renvoie le successeur d'une valeur ordinale. | |
Renvoie la somme des éléments d'un tableau. | |
Renvoie l'heure en cours. | |
Convertit une variable de type TDateTime en chaîne. | |
Tronque un nombre réel en entier. | |
Garantit qu'une chaîne n'a qu'une seule référence. La chaîne peut être copiée pour produire une référence unique. | |
Convertit un caractère en majuscule. | |
Renvoie une chaîne en majuscules. | |
Crée un tableau variant. | |
Renvoie le nombre de dimensions d'un tableau variant. | |
Renvoie la limite supérieure d'une dimension d'un tableau variant. | |
Verrouille un tableau variant et renvoie un pointeur sur les données. | |
Renvoie la limite inférieure d'une dimension d'un tableau variant. | |
Crée et remplit un tableau variant unidimensionnel. | |
Redimensionne un tableau variant. | |
Renvoie une référence au tableau variant transmis. | |
Déverrouille un tableau variant. | |
Convertit un variant dans le type spécifié. | |
Convertit un variant dans le type spécifié, en stockant le résultat dans une variable. | |
Efface un variant. | |
Copie un variant. | |
Convertit un variant en chaîne. | |
Renvoie le code de type du variant spécifié. |