Fonctions, procédures et types primitifs natifs

Modifiez le fichier dpr de la leçon précédente avec le contenu suivant

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 is: ', A + 10);
end;
function MyFunction(const S: string): string;
begin
  Result := S + 'strings are automatically managed';
end;
var
  X: Single;
begin
  WriteLn(MyFunction('Note: '));
  MyProcedure(5);
  // L'opérateur "/" renvoie toujours un flottant, utilisez "div" pour division entière
  X := 15 / 5;
  WriteLn('X is now: ', X); // notation scientifique
  WriteLn('X is now: ', X:1:2); // 2 chiffres après la virgule
end.Langage du code : PHP (php)

D:\fpcdemo>fpc mydemo.dpr
Free Pascal Compiler version 3.2.2 [2021/05/15] for i386
Copyright (c) 1993-2021 by Florian Klaempfl and others
Target OS: Win32 for i386
Compiling mydemo.dpr
Linking mydemo.exe
20 lignes compilées, 0,0 sec, 39248 octets code, 2484 octets données

D:\fpcdemo>mydemo
Note: strings are automatically managed
A + 10 is: 15
X is now:  3.000000000E+00
X is now: 3.00

D:\fpcdemo>Langage du code : CSS (css)

Voici l’explication ligne par ligne des commentaires. Les caractères non latins peuvent s’afficher déformés ; configurez l’encodage de la console pour afficher correctement le chinois.

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram; 
// Nom personnalisé du programme. Tout programme console Pascal débute par program [nom]; puis déclare variables, procédures et logique principale

// Sans valeur de retour : procedure. Procédures et fonctions ne s’exécutent que si appelées
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 =：', A + 10);
end;

// Avec valeur de retour : function
function MyFunction(const S: string): string;
begin
  Result := S + 'la mémoire des chaînes est gérée automatiquement par le système';
end;

// Object Pascal n’a pas de fonction main, le bloc le plus externe begin...end. est le point d’entrée du programme, voici le bloc principal
var
  X: Single; // Type flottant simple précision natif
begin 
  // Toute la logique à exécuter s’écrit ici
  WriteLn(MyFunction('Conseil：'));
  MyProcedure(5);

  // La division "/" produit systématiquement un nombre à virgule ; utilisez div pour division entière
  X := 15 / 5;
  WriteLn('X is now：', X); // Affichage en notation scientifique
  WriteLn('X is now：', X:1:2); // Limite à deux décimales
end. // end. avec point marque la fin totale du programmeLangage du code : PHP (php)

Chaque fonction ou procédure utilise un couple begin / end pour délimiter son corps, équivalent aux accolades { } de C, C++, Java et autres langages.

WriteLn affiche du texte dans la console, les apostrophes ‘ ‘ encadrent une chaîne de caractères littérale. WriteLn('A + 10 =：', A + 10); affiche successivement la chaîne A + 10 =： puis le résultat du calcul A + 10.

Un programme ne possède qu’un seul bloc externe begin et end. qui contient tout le code principal et appelle les autres fonctions et procédures.

X := 15 / 5;
WriteLn(‘X is now: ‘, X); // notation scientifique
WriteLn(‘X is now: ‘, X:1:2); // deux décimales

L’opérateur / correspond à la division flottante, le quotient est toujours un flottant.

Les deux premières lignes sont des directives de précompilation

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}Langage du code : PHP (php)

Il s’agit d’une directive de compilation conditionnelle propre à FPC

• {$ifdef FPC} : exécute les paramètres intermédiaires uniquement si le compilateur est Free Pascal
• {$mode objfpc} : active le mode syntaxique ObjFpc
• {$H+} : active les chaînes longues (type string moderne à gestion mémoire automatique, indispensable)
• {$J-} : désactive les constantes modifiables (les constantes ne peuvent pas être modifiées pendant l’exécution, plus sûr)
• {$endif} : fin du bloc conditionnel

Rôle : n’activer la syntaxe moderne que lors d’une compilation avec FPC ; le compilateur Delphi ignore tout ce bloc.

{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}Langage du code : PHP (php)

Compilation conditionnelle multiplateforme

• MSWINDOWS : ne s’applique que sur système Windows
• {$apptype CONSOLE} : définit le programme comme une application console (fenêtre terminal noire au lieu d’une fenêtre graphique). Cette ligne est ignorée sous Linux/macOS.

Connaissances fondamentales

• string est un type natif primitif ; FPC/Delphi gère sa mémoire automatiquement, pas de libération manuelle requise
• procedure procédure : sans valeur de retour ; function fonction : avec valeur de retour stockée dans la variable native Result
• Deux opérateurs de division : / division flottante ; div division entière tronquée
• Formatage d’affichage variable:largeurTotale:nbDecimales pour contrôler l’affichage des flottants
• Les fonctions récursives sans paramètres doivent porter des parenthèses vides () pour éviter l’ambiguïté syntaxique
• ValeurExit(Valeur) permet de spécifier une valeur de retour et de quitter une fonction prématurément
• On peut appeler une fonction sans récupérer sa valeur de retour, utile pour des effets secondaires comme la modification de variables globales

Règles des valeurs de retour des fonctions

1. La variable spéciale native Result stocke la valeur renvoyée par la fonction, elle se lit et s’écrit comme une variable locale classique

function MyFunction(const S: string): string;
begin
  Result := S + 'One';
  Result := Result + 'Two';
end;
Langage du code : PHP (php)

2. L’ancienne syntaxe permet d’affecter directement le nom de la fonction (MyFunction := xxx), déconseillée car peu lisible ; utilisez systématiquement Result.

C/C++/Java/C# utilisent = pour l’affectation et == pour la comparaison d’égalité. Pascal fonctionne à l’inverse : := pour l’affectation des variables, simple = pour la comparaison, identique aux notations mathématiques.

Pascal ne dispose pas de l’opérateur ==

Remplacez l’ancienne MyFunction de l’exemple par cette nouvelle version. Cette fonction ajoute d’abord « One » puis « Two » à la fin de la chaîne transmise lors de l’appel.

La chaîne finale renvoyée sera : chaîne initiale + One + Two

Appels récursifs

Les fonctions sans paramètres appelées récursivement doivent avoir des parenthèses vides () pour distinguer « exécuter la fonction » de « lire la valeur de retour actuelle » :

function SumIntegersUntilZero: Integer;
var I: Integer;
begin
  ReadLn(I);
  Result := I;
  if I <> 0 then
    Result := Result + SumIntegersUntilZero(); // appel récursif avec ()
end;
Langage du code : JavaScript (javascript)

Pour la fonction sans paramètre SumIntegersUntilZero :

1. SumIntegersUntilZero() → exécuter la fonction en récursif et récupérer sa valeur de retour
2. SumIntegersUntilZero → référence la variable interne Result (la valeur de retour propre de la fonction)

Code sans parenthèses :

Result := Result + SumIntegersUntilZero;

Le compilateur interprète cela comme :

Result := Result + Result;

Équivaut à Result := Result * 2 ; toute logique récursive est détruite, boucle infinie et valeurs multipliées par deux à chaque étape.

Dans cet exemple, la fonction s’appelle elle-même en boucle jusqu’à ce que l’entrée soit égale à zéro pour sortir ; tant que l’entrée est non nulle, la récurrence continue.

Exit : sortie anticipée

1. Exit sans paramètre : quitte immédiatement la fonction, renvoie la valeur déjà affectée à Result
2. Exit(Valeur) : définit directement la valeur de retour et termine la fonction, équivalent au return x du langage C

function AddName(const ExistingNames, NewName: string): string;
begin
  if ExistingNames = '' then
    Exit(NewName); // renvoie directement NewName et arrête la fonction
  Result := ExistingNames + ', ' + NewName;
end;
Langage du code : PHP (php)

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;
procedure MyProcedure(const A: Integer);
begin
  WriteLn('A + 10 is: ', A + 10);
end;

function AddName(const ExistingNames, NewName: string): string;
begin
  if ExistingNames = '' then
    Exit(NewName); 
  Result := ExistingNames + ', ' + NewName;
end;

var
  X: Single;
begin
  WriteLn(AddName('Tom','Jack'));
  WriteLn(AddName('Tom',''));
  WriteLn(AddName('','Jack'));
end.Langage du code : PHP (php)

Appeler une fonction comme une procédure (ignorer sa valeur de retour)

Même si une fonction renvoie une valeur, on peut l’exécuter uniquement pour sa logique et ignorer le résultat ; adapté aux traitements à effets secondaires (modification de variables globales) :

var
  Count, MyCount: Integer;
function CountMe: Integer;
begin
  Inc(Count); // effet secondaire : incrémentation variable globale
  Result := Count;
end;
begin
  Count := 10;
  CountMe;   // ignorer la valeur de retour, seul l’effet est exécuté, Count passe à 11
  MyCount := CountMe; // récupérer la valeur de retour, Count passe à 12
end.
Langage du code : PHP (php)

Exemple fonctionnel complet

{$ifdef FPC} {$mode objfpc}{$H+}{$J-} {$endif}
{$ifdef MSWINDOWS} {$apptype CONSOLE} {$endif}
program MyProgram;

var
  Count, MyCount: Integer;

function CountMe: Integer;
begin
  Inc(Count); 
  Result := Count;
end;

begin
  Count := 10;
  WriteLn(CountMe);   
  MyCount := CountMe;
  WriteLn(MyCount);
end.Langage du code : PHP (php)

Inc est une fonction native standard de Pascal (FPC/Delphi) qui incrémente une variable de 1.

var est le mot-clé de déclaration de variable en Pascal, son rôle est de définir des variables.

var
  Count, MyCount: Integer;Langage du code : JavaScript (javascript)

var : ouvre la section de déclaration des variables

Count, MyCount : deux noms de variables

Integer : type entier

Les variables déclarées dans le bloc var de cet exemple sont globales, accessibles par toutes les procédures et fonctions du programme entier.

Fonctions, procédures et types primitifs natifs