Learn PASCAL - Thomas-Zabalo/PASCAL GitHub Wiki

Documentation sur le langage Pascal

Introduction à Pascal

Pascal est un langage de programmation impératif, structuré et typé, qui a été conçu pour encourager une bonne pratique de la programmation.

Erreurs courantes

Attention à la syntaxe :
Les erreurs les plus fréquentes en Pascal sont liées à la syntaxe. Quelques points à garder à l'esprit :

  • Un espace en trop : Pascal est sensible à l'espace, veillez à bien organiser votre code.
  • Le manque de point-virgule ; : Un oubli de point-virgule après une instruction ou une déclaration peut provoquer une erreur.
  • La mauvaise définition des variables : Assurez-vous que toutes les variables sont bien définies avec leur type.

Cela peut entraîner un mauvais fonctionnement du code.

Architecture d'un fichier de base

Voici l'architecture d'un fichier Pascal typique :

program {Nom du programme};
uses {Extensions ou bibliothèques nécessaires};

const
  {Déclaration des constantes ici};

var
  {Déclaration des variables ici};

{Création d'une fonction (si nécessaire)}
function {Nom de la fonction}({paramètres}): {Type de retour};
begin
  {Corps de la fonction}
end;

{Création d'une procédure (si nécessaire)}
procedure {Nom de la procédure}({paramètres});
begin
  {Corps de la procédure}
end;

begin
  {Début de ton programme}
  {Instructions principales ici}
end. {Fin du programme}

Explication :

  1. program : Le nom de ton programme.
  2. uses : Pour importer des bibliothèques ou extensions nécessaires (par exemple, crt pour gérer l'écran).
  3. const : Déclare des constantes (valeurs fixes).
  4. var : Déclare des variables (les types doivent être précisés).
  5. Fonctions et procédures : Définir les comportements et les actions à accomplir.

Variables

Variables globales

Les variables globales sont définies dans la section var au début du programme. Elles sont accessibles par toutes les fonctions et procédures du programme.

Variables locales

Les variables locales sont spécifiques à une fonction ou une procédure. Elles sont définies juste après le nom de la fonction ou de la procédure et avant le mot-clé begin.

Exemple :

function CalculSomme(a, b: Integer): Integer;
var
  somme: Integer;
begin
  somme := a + b;
  CalculSomme := somme;
end;

Types de données

Pascal offre plusieurs types de données de base :

  1. Entiers (Integer) : Représente des nombres entiers (positifs ou négatifs).
  2. Réels (Real) : Pour des nombres avec une virgule flottante.
  3. Caractères (Char) : Représente un seul caractère.
  4. Booléens (Boolean) : Peut être True ou False.
  5. Chaînes de caractères (String) : Représente des séries de caractères (texte).

Exemple :

var
  a: Integer;
  b: Real;
  c: Char;
  d: Boolean;
  e: String;

Constantes

Les constantes sont des valeurs fixes qui ne peuvent pas être modifiées pendant l'exécution du programme. Elles sont définies dans la section const.

Exemple :

const
  MAX_VAL = 100;
  MIN_VAL = 1;

Fonctions

Les fonctions sont des morceaux de code qui effectuent des calculs et retournent une valeur. Elles sont définies avec le mot-clé function.

Exemple de fonction

function Increment(val: Integer): Integer;
begin
  Increment := val + 1;
end;

Les fonctions sont utilisées pour encapsuler des logiques réutilisables. Elles peuvent accepter des paramètres et retourner une valeur.

Exemple d'utilisation :

var
  result: Integer;
begin
  result := Increment(5);  { Appelle la fonction et stocke le résultat }
  WriteLn('Résultat : ', result);  { Affiche 6 }
end.

Procédures

Les procédures sont similaires aux fonctions, mais elles ne retournent pas de valeur. Elles sont utilisées pour exécuter des actions sans avoir besoin de renvoyer un résultat.

Exemple de procédure

procedure AfficherMessage;
begin
  WriteLn('Bonjour, bienvenue sur Pascal!');
end;

Les procédures sont appelées de manière similaire aux fonctions, mais sans attendre de valeur de retour.

Exemple d'utilisation :

begin
  AfficherMessage;  { Appelle la procédure pour afficher un message }
end.

Exemple complet : Compteur

Voici un exemple complet d'un programme Pascal qui incrémente un compteur avec une fonction.

program Counter;
uses crt;

var 
  nb: Integer;

procedure Increment(var num: Integer);
const 
  plus = 2;
begin
  num := num + plus;
end;

begin
  nb := 0;
  Increment(nb);  { Appelle la procédure pour incrémenter }
  writeln('Valeur de nb après incrémentation : ', nb);
end.

D'accord, simplifions tout ça pour commencer !

Tableaux en Pascal

Un tableau est une manière de stocker plusieurs valeurs sous un même nom. Par exemple, tu peux avoir un tableau qui contient plusieurs scores, et tu y accèdes via un numéro (ou indice).

1. Déclarer un tableau

Un tableau en Pascal est défini avec une plage d'indices, par exemple :

var
  scores: array[1..5] of Integer;

Cela crée un tableau scores qui contient 5 éléments, chacun étant un nombre entier (Integer). Les indices vont de 1 à 5.

2. Accéder aux éléments d’un tableau

Pour accéder à un élément du tableau, tu utilises un indice. L'indice commence à 1 (ou parfois à 0, selon la déclaration).

Par exemple, pour mettre un score dans le premier emplacement du tableau :

scores[1] := 10;  { Le premier score est 10 }

3. Utiliser un tableau avec une boucle

Les tableaux sont souvent utilisés avec des boucles pour automatiser les actions. Voici comment tu peux utiliser une boucle pour remplir et afficher un tableau.

var
  i: Integer;
  scores: array[1..5] of Integer;
begin
  { Remplir le tableau avec des scores }
  for i := 1 to 5 do
    scores[i] := i * 10;  { Exemple : 10, 20, 30, ... }

  { Afficher les scores }
  for i := 1 to 5 do
    WriteLn('Score ', i, ': ', scores[i]);
end.

4. Tableau multidimensionnel (facultatif pour débuter)

Parfois, tu as besoin de tableaux avec plusieurs dimensions (comme une grille). Par exemple, pour un tableau de 2 lignes et 3 colonnes :

var
  matrix: array[1..2, 1..3] of Integer;
begin
  matrix[1, 1] := 1;
  matrix[1, 2] := 2;
  matrix[1, 3] := 3;
  matrix[2, 1] := 4;
  matrix[2, 2] := 5;
  matrix[2, 3] := 6;

  { Afficher la matrice }
  WriteLn('Matrice :');
  WriteLn(matrix[1, 1], ' ', matrix[1, 2], ' ', matrix[1, 3]);
  WriteLn(matrix[2, 1], ' ', matrix[2, 2], ' ', matrix[2, 3]);
end.

Récapitulatif

  • Tableau simple : Une collection de valeurs d’un même type.
  • Accès aux éléments : Utiliser des indices comme scores[1] pour accéder à l'élément.
  • Boucles : Les boucles permettent de remplir et d'afficher facilement les tableaux.