ADDEXITPROC

Syntaxe

Paramètres

Description

Cette procédure permet d'ajouter une procédure à exécuter lors du processus de terminaison du programme. À la sortie du programme, toutes les procédures ajoutées de cette manière seront appelées dans l'ordre inverse.

Remarques

• La procédure AddExitProc ajoute Proc à la chaîne de procédures de sortie. A la sortie du programme, toutes les procédures ajoutées de cette manière seront appelées dans l'ordre inverse.
• AddExitProc permet d'exécuter du code à la fin du programme : La fonction AddExitProc est utilisée pour enregistrer une procédure étant exécutée juste avant la fin du programme. Cela permet d'effectuer des actions de nettoyage, comme libérer des ressources, fermer des fichiers ou enregistrer des journaux de bord. Elle est souvent utilisée lorsqu'on ne veut pas modifier directement le bloc finalization des unités.
• AddExitProc fonctionne avec des procédures standard sans paramètres : Les procédures enregistrées avec AddExitProc doivent être des procédures classiques sans paramètres. Il n'est pas possible d'y passer une méthode d'objet ou une procédure avec des paramètres. Cela limite son usage pour les nettoyages globaux plutôt que pour des nettoyages spécifiques à des objets. Exemple invalide :
1. Procedure Cleanup(Param: Integer);Begin { ERREUR : `AddExitProc` ne prend pas de paramètre }
2.  WriteLn('Nettoyage avec paramètre : ', Param);
3. End;


• AddExitProc est exécutée dans l'ordre inverse de l'enregistrement : Si plusieurs procédures sont ajoutées via AddExitProc, elles seront appelées dans l'ordre inverse de leur enregistrement. C'est un comportement de type pile LIFO (Last In, First Out). Exemple :
1. Procedure First;Begin
2.  WriteLn('Premier nettoyage.');
3. End;
4.  
5. Procedure Second;Begin
6.  WriteLn('Deuxième nettoyage.');
7. End;
8.  
9. BEGIN
10.  AddExitProc(@First);
11.  AddExitProc(@Second);
12. END.

Sortie attendue :

Premier nettoyage.
Deuxième nettoyage.

• AddExitProc fonctionne même en cas d'erreur non interceptée : Les procédures enregistrées avec AddExitProc seront appelées même si le programme se termine à cause d'une exception non gérée. Cela permet de garantir qu'un certain nettoyage aura toujours lieu, sauf en cas d'arrêt forcé (exemple : Halt). Exemple :
1. {...}
2.  
3. Procedure Cleanup;Begin
4.  WriteLn('Nettoyage avant la sortie.');
5. End;
6.  
7. BEGIN
8.  AddExitProc(@Cleanup);
9.  raise Exception.Create('Erreur fatale !'); { Cleanup sera quand même appelé }
10. END.


• AddExitProc ne fonctionne pas si Halt est appelé : Si le programme est interrompu avec la fonction Halt, les procédures enregistrées avec AddExitProc ne seront pas exécutées. C'est une exception importante à connaître, car un programme qui utilise Halt pour gérer certaines erreurs peut empêcher l'exécution du nettoyage prévu. Exemple :
1. Procedure Cleanup;Begin
2.  WriteLn('Nettoyage...');
3. End;
4.  
5. BEGIN
6.  AddExitProc(@Cleanup);
7.  Halt;  { Cleanup ne sera pas exécuté ! }
8. END.

Sortie attendue : (Rien, car Cleanup est ignoré)

• AddExitProc peut provoquer une erreur d'accès mémoire si elle est mal utilisée : Si une procédure enregistrée avec AddExitProc fait référence à des objets ou variables n'existant plus au moment de l'exécution, cela peut entraîner un segmentation fault ou un comportement indéfini. Exemple dangereux :
1. Procedure Cleanup;
2. Var
3.  P:PChar;
4. Begin
5.  GetMem(P, 10);
6.  StrPCopy(P, 'Test');
7.  WriteLn(P);  
8.  FreeMem(P);  { Mémoire libérée ici... }
9. End;
10.  
11. BEGIN
12.  AddExitProc(@Cleanup);
13. END.

Ici, si Cleanup tente d'accéder à P après sa libération, le programme peut planter. Il faut s'assurer que toutes les ressources utilisées existent encore avant la sortie.

AddExitProc n'est pas recommandée dans du code orienté objet : Dans un programme basé sur des objets, il est préférable d'utiliser le destructeur des objets (Destroy) plutôt que AddExitProc. La raison est que AddExitProc ne gère pas les méthodes d'objets et ne permet pas de gérer précisément la libération de chaque instance.

Mauvaise utilisation avec objets :

1. Type
2.  TMyClass=Class
3.   Procedure Cleanup;
4.  End;
5.  
6. Procedure TMyClass.Cleanup;Begin
7.  WriteLn('Nettoyage de l'objet.');
8. End;
9.  
10. Var
11.  Obj:TMyClass;
12. BEGIN
13.  Obj := TMyClass.Create;
14.  AddExitProc(@Obj.Cleanup);  { ERREUR : `Cleanup` est une méthode d'objet ! }
15. END.

La bonne approche ici serait de libérer explicitement les objets au bon moment, plutôt que d'essayer d'enregistrer un AddExitProc sur des objets.

• AddExitProc est obsolète pour la gestion moderne des sorties : Bien que AddExitProc soit encore fonctionnelle, elle est considérée comme une ancienne approche en Free Pascal. Aujourd'hui, il est préférable d'utiliser : Le bloc finalization d'une unité pour un nettoyage automatique, des destructeurs d'objets (Destroy) pour la gestion mémoire propre, des gestionnaires d'exceptions (try...finally) pour garantir la libération des ressources. Exemple moderne avec finalization :
1. Unit MyUnit;
2.  
3. INTERFACE
4.  
5. IMPLEMENTATION
6.  
7. Procedure Cleanup;Begin
8.  WriteLn('Nettoyage via finalization.');
9. End;
10.  
11. FINALIZATION
12.  Cleanup;
13. END.

Ce code garantit que Cleanup sera exécutée sans dépendre de AddExitProc.

Exemple

Dans cet exemple, nous créons une procédure étant appelée lors de la fermeture du programme pour afficher un message et effectuer un nettoyage :