1 - Introduction

Introduction à la programmation

Le cours IFT 1810

De manière générale, on peut affirmer que le but fondamental du traitement automatisé de l’information est de confier à un ordinateur la tâche de manipuler des données de façon automatique, puis de restituer les résultats selon le plan établi à l’avance.

graph LR;
    A[Données] --> B(Ordinateur) --> C[Résultats escomptés]

La programmation représente l’un des outils permettant d’arriver à ce but. À l’aide d’un langage adapté, qu’on nomme langage de programmation, on définit avec exactitude les étapes que l’ordinateur devra parcourir afin de produire les résultats attendus à partir des données reçues. En informatique, il existe de nombreux langages de ce type, tout comme il existe plusieurs langues humaines (le français, l’anglais, etc.), et ces différents langages servent à dialoguer avec la machine. Dans le cours IFT 1810, les langages employés sont le langage C suivi du Java, tous deux très recherchés sur le marché de l’emploi.

Pour le cours IFT 1810, on aborde durant 7 semaines (sur 12) une portion du langage C pour présenter les concepts fondamentaux de la programmation. Lorsque l’étudiant a assimilé les bases, on introduit progressivement quelques notions élémentaires de la programmation orientée objet (POO) à l’aide du langage Java. Le langage C a été conçu pour être utilisé avec les ordinateurs dans une grande variété d’applications. À l’image des langues humaines, il possède :

• Un vocabulaire qui lui est propre : ce vocabulaire demeure assez restreint, une trentaine de mots pour IFT 1810 qui se retiennent aisément.

• Une syntaxe qui lui est propre : celle-ci, de faible ampleur (comparée à celle de n’importe quelle langue humaine), doit être suivie avec beaucoup de rigueur car l’ordinateur n’exécute que les instructions formulées correctement. Les règles de syntaxe s’assimilent facilement grâce aux exposés théoriques ainsi qu’aux exercices de programmation réalisés dans le cadre du volet pratique du cours.

Le cours IFT 1810 implique l’apprentissage de quelques mots et de quelques règles grammaticales propres aux langages de programmation. Ceux-ci permettent au programmeur de rédiger les phrases (instructions) dont l’ordinateur a besoin pour produire les résultats issus de l’information fournie, selon le problème à résoudre.

L’apprentissage demeure relativement simple. La rédaction des phrases (instructions) en langage C sollicite la logique du raisonnement et l’imagination. L’ensemble se révèle fort instructif et fort captivant. Il suffit de se lancer pour en saisir tout l’attrait!

Branchez-vous et bonne réussite!

Terminologie de base (à titre d’information, non évaluée pour IFT 1810)

1. Informatique : science du traitement de l’information de manière automatique à l’aide d’un dispositif nommé ordinateur.

graph LR;
    A[Données] --> B(Ordinateur : programmes ou logiciels) --> C[Résultats escomptés]

2. Ordinateur : appareil réalisant des opérations sur l’information de façon automatique. L’automatisation des traitements n’empêche pas l’interactivité avec l’utilisateur.

3. Algorithme : enchaînement de raisonnements ou d’opérations de calcul permettant de trouver la solution d’un problème en un nombre limité d’étapes (un exemple sera présenté plus loin).

4. Langage informel ou pseudo-code : façon d’exprimer l’algorithme conçu pour résoudre un problème sans trop tenir compte de la grammaire et du vocabulaire propres au langage de programmation choisi.

5. Programme : ensemble d’instructions précisant les opérations qui devront être réalisées par l’ordinateur pour résoudre un problème. Stocké dans la mémoire centrale, un programme dirige le déroulement des différentes opérations, et ce, jusqu’au résultat final.

6. Programmation : ensemble des activités tournées vers la conception, la réalisation, l’essai et l’entretien de programmes.

7. Langages de programmation. Les principaux sont :

• Pascal : excellent pour l’apprentissage d’un premier langage de programmation.

• Visual Basic : tout aussi excellent que Pascal pour l’apprentissage d’un premier langage de programmation.

• C : langage d’apprentissage de la programmation, à vocation universelle et surtout industrielle.

• C++ : langage de programmation orientée objet présenté dans deux cours de la DESI : IFT 1166 et IFT 1169.

• Java : langage orienté objet enseigné au niveau universitaire.

• C# : langage de programmation orientée objet fondé sur C++ et Java, enseigné dans le cours IFT 1179.

• Etc

8. Fichier : document conservé sur un support durable comme un disque dur ou une clé USB, par exemple : tp1.c, metrique.dta, tp1.exe, tp3.java,…

9. Bit (binary digit) : la plus petite unité d’information qu’on peut représenter dans un ordinateur et que celui-ci est capable de traiter (notée habituellement par 0 ou 1).

10. Octet (byte) : ensemble de 8 bits dans lequel on peut encoder (stocker) un caractère. Unité de mesure des quantités d’information. Chaque octet possède une “adresse” (sa position en mémoire) tout comme chaque logement dispose d’une adresse postale.

Premier exemple d’introduction

Réaliser les étapes nécessaires pour écrire au final un programme en langage C qui permet :

• de saisir une température exprimée en degrés Celsius (exemple : 25 degrés);

• de la convertir en degrés Fahrenheit (formule : F = C × 9 / 5 + 32);

• d’afficher la température dans les deux systèmes (Celsius et Fahrenheit)

Exécution

L’exécution d’un tel programme sur un micro-ordinateur donne, par exemple, ce qui suit à l’écran :

Tapez la temperature en degres Celsius : 25
La temperature mesuree :
 systeme Celsius    : 25 degre(s) C
 systeme Fahrenheit : 77.00 degre(s) F
Appuyez sur une touche pour continuer...

Comprendre le problème, faire un cheminement

Quelles sont les données ? :

• la température en degrés Celsius

• les facteurs de conversion (le rapport 9 / 5 et l’écart de 32 degrés).

Quels sont les résultats ? :

• un seul! c’est la température en degrés Fahrenheit

Exemple : Si une journée affiche 25 degrés Celsius, comment calculer la température en Fahrenheit ?

25 degres Celsius x 9 / 5 = 45 (car le rapport est de 9 pour 5)

45 + 32 = 77 degres Fahrenheit

Cheminement :

Obtenir la température en degrés Celsius

Convertir la température en Fahrenheit selon la formule :

fahrenheit <---- celsius x 9 / 5 + 32

Faire un tableau d’analyse des informations

Dans ce tableau :

• une variable est une information dont la valeur peut changer : la température en Celsius et celle en Fahrenheit varient d’une journée à une autre;

• une constante est une information dont la valeur reste fixe : on applique toujours le même facteur de conversion (le rapport 9/5 et l’écart de 32 degrés) quelle que soit la température;

• un identificateur est un mot unique servant à désigner l’information (on attribue un nom à l’information). La syntaxe du langage débute ici.

Faire un algorithme (un cheminement plus détaillé)

Obtenir la temperature en degres Celsius :

Écrire un message à l'écran pour demander à l'usager
d'entrer la temperature en degres Celsius

Lire celsius  (tapé au clavier par l'usager)

Convertir la temperature en Fahrenheit selon la formule :

fahrenheit <---- celsius x 1.8 + 32

Afficher la temperature :

Écrire à l'écran la temperature 
-	dans le systeme Celsius    : celsius
-	dans le systeme Fahrenheit : fahrenheit

Dans cet algorithme, on emploie souvent des identificateurs décrits dans le tableau d’analyse de l’information.

Avant de programmer, on contrôle l’exactitude de l’algorithme.

Traduire l’algorithme en langage de programmation

On traduit l’algorithme en utilisant le vocabulaire du langage (ici, le C) et sa syntaxe.

Le tableau d’analyse des informations est utile pour comprendre le problème et pour effectuer les déclarations.

Cette étape, qui est expliquée en détail au premier cours théorique, nous mène à un programme écrit en langage C comme suit, suivi des explications :

#include <stdio.h>

int main()
{
    /* F = C x 1.8 + 32 */
    const float FACTEUR = 1.8;

    int ecart = 32; /* ecart additif en degres */

    float celsius;    // la temperature en Celsius
    float fahrenheit; // la temperature en Fahrenheit
    
    /* Saisie de la donnee tapee au clavier */
       printf("Tapez la temperature en degres Celsius : ");
       scanf("%f", &celsius);
       
    /* Conversion en Fahrenheit */
       fahrenheit = celsius * FACTEUR + ecart;
       
    /* Affichage de ces informations */
       printf("La temperature mesuree :\n");
       printf(" systeme Celsius    : %.0f degre(s) C\n", celsius);
       printf(" systeme Fahrenheit : %.2f degre(s) F\n", fahrenheit);
       
    return 0;   
}

Ce programme sera présenté en ligne (tapé sur l’ordinateur en classe et projeté à l’écran dans la salle de cours). Il sera aussi disponible sur le site Web du cours. Pour le premier cours, vous n’avez pas besoin de comprendre tous les détails. L’objectif est d’avoir une idée de la programmation et du langage C. Les détails et les explications techniques seront présentés durant les autres semaines.

Explications sommaires du programme

Ce programme comporte :

1. Un fichier d’en-tête (fichier d’inclusion) :

#include <stdio.h>

stdio.h (standard input/ouput header file) est le nom d’un fichier d’en-tête permettant de gérer les entrées et sorties standard (scanf : lire les données, printf : afficher, etc …)

2. Une seule fonction (pour cet exemple), c’est la fonction principale (main) : int main ()

3. un bloc d’énoncés délimités entre { (début d’un bloc) et } (fin d’un bloc)

4. La déclaration :

• D’une constante de type réel dont la valeur vaut 1.8 :

const float FACTEUR = 1.8;

const est l’abrégé du mot “constant” en anglais qui signifie une constante.

float désigne le type réel (un nombre “flottant”, une valeur numérique avec la partie décimale).

FACTEUR (facteur de conversion) est le nom de cette constante. La valeur d’une constante est inchangée durant l’exécution du programme (le facteur de conversion est le même, quelle que soit la température).

• De trois variables :

ecart est le nom (l’identificateur) d’une variable de type entier (int est l’abrégé du mot anglais “integer” qui signifie le type entier, exemple 23, 456, 32100, etc…)

celsius et fahrenheit sont les noms de deux variables de type réel (float désigne le type réel, valeur numérique avec la partie décimale, exemple 25.0).

La valeur d’une variable peut varier durant l’exécution du programme (la température varie d’une journée à une autre).

5. L’affichage d’un message à l’écran :

printf("Tapez la temperature en degres Celsius : ");

printf est le nom d’une fonction (une tâche) prédéfinie qu’on peut appeler en incluant le fichier d’en-tête approprié (ici : stdio).

#include <stdio.h>

printf vient de 2 mots anglais : print + format qui signifient “afficher avec format de présentation” (à voir plus tard dans le cours). On utilise souvent cette fonction pour afficher des messages, des calculs, des variables, etc.

Notez que nous ne plaçons pas de lettres accentuées dans les messages à imprimer par le programme. La raison est très simple : les accents n’apparaissent pas correctement lorsque nous lançons le programme.

Format (plus tard dans le cours) :

• %d ou %nd pour un entier : printf("%3d", age);

• %f ou %n.kf pour un réel : printf("%6.2f", temperature);

• %c ou %nc pour un caractère: printf("%4c", sexe);

6. la lecture de données tapées au clavier :

scanf("%f", &celsius);

scanf est le nom d’une autre fonction (une tâche) prédéfinie qu’on peut appeler en incluant le fichier d’en-tête approprié (ici : stdio).

#include <stdio.h>

scanf vient de 2 mots anglais : scan + format qui signifient “lire les données avec format de présentation”. On utilise souvent cette fonction pour lire les données tapées au clavier.

Le code de format %f indique qu’on lit un réel.

L’opérateur & indique l’adresse (l’emplacement en mémoire) d’une variable. On lit un réel et on place sa valeur à l’adresse d’une variable. La notion “d’adresse de …” sera présentée plus en détails durant les prochaines semaines. Temporairement, on peut imaginer le cas d’un facteur qui livre un colis chez-vous grâce à votre adresse (plutôt que votre nom).

Veuillez noter que les instructions de lecture et d’écriture varient beaucoup d’un langage de programmation à un autre.

7. l’affectation à la variable fahrenheit du résultat d’un calcul :

fahrenheit = celsius * FACTEUR + ecart;

L’opérateur = indique qu’on affecte (on dépose) la valeur de l’expression à droite du symbole = à la variable fahrenheit.

L’opérateur * représente la multiplication entre deux valeurs numériques.

8. l’affichage des informations :

printf("La temperature mesuree :\n");

On affiche à l’écran le message La temperature mesuree :

Le caractère \n (new line) signale qu’on quitte la ligne d’affichage (changement de ligne d’affichage).

printf(" systeme Celsius    : %.0f degre(s) C\n", celsius);

On affiche à l’écran la valeur de la variable celsius avec message d’accompagnement et le format de présentation dont %.kf est le format pour un réel.

printf(" systeme Fahrenheit : %.2f degre(s) F\n", fahrenheit);

On affiche à l’écran la valeur de la variable fahrenheit avec message d’accompagnement et le format de présentation dont %.kf est le format très courant pour présenter un réel.

k chiffres après le point de décimal.

Explications sommaires du code de format :

• %.2f : on aimerait afficher la température sous le format d’un réel (f : float (un réel))

• On veut 2 chiffres après le point de décimal.

• Les détails des formats seront présentés plus tard.

Éléments de base du langage C

Dans ce programme, on utilise des mots de vocabulaire ainsi que les symboles suivants du langage C :

• int main() : fonction principale

• const : constante

• float : type réel (exemple -23.7, 1.78, 67.9435, …)

• int : type entier (exemple -34, 0, 678, …)

• { : début d’un bloc d’instructions

• } : fin d’un bloc d’instructions

• printf : afficher à l’écran avec format de présentation

• scanf : lire (avec format) des données tapées au clavier

• = : affectation (dépôt de valeur)

• * : multiplication

• / : division

• \n : (new line) : changement de ligne

Ces mots et ces symboles reviennent exemple après exemple, semaine après semaine. On parviendra rapidement à les comprendre et à les retenir. Il reste une vingtaine d’autres mots à découvrir durant toute la session.

Dans l’environnement du compilateur Dev-C++, par défaut, l’écran d’exécution se ferme automatiquement. L’usager n’a pas du temps de lire les informations affichées à l’écran d’exécution. Pour empêcher la disparition de l’écran d’exécution, on ajoute la ligne suivante à la fin du programme :

system("pause");

Cette instruction permet d’afficher le message Appuyez sur une touche pour continuer... et met l’écran d’exécution en vue (en pause) en attente de la frappe d’une touche (par exemple la touche Entrée).

Pour IFT 1810, la fonction principale se présente souvent sous la forme :

int main()
   {   . . .
                                

        return 0 ;
    }   

Quelques règles de syntaxe

Dans ce programme :

• On termine souvent une “phrase en langage C” (une instruction) par le point virgule ; :

int ecart;

• On délimite un message entre les guillemets :

printf("Entrez la temperature en degres Celsius ");

• On affecte (dépose) une valeur à une variable avec le symbole =

fahrenheit = celsius * FACTEUR + ecart;

• On utilise le symbole * pour la multiplication

• Une erreur de syntaxe est souvent facile à localiser et à corriger. Après quelques semaines de pratique, on sera habitué aux règles de syntaxe du langage.

Convention pour les identificateurs

Pour le cours IFT 1810, on suggère :

1. D’utiliser les majuscules pour faciliter l’identification des constantes :

const int MAX_ETUD = 100; /* au maximum : 100 étudiants */
#define TAUX_TPS 0.05     /* 5% pour le taux de TPS */

2. D’utiliser le premier mot en minuscules et le début d’un nouveau mot en majuscules :

int age, nbPieds, nbPouces;
float tailleEnMetre , poidsEnKg;

3. D’utiliser un identificateur de longueur raisonnable et significatif :

• taille au lieu de t (non significatif)

• taille au lieu de laTailleDeLaPersonneATraiter (trop long pour taper !)

4. Éviter les accents, les cédilles,… dans les identificateurs : taillePlusÉlevé, température, . . .

Environnement de travail

Cette étape se fait sur un poste de travail muni d’un compilateur C (ou C++). Exemple : sur un micro-ordinateur avec un compilateur de C++ (comme dans nos laboratoires : wxDevcpp ou Dev-C++).

Une démonstration sera faite en classe au premier cours et/ou au laboratoire, lors de la première démonstration :

1. Éditer le programme :

• Taper le programme.

• Corriger les erreurs de frappe.

• Sauvegarder dans un fichier (document électronique).

2. Compiler le programme :

• Le compilateur traduit le programme C en langage machine.

• Il signale les erreurs de syntaxe.

On utilise l’éditeur pour corriger les erreurs, s’il y a lieu, jusqu’à ce que la compilation se termine avec succès.

3. Exécution du programme :

L’ordinateur exécute les instructions décrites dans le programme.

Si les résultats sont incorrects (une température de 200 degrés Fahrenheit pour 25 degrés Celsius, par exemple), il faut réviser l’algorithme.

Si les résultats sont corrects, il suffit d’améliorer, s’il y a lieu, la présentation des résultats à l’écran, la présentation du programme, etc.

Profitez de la première semaine de démonstration pour vous familiariser avec l’environnement de travail. A partir de la deuxième semaine, on peut commencer le premier travail pratique de la session.

Exercices

Exercice 1 :

Énoncé

Faire les étapes nécessaires pour écrire au final un programme en langage C qui permet :

• De saisir le prix d’un seul article

• De calculer les taxes suivantes :

  • tps : 5 % du prix

  • tvq : 9.975 % du prix

  • taxes : total des 2 taxes

• De calculer le prix total à payer

• D’afficher les prix et les taxes

• De saisir le montant donné par le client

• De calculer le change (la monnaie) à lui remettre

• D’afficher les informations voulues

Exécution

L’exécution d’un tel programme sur un micro-ordinateur donne ce qui suit à l’écran :

Tapez le prix de l'article 2.78
TPS       0.14
TVQ       0.28
Prix avec taxes 3.20
Quel est le montant donne par le client ? 10.00
Montant remis parle client : 10.00
Monnaie a remettre : 6.80 $
Appuyez sur une touche pour continuer...

Solution

Écrire un message à l'écran pour demander à l'usager d'entrer le prix de l'article.

Lire prix  (tapé au clavier par l'usager)

tps   <------ prix x TAUX_TPS
tvq   <------ prix x TAUX_TVQ

prixAvecTaxes <---- prix + tps + tvq

Écrire à l'écran : prix, tps, tvq,  prixAvecTaxes

Écrire un message à l'écran pour demander à l'usager d'entrer le montant donné par le client
Lire montantRemis (tapé au clavier par l'usager)

monnaie <----- montantRemis – prixAvecTaxes

Écrire à l'écran : montantRemis, monnaie

Exercice 2 :

Écrire un programme qui permet de saisir la longueur et la largeur d’un rectangle et qui calcule le périmètre et la surface de ce rectangle. Voici les informations pour le traitement :

• Votre programme doit afficher les informations sur le rectangle en question.

• Quelles sont les données?

  • La largeur et la longueur.

• Quels sont les résultats?

  • Le périmètre et la surface.

• Le traitement devra s’effectuer de la façon suivante :

  • Périmètre = 2 * (longueur + largeur)

  • Surface = longueur * largeur

Solution

Lire longueur, largeur

Calculer perimetre: perimetre <---- 2 * (longueur + largeur)
Calculer surface:   surface <---- longueur * largeur 

Afficher longueur
Afficher largeur
Afficher perimetre
Afficher surface

#include <stdio.h>  

 /* Auteurs : Tremblay Nicole,  Section E et
              Bérubé Yves,      Section F

     Date : 13 septembre 2024

     But : Ce programme permet de saisir la longueur et la largeur
           d'un rectangle. 

           On calcule le périmètre et la surface :
               perimetre = 2 x (longueur + largeur)
               surface = longueur x largeur

           On affiche les informations du rectangle
  */

int main()
{
   float longueur, largeur, perimetre, surface;

   /* Saisie des coordonnées du rectangle */
   printf("Entrez la longueur et la largeur du rectangle ");
   scanf("%f%f", &longueur, &largeur);

   /* Calcul du périmètre : */
   perimetre = 2 * (longueur + largeur);

   /* Calcul de la surface : */
   surface = longueur * largeur;

   /* Affichage : */
   printf("Informations du rectangle : \n");
   printf("   La longueur     : %8.2f\n", longueur);
   printf("   La largeur      : %8.2f\n", largeur);
   printf("   Le perimetre    : %8.2f\n", perimetre);
   printf("   La surface      : %8.2f\n", surface);
   
   return 0;
}

Exécution

Entrez la longueur et la largeur du rectangle 8.6 3.4
Informations du rectangle :
   La longueur     :     8.60
   La largeur      :     3.40
   Le perimetre    :    24.00
   La surface      :    29.24
Appuyez sur une touche pour continuer...

Exercice 3 (sans solution)

Faire les étapes nécessaires pour écrire au final un programme en langage C qui permet :

• De saisir le rayon d’un cercle

• De calculer et d’afficher à l’écran

Le périmètre (2 x PI x Rayon dont PI vaut 3.14159)

La surface (PI x Rayon x Rayon)

Allure d’un programme simple

Un programme simple écrit en langage C comporte souvent :

1. Des fichiers d’en-tête (header file):

#include <xxxx.h>

2. Des déclarations “globales” (à voir plus tard dans le cours)

3. Une fonction principale (main) qui contient des déclarations et des instructions en langage C

4. Des sous-programmes (en langage C on n’a que des fonctions qui se trouvent avant et/ou après la fonction principale : à étudier plus tard.

5. Des commentaires sur une ou plusieurs lignes : entre /* et */ (en langage C, en langages C++, C# et Java)

6. On ajoute aussi des courts commentaires (commentaires en ligne) : fin de la ligne = fin de commentaire

int ecart ; // l'ecart additif en degres

Veuillez revoir les exemples au début du chapitre.