Base de connaissances CCM
Programmation - Langages - Pascal

Quelques liens pour des compilateurs et ressources Pascal gratuits:

• FreePascal
• GNU-Pascal
• Dev-Pascal
• Autres compilateurs

Bon développement.

Lire la suite

Gestion des erreurs »

Par défaut, en Pascal, la gestion des erreurs est assurée par le compilateur. C'est pour cette raison que le programme s'arrête en affichant un message commençant par Runtime error suivi par le numéro de l'erreur ...
Alors si le programmeur désire gérer lui même les erreurs il faut qu'il désactive l'option de vérification des erreurs par le compilateur, en utilisant le menu Option et la commande Compiler ... ou bien d'utiliser les directives de compilation directement dans le code source du programme.

Par exemple, si dans un programme donné, nous voulons ouvrir un fichier par la procédure ReSet et que ce fichier n'existe pas, un message d'erreur est affiché et le programme est arrêté.
Pour éviter ceci, nous pouvons tester l'existence ou non d'un fichier et puis agir en conséquence en utilisant la directive de compilation $I est la fonction IOresult qui renvoie le résultat des opérateurs d'entrée / sortie. Avec la directive {$I-}, le programmeur doit gérer lui même ce type d'erreur.
Ceci est un programme qui permet de saisir le nom physique d'un fichier et de l'ouvrir. Si le fichier n'existe pas il sera créé sans arrêt du programme sur l'erreur : Runtime error 2 at ... (fichier inexistant).

Program Ouverture; 
Uses WinCrt; 
Type 
    Fichier = File; 
Var 
f : Fichier; 
nom : string; 
Begin 
     Write ('Nom du fichier : '); Readln (nom); 
     Assign (f, nom); 
     {$I-} 
     Reset (f); 
     If IOresult <> 0 then Rewrite (f); 
     {$I+} 
end.

Lire la suite

Gestion d'écran en Pascal »

La gestion d'écran se fait par les fonctions et les procédures prédéfinies de l'unité WinCrt. C'est pourquoi dans chaque programme on utilise l'unité WinCrt (Crt en Free Pascal)

Exemple :

• Par défaut, le titre d'une fenêtre c'est le nom du fichier source commençant par son chemin d'accès, pour le modifier on met dans la variable prédéfinie (Tableau de 80 caractères) de l'unité WinCrt : WindowTitle à l'aide de la procédure de l'unité Strings : StrCopy.
• Et pour fermer la fenêtre après la fin de l'exécution du programme on appelle la procédure DoneWinCrt.

Mais, pour déplacer le curseur on utilise la procédure GotoXY

Et voici un exemple illustratif :

Program Gestion;  
Uses WinCrt, Strings;  
Begin  
     StrCopy(WindowTitle, 'GESTION DE STOCK');  
     GotoXY (20, 10); (* Ligne 10 colonne 20 *)  
     Write ('*');  
     Readln;  
     DoneWinCrt;  
End.

Lire la suite

Pascal - Tri par insertion - Récursivité- »

Voici une procédure récursive qui permet de trier un tableau de n entiers en utilisant la méthode de tri par insertion :

Procedure Tri_Ins (Var t: TAB; n: integer);  
Var aux,i : integer;  
begin  
        If n > 1 Then  
             begin  
                  Tri_Ins (t,n - 1);  
                  If t[n] < t[n - 1] Then  
                  Begin  
                     aux:= t[n];  
                     i := n;  
                     Repeat                          
                        t[i] := t[i - 1];  
                        i := i - 1;  
                     Until (i = 1) Or (aux > t[i - 1]);  
                     t[i] := aux;  
                  End; 

Lire la suite

Décaler les éléments d'un tableau (Rotation) -Récursivité- »

Voici une procédure récursive qui permet de décaler tous les éléments d'un tableau d'une position à droite à partir de la position p

Procedure Decaler (Var t : Tab; p, n : integer);  
Begin  
     If p <= n Then  
     Begin  
          Decaler (t, p + 1, n);  
          t[p + 1] := t[p];  
     End;  
End;

Lire la suite

Inverser les éléments d'un tableau -Récursivité- »

Voici une procédure récursive qui permet d'inverser les éléments d'une partie d'un tableau compris entre la position p et n :

Procedure Inverser (Var t : Tab; p, n : Integer);  
Var aux : Real;  
Begin                           
     If p < n Then  
     Begin  
          aux := t[p];  
          t[p] := t[n];  
          t[n] := aux;  
          Inverser (t, p + 1, n - 1);            
     End;  
End;

Lire la suite

Tri par fusion - récursivité- »

Voici une procédure récursive qui permet de trier un tableau de n entiers en utilisant la méthode de tri par fusion :

Procedure Tri_Fusion (Var t : TAB; g, d : integer);  
Var  
   m, i, j, k : integer;  
   s : TAB;  
Begin  
     If d > g Then  
     Begin           
          m := (g + d) Div 2;  
          Tri_Fusion (t, g, m);  
          Tri_Fusion (t, m + 1, d);  
            
     For i := m DownTo g Do  
              s[i] := t[i];  
            
     For j := m + 1 To d Do  
              s[d + m + 1 - j] := t[j];  
            
     i := g; j := d;  
          For k := g To d Do  
          Begin  
               If s[i] < s[j] Then  
               Begin  
                    t[k] := s[i];  
                    i := i + 1;  
               End  
               Else  
                   Begin  
                         t[k] := s[j];  
                         j := j - 1;  
                   End;  
          End;  
     End;  
End;

Lire la suite

Tri à bulles -récursivité- »

Voici une procédure récursive qui permet de trier un tableau de n entiers en utilisant la méthode de tri à bulles :

Procedure Tri_bulles (var t : TAB; n : integer);  
Var i, aux : integer;  
    Function Trier (t : TAB; n : integer) : Boolean;  
    Var ok : boolean; i : integer;  
    Begin  
         ok := true; i := 1;  
         Repeat  
               If t[i + 1] < t[i] Then ok := false  
               Else i := i + 1;  
         Until ((Not ok) or (i >= n));  
         Trier := ok;  
    End;  
    Begin  
         If Not Trier (t, n) Then  
         Begin  
              For i := 1 To n - 1 Do  
                If t[i] > t[i + 1] Then  
                   Begin  
                        aux := t[i];  
                        t[i] := t[i + 1];  
                        t[i + 1] := aux;  
                   End;  
              Tri_bulles (t, n);  
         End;  
    End;

Lire la suite

Tri Shell -Recursive- »

Voici une procédure récursive qui permet de trier un tableau de n entiers en utilisant la méthode de tri Shell :

Procedure Tri_Shell_Rec (Var t: TAB; n,h : integer);   
Var aux,i : integer;   
begin   
    If h > 0 Then   
    Begin   
        If n > h Then   
             begin   
                  Tri_Shell_Rec (t,n - h,h);   
                  If t[n] < t[n - h] Then   
                  Begin   
                     aux:= t[n];   
                     i := n;   
                     Repeat                           
                        t[i] := t[i - h];   
                        i := i - h;   
                     Until (i = h) Or (aux > t[i - h]);   
                     t[i] := aux;   
                  End;   
              End;   
        Tri_Shell_Rec (t,n,h Div 3);   
    End;   
End;

Remarques:

Tester cette procédure sur des tableaux de petites tailles, car si n'est pas le cas le nombre des appels devient important et en aura le problème de débordement de la pile (la limite technique de la récursivité est la mémoire).
On peut augmenter la taille du tableau test on augmentant la taille de la pile (Option\Compilateur\Paramètres mémoire\Taille pile)