Cours de programmation n°1

Introduction et instructions

Prise de contact

• Présentation, organisation, cas des étudiants étrangers.
• Buts, choix du langage Ada.
• Cas des élèves ayant déjà fait de la programmation.
• Sondage, niveaux, liste des élèves.

Présentation générale de l'informatique

• Systèmes physiques, couches matérielles, hardware (mémoire, disque dur, CPU...).
• Systèmes d'exploitation, couche logicielle, software
  Windows, Unix-Linux, Mac.
• Langages de programmation. Notion de niveau d'abstraction
  Assembleur - C,C++,Java,Ada,Pascal - Lisp,Prolog...
• Programmation impérative.
• Instructions, modification d'un état discret
  Exemple du jeu d'échecs : ensemble de variables, ayant chacune un type.
• Instructions : Calculs mathématiques et logiques & entrées-sorties.
• Lemme de base : l'ordinateur est idiot (mais discipliné).

Premier programme

Structure générale d'un programme simple

with Ada.Text_IO;
use Ada.Text_IO;

procedure nom_du_fichier is
-- Déclaration de variables globales
-- Fonctions et procédures internes
-- "declare" de nouvelles variables.
begin
  -- Suite d'instructions
  Put_Line("Hello World");
end nom_du_fichier;

• Présentation sommaire Unix, éditeur de texte (cf TP mercredi).
• Hello world.
• Compilation, notion de fichiers.
• Variables, calculs, Entrées/Sorties (voir ex_concepts).
• Programmes conséquents coupés en plusieurs fichiers : paquetages, édition de liens.
• Compilation : faire adamake nom_du_fichier.adb (voir le résultat).
• Erreurs de compilation, d'exécution (plus graves).
• Assembleur : pas de variables (@ mémoire), tout dans un long programme avec des sauts.
• Commentaires, espaces, majuscules, ";", retour à la ligne, indentation.

Variables et types

• Nom donné à une valeur, plus pratique à manipuler qu'une adresse dans la mémoire..
• Notion de type.
• Types simples.
• Integer (entiers), Natural (>=0), Positive (>0).
• Float.
• Boolean.
• Character, String.
• Types composés

Déclaration de variables :

Continuer : Boolean;
X,Y       : Integer;
a,b,c     : Float := 0.0;
Nombre_de_Jours : constant Positive := 365;

Affectation d'une variable :

X := 5;
Y := 3+X;
Continuer := X>Y;
a := 3.4*b + c*X - sin(a);

• Nom (à gauche) et expression (à droite) de même type.
• Notion de types compatibles (un Positive affecté à un Integer)
• Conversion de type X : Natural; a := Float(X);
• Ecriture dans la variable de gauche, lecture de celles de droite.
• Expressions booléennes : and, or, not, true, false
• Expressions mathématiques : division entière, modulo, fonctions trigonométriques, valeur absolue...

Suite d'intructions

Entrées-Sorties

• Lecture : get(variable);, identique à une affectation. Voir aussi get_line(s,l);
• Écriture : put(expression); ou put_line("Hello"); (String seulement).
• Conversion en chaîne de caractères : Natural'Image(X).
• Concaténation de chaîne : put_line("La valeur est" & Integer'Image(X) & " cm");.
• Saut de ligne : New_Line;, (voir entree_sorties.adb).
• Paquetages spécifiques : Ada.Text_IO, Ada.Integer_Text_IO, Ada.Float_Text_IO;.
• Demander avec un put avant tout get.

Suite d'instructions en séquence

• Début, fin, linéaire, états, curseur.
• Coût = Somme (temps ou instructions élémentaires).
• Instruction vide : null;.

Instruction conditionnelle : if

• if condition booléenne then ... end if; ou if ... then ... else ... end if;.
• Exemple : maximum de 2, 3 valeurs. En valeur ou en indice.
• Dessin : blocs A,B,C....
• if A then ... est plus élégant que if A=true then ...

Instruction de branchement : case

• Action différente selon la valeur d'une variable (de type énuméré, cf cours 2).

Put_Line("Voulez-vous vraiment quitter ? ");
Get(rep);  -- rep est de type Character
case rep is
  when 'N' => ...;
  when 'Y'|'y' => ...;
  when others => ...;
end case;

• Rien d'autre qu'une longue série de if ... else

Structures de boucles

• On sait au départ le nombre d'itérations : for

  -- I n'a pas à être déclaré avant
  for I in 0..2*X+1 loop
    Put ('*');
  end loop;

• Compte à l'envers avec in reverse 1..12.
• Exemples : dessin de ligne, factorielle, coin d'*, diagonale d'*.
   
• On ne sait pas combien d'itérations on souhaite faire : while, loop
• while C loop ... end loop; : compteur, 0 passages, boucle infinie, prédicat en sortie.
• loop ... exit when C ... end loop; : cas général, plus complexe.
• Le for est un cas simplifié du while (laissé en exercice)
• Calcul des coûts.
• Assertions, invariants prouvés.

declare
    i, j : Integer;
begin
    i := 1;
    j := 100;
    while i < 59 loop 
         -- INVARIANT : i+j = 101 
         -- on sait aussi que i < 59 
         j := j - 1;
         i := i + 1;
         -- ici i < 59+1 
         -- et on est retombe sur i+j=101
    end loop;
    -- Ici, puisqu'on est sorti : i >= 59
    -- et on a toujours i < 59+1, i+j=101
    put (i);
    put (j);
    -- Que voit-on ici ? 
    -- des formules precedentes, on deduit facilement i = 59, j = 42

********
 *******
  ******
   *****
    ****
     ***
      **
       *