Appendre le langage C : cours et applications sur les outils et bases de la programmation


Télécharger Appendre le langage C : cours et applications sur les outils et bases de la programmation

★★★★★★★★★★2.8 étoiles sur 5 basé sur 5 votes.
Votez ce document:

Télécharger aussi :


SOMMAIRE

1  Chapitre 1 - Qu’est-ce que la programmation ?

Qu’allez-vous apprendre dans ce cours cette année ?  7

1.1  Tout part du problème à résoudre....... 7

1.2  Le rôle de l’ingénieur..... 8

1.3  En résumé....... 8

2  Chapitre 2 - Programmation : Du problème à l’algorithme  9

2.1  Première étape : Analyse du cahier des charges....... 9

2.2  Deuxième étape : l’analyse du problème........ 9

2.2.1  Analyse chronologique... 9

2.2.2  Analyse descendante... 10

2.3  Troisième étape : Détermination des ressources – Notion de variable....... 10

2.4  Quatrième étape : l’algorithme, organigramme ou l’utilisation d’un pseudo langage......... 10

2.4.1  Conception..... 10

2.4.2  Avantages...... 11

2.4.3  Exemple : Calcul du PGCD par la méthode d’Euclide... 11

2.4.4  Organigramme......... 12

2.5  Cinquième étape : Test......... 13

2.6  Sixième étape : Programmation en langage dit « de haut niveau ».... 14

2.6.1  Edition d’un programme C..... 14

2.6.2  Relecture du code pour en vérifier la syntaxe... 14

2.6.3  Compilation ou Interprétation... 14

2.6.4  Vérification syntaxique......... 14

2.6.5  Création du fichier « objet » .obj........ 14

2.6.6  Création du fichier « exécutable » .exe : Edition des liens...... 15

2.6.7  Définition du protocole de test d’exécution..... 15

3  Chapitre 3 - Un peu de culture generale  17

3.1  Composition d’un ordinateur... 17

3.1.1  Extérieur : l’Unité Centrale et ses périphériques d’Entrée/Sortie (schéma)...... 17

3.1.2  Intérieur : Les constituants de l’Unité Centrale (schéma)....... 17

3.2  Rôle de l’ordinateur..... 18

3.2.1  Son fonctionnement.... 18

3.3  Le stockage des données : mémoire vive, mémoire morte et mémoire de masse... 19

3.3.1  Les données... 19

3.3.2  Les mémoires......... 19

3.3.3  Retour sur les variables......... 20

3.3.4  La FAT (File Allocation Table), le NTFS (NT File System)....... 20

3.3.5  Le Pourquoi du formatage...... 21

3.3.6  Le Pourquoi de la défragmentation..... 21

3.4  Les traitements des données : processeur.... 21

3.4.1  La notion de registre... 21

3.4.2  Les bus de données.... 21

3.4.3  L’ordonnancement des instructions..... 21

3.5  Le binaire ou la genèse d’une information...... 21

3.5.1  0 ou 1 : le courant passe t’il ?... 21

3.5.2  1 fil, 2 fils…n fils........ 21

3.6  Le codage/décodage de l’info : La Table d’Interprétation Sémantique - TIS... 22

3.7  Les programmes, les applications..... 22

4  Chapitre 4 - Le langage C – Premiers pas  23

4.1  Historique....... 23

4.2  Récapitulatif des étapes de programmation... 23

4.2.1  Analyse du problème (papier)......... 23

4.2.2  Détermination des ressources (papier)......... 23

4.2.3  Ecriture du code (pseudo langage algorithmique) et/ou de l’organigramme (papier)... 23

4.2.4  Traduction de l’algorithme en langage de haut niveau (VI, bloc‑note, logiciel dédié…). 23

4.2.5  Relecture (yeux ;-)...... 23

4.2.6  Simulation (papier)..... 23

4.2.7  Compilation du code et édition de liens (GCC, logiciel dédié…)........ 23

4.3  Composition d’un programme en C..... 24

4.3.1  Inclusion des bibliothèques de fonctions....... 24

4.3.2  Le corps du programme........ 24

4.4  Premier programme : « Bonjour le monde ! »......... 24

4.5  Les instructions......... 24

4.5.1  Instruction simple....... 24

4.5.2  Bloc d’instructions...... 25

4.6  Les commentaires...... 25

4.7  Un exemple sous Dev-C++..... 25

5  Chapitre 5 -  Les variables – Les types simples (ou scalaires)  27

5.1  Rôle et convention d’écriture... 27

5.2  Déclaration de variable......... 27

5.3  Le domaine de définition et la plage de valeurs........ 27

5.3.1  Les altérateurs de type : short, long, signed, unsigned......... 27

5.4  Les types scalaires de données : int, float, char , pointeur..... 28

5.4.1  Nombre entier (int)..... 28

5.4.2  Nombre à virgule (float)........ 29

5.4.3  Caractère (char)........ 29

5.4.4  Pointeurs  (int*, char*, float*, int*****,…)......... 30

5.5  Le lieu de déclaration et portée......... 30

5.5.1  Analyse d’un exemple......... 30

5.5.2  Notion de variable globale...... 30

5.6  Créer un type de donnée....... 31

5.7  Conversion de type de données........ 31

5.8  Les booléens VRAI et FAUX..... 32

5.9  Précisions sur les constantes......... 32

5.10 L’affectation..... 32

5.10.1  L’initialisation... 32

5.10.2  L’affectation des variables scalaires... 32

5.10.3  Les affectations cachées....... 33

6  Chapitre 6  -  Les entrées / sorties formatées  35

6.1.1  Printf (écrire, traitement de sortie)...... 35

6.1.2  Scanf (lire, traitement d’entrée)......... 35

6.1.3  Les formats..... 35

6.1.4  Les alignements....... 35

6.1.5  Les caractères spéciaux........ 36

7  Chapitre 7 - Calculs et comparaisons, Structures de controle  37

7.1  Les opérateurs mathématiques........ 37

7.2  Le CAST......... 37

7.3  Les opérateurs de comparaison....... 37

7.4  Les opérateurs logiques........ 37

7.4.1  Tables de vérité des opérateurs logiques....... 37

7.4.2  Priorité des opérateurs......... 38

7.5  Opérateurs binaires de traitement des bits.... 38

7.5.1  & (ET)... 38

7.5.2  | (OU)... 38

7.5.3  ^ (OU exclusif)......... 38

7.5.4  op1 << op2 (décalage binaire gauche de op1 un nombre de fois égal à op2)... 39

7.5.5  op1 >> op2  (décalage binaire droite de op1 un nombre de fois égal à op2)... 39

7.5.6  ~  (complément à 1 d’un opérande de type entier, inversion des bits)... 39

8  Chapitre 8 - Structures de controle  41

8.1  Les structures de contrôle..... 41

8.1.1  Les conditionnelles..... 41

8.1.2  Les répétitives......... 42

9  Chapitre 9 - Données de type complexe : Les tableaux  43

9.1  Les tableaux monodimensionnels...... 43

9.1.1  Accès... 43

9.1.2  Schéma de la représentation classique......... 44

9.2  Un pointeur caché dans un tableau monodimensionnel....... 45

9.2.1  Principe d’adressage... 45

9.3  Les tableaux multidimensionnels...... 45

9.3.1  Schéma de la représentation classique......... 45

9.3.2  Principe d’adressage... 46

9.3.3  46

9.3.4  Accès... 46

9.3.5  Simulation d’une matrice en tableau monodimensionnel...... 46

10  Chapitre 10  -  Données complexes : Les chaînes de caractères  47

10.1 Convention...... 47

10.2 Déclaration d’une chaîne....... 47

10.3 Saisie... 47

10.3.1  Plusieurs fonctions de saisie possibles......... 47

10.3.2  Problème d’espace mémoire... 48

10.4 Affichage à l’écran...... 48

10.5 Autres fonctions dédiées....... 48

10.5.1  Affectation...... 48

10.5.2  Concaténation......... 48

10.5.3  Comparaison... 48

10.5.4  Dimension...... 48

11  Chapitre 11 -  Les pointeurs  49

11.1 Définition........ 49



11.2 Initialisation..... 49

11.3 Adressage direct....... 49

11.4 Adressage indirect...... 49

11.5 Usage... 50

11.5.1  Opérateur unaire &..... 50

11.5.2  Déclaration des pointeurs...... 50

11.5.3  Opérateur unaire *...... 50

11.6 Les pointeurs pour le passage de paramètres par adresse à une fonction... 50

12  Chapitre 12 - Aléatoire et Evénementiel  51

12.1 Génération de nombres aléatoires..... 51

12.1.1  Inclusion des bibliothèques..... 51

12.1.2  Initialisation du générateur aléatoire... 51

12.1.3  Génération du nombre par la fonction RAND... 51

12.2 Programmation événementielle........ 52

13  Chapitre 13 -  Allocation dynamique de mémoire  53

13.1 Retour sur la déclaration statique de données......... 53

13.1.1  Variables scalaires..... 53

13.1.2  Tableaux....... 53

13.1.3  Chaînes de caractères constantes...... 53

13.1.4  Pointeurs....... 53

13.2 Problème et solution.... 54

13.3 Principe de l’allocation......... 54

13.3.1  La fonction malloc...... 54

13.3.2  La fonction sizeof...... 54

13.3.3  Cas du tableau monodimensionnel.... 55

13.3.4  Allocation dynamique d’un tableau multidimensionnel......... 55

13.3.5  Cas des chaînes de caractères......... 56

13.4 La fonction free......... 57

14  Chapitre  14 - Les sous-programmes en langage C  59

14.1 Utilité.... Erreur ! Signet non défini.

14.2 Visibilité des sous-programmes....... 59

14.2.1  Prototype d’un sous-programme....... 60

14.2.2  Déclaration en fichier bibliothèque .h... 60

14.3 Les procédures : Le type void... 60

14.4 Les fonctions : Le mécanisme de retour....... 61

14.5 Appel des sous-programmes... 62

14.6 Graphes d’appel......... 62

15  Chapitre  15 - Passage des paramètres  63

15.1 Le passage par valeur......... 63

15.2 Le passage par adresse........ 63

15.3 Cas particulier des tableaux... 64

15.4 Passage d’arguments à la fonction main : la ligne de commande..... 64

16  Chapitre  16  La récursivité  65

16.1 Définition........ 65

16.2 Utilité.... 65

16.3 Notion de clone......... 65

16.4 Condition d’arrêt........ 66

16.5 Procédure récursive... 66

16.6 Fonction récursive...... 66

17  Chapitre  17 -  Les structures et les unions  67

17.1 Les Structures......... 67

17.1.1  Déclaration de type structure... 67

17.1.2  Déclaration d'une variable de type structure.... 68

17.1.3  Les données membres d'une structure :  les champs... 68

17.1.4  Accès aux champs d’un objet structure......... 69

17.1.5  Accès aux champs d’un objet structure via un pointeur......... 70

17.1.6  Accès aux données membres de structure dans le cas de structures imbriquées...... 70

17.1.7  Opération sur les structures..... 71

17.1.8  Les tableaux de structures...... 71

17.1.9  La récursivité et les structures... 71

17.2 Les unions...... 72

18  Chapitre  18 -  Les fichiers  75

18.1 Fichier ASCII.... 75

18.1.1  Création et Ouverture d'un fichier....... 75

18.1.2  Lecture/Ecriture dans un fichier texte... 76

18.1.3  Fermeture d'un fichier... 76

18.1.4  Principe de manipulation des fichiers... 76

18.1.5  Le caractère de fin de fichier (EOF)..... 79

18.2 Fichiers binaires........ 79

19  Chapitre 19 -  Les liste chaînées, table de hachage, arbre, graphe 81

19.1 Les liste chaînées...... 81

19.1.1  Définition....... 81

19.1.2  Construction.... 81

19.1.3  Parcours....... 82

19.1.4  Ajout... 82

19.1.5  Liste doublement chaînée...... 82

19.1.6  Liste circulaire......... 82

19.1.7  Listes de listes......... 82

19.2 Les tables de hachage......... 83

19.3 Les arbres...... 83

19.4 Les graphes..... 83

20  ANNEXE A : Règles d’écriture des programmes en C  87

21  ANNEXE B : Les séquences d'échappement  89

22  ANNEXE C : Les priorités des opérateurs  89

23  ANNEXE D : Classification, conversion de caractère : <ctype.h>  90

24  ANNEXE E : Traitement de chaînes de caractères : <string.h>  91

25  ANNEXE F : Fonctions d'aide générales : <stdlib.h>  92

26  ANNEXE G : TABLE ASCII ET TABLE ASCII ETENDUE  94



1  Chapitre 1 -  Qu’est-ce que la programmation ? Qu’allez-vous apprendre dans ce cours cette année ?

Ce cours s’adresse à des étudiants n’ayant jamais pratiqué la programmation, mais ayant malgré tout déjà touché, voire « allumé » un ordinateur (quelle audace !) et désireux de comprendre comment cette diabolique machine peut-elle bien être devenue un outil indispensable dans notre vie de tous les jours alors que nos grands parents n’en ont peut-être jamais utilisé un et n’en auront surement jamais le besoin.

Aujourd’hui vous utilisez l’ordinateur presque par réflexe, habitué à ce qu’il ait réponse à (quasi) tout !

Mais comment donc est-ce possible que cette boîte sache tout faire ? Qu’elle regorge d’autant de connaissances, d’informations ?

La réponse à cette question c’est l’Homme, dont l’intelligence inégalée (euh oui, le robot qui surpasse l’homme ce n’est pas encore pour tout de suite, c’est encore de la science-fiction, surtout si on respecte les 3 lois d’Isaac Asimov).

L’Homme donc, qui sait comment stocker cette formidable quantité d’informations dans ces boites et comment les traiter ensuite pour apporter des réponses à la plupart des problématiques (certaines résistent encore…)

[Le lecteur habile et perspicace aura noté que certains mots sont en gras. En effet, dès cette simple introduction, j’introduis un vocabulaire intrinsèque à cet enseignement et indispensable à sa bonne compréhension. Si vous n’en retenez qu’un peu, retenez le gras ;-) ]

Mais revenons à l’Homme, dont l’intelligence n’est plus à prouver (même si on peut parfois en douter) et qui très modestement place cette intelligence à un haut-niveau dans une hypothétique hiérarchie dont le bas-niveau serait la fameuse boîte et ses composants électroniques barbares.

Tout ca pour vous dire que si vous souhaitez devenir programmeur, ou simplement avoir goûté succinctement à la programmation dans une formation d’ingénieur beaucoup plus ambitieuse qui vous emportera vers des sommets, eh bien il vous faudra être capable de relier le bas-niveau au haut-niveau.

1.1  Tout part du problème à résoudre

Commençons donc par se placer au haut-niveau, celui de l’intelligence. Vous allez voir, ce n’est pas si simple que ça.

Le haut-niveau, c’est le niveau où le problème à résoudre est exprimé dans un bon vieux langage oral, prenons le français par exemple (ça facilitera un peu). Imaginez donc : Vous êtes déjà ingénieur (5 ans, ça passe vite) et à ce titre vous utilisez votre savoir pour résoudre le problème d’un « client ».

Ce bon client vous exprime sa problématique dans son langage à lui. Ca donne quelque chose comme ça : « Je travaille à la FNAC et je voudrais que vous me trouviez une solution pour vendre des billets de spectacle depuis des magasins FNAC dans la France entière… » ou encore « J’ai 1500 avions qui se posent à Roissy Carles De Gaulle chaque jour, comment organiser au mieux les atterrissages ? »

Quelques conclusions immédiates :

o  Il n’est pas informaticien

o  Il n’a pas tout dit, et vous avez toutes les chances qu’il vous appelle dans quelques jours pour vous faire, à la « Colombo », « Ah au fait, j’oubliais de vous dire…. »



o  Rien ne prouve que ce que vous lui proposerez, après des mois de travail, lui convienne

1.2  Le rôle de l’ingénieur

Votre rôle, c’est de démêler ce sac de nœuds et de proposer une solution efficace à votre client.

Proposer une solution, ca ne veut pas forcément dire « développer » une solution originale de A à Z. Ca veut dire exploiter ses connaissances personnelles du domaine concerné, exploiter l’expérience acquise au fil des années d’activité et de ses propres centres d’intérêt et mettre en place une communication efficace avec le client pour ne pas faire fausse route dans ses choix. Sans oublier les fameux tests réguliers que tout débutant minimise systématiquement, commettant ici sa plus grande erreur ! (mais ne faut-il pas « toucher » pour vérifier que c’est chaud, même si on était prévenu ? ;-)

 Des connaissances personnelles vous en avez peut-être. De l’expérience acquise, vous allez en accumuler tout au long de cette formation. Des erreurs, vous allez en faire beaucoup (j’espère !) et vous devriez être capable d’en apprendre beaucoup de choses. Vos choix, il faudra les justifier. Il vous faudra être « ingénieux » et choisir au mieux vos traitements et vos tests.

Vous aurez besoin de maîtriser le haut-niveau, celui de l’intelligence, celui du langage oral, celui du client qui parle en français sans avoir les idées toujours claires ; et vous aurez besoin de maîtriser le bas niveau, celui de l’ordinateur, celui de l’électronique et des contraintes du binaire (en attendant de passer au quantique un jour, mais ne retombons pas dans la science-fiction). Et bien évidemment, vous aurez besoin de maîtriser toute la chaîne entre les deux, qui passe par l’analyse détaillée de la problématique (chronologique et descendante), l’élaboration du cahier des charges lorsqu’il n’est pas fourni, la rédaction des algorithmes ou organigrammes, le codage dans un langage approprié (le C ?) choisi pour ses performances et son efficacité dans la gestion des contraintes du bas niveau (optimisation), la compilation de ce code, l’exécution des tests intermédiaires et finaux, la validation de la solution finale (recette)… Ouf !!

Et tout ca en collaboration étroite avec le client, quel qu’il soit, pour optimiser le temps de développement.

1.3  En résumé

Voilà ! Un petit aperçu du contenu de cette première année d’étude. L’acquisition de tout ça ne sera pas forcément simple, vous aurez des difficultés mais on ne vous en voudra pas pour ca. C’est normal.

Ce qui ne l’est pas, en tous cas pour un ingénieur qui se respecte, c’est de ne pas chercher à dépasser ses difficultés. Et pour cela, beaucoup de solutions vous sont proposées à l’école : Camarades, association tutorat, soutien et professeurs à votre écoute et disposition.

Utilisez-les !!! On vous reprocherait de ne pas le faire et de vous laisser glisser, reflet de la mauvaise attitude que vous pourriez avoir face aux difficultés du monde professionnel.

2  Chapitre 2 -  Programmation : Du problème àu resultat en passant par l’algorithme

Commençons par nous occuper du haut niveau.

L’idée c’est d’essayer de comprendre les attentes du client ou de décortiquer un cahier des charges lorsqu’il est fourni.

Comment instaurer un dialogue avec le client afin d’obtenir des précisions sur tous les points obscurs ? Dans quelle mesure sommes-nous libre de faire des choix lorsque le client n’a pas de précision à apporter ? Comment justifier ces choix ? Quels sont les bons critères de choix ? Comment organiser notre propre pensée ? Comment définir notre méthode ?

Autant de questions auxquelles nous allons essayer d’apporter une réponse.

2.1  Première étape : Analyse du cahier des charges

Le cahier des charges est un document « contractuel » qui vous lie à votre client. Il précise les attentes de ce dernier et vous fourni un cadre d’exécution.

Rien de ce qui n’est écrit au cahier des charges ne peut vous être exigé et tout manquement à ce qui y figure en termes de respect des contenus et des délais peut entraîner des pénalités (en euros, centaines d’euros, voire millier d’euros dans la vie professionnelle ; en terme de points sur 20 à l’école&nbsp;;-).

Armez-vous d’un surligneur et lisez attentivement le cahier des charges. Si vous dialoguez avec le client, prenez un papier et un stylo.

Identifiez les noms

Les noms représentent la plupart du temps les données, les informations à manipuler. Ces données devant être stockées en mémoire, les identifier permet d’évaluer les ressources mémoire nécessaires à votre programme.

Identifiez les verbes

Les verbes correspondent aux actions, aux traitements à réaliser. Ces traitements étant réalisés par le processeur, les identifier permet d’évaluer la charge processeur et donc le temps d’exécution de votre programme.

L’objectif final est d’identifier :

  • Les données
  • Les traitements
  • Les résultats à fournir

Place mémoire et charge processeur (temps d’exécution) sont les 2 paramètres permettant de déterminer l’efficacité de votre solution.

2.2  Deuxième étape : l’analyse du problème

2.2.1  Analyse chronologique 

Maintenant que vous avez identifié l’ensemble des traitements à exécuter, il est important d’y mettre de l’ordre. En effet, rien ne dit qu’à la rédaction du cahier des charges ou lors du dialogue avec le client, les idées soient arrivées dans un ordre logique.

L’analyse chronologique consiste à définir la succession logique des étapes à réaliser pour résoudre le problème.

2.2.2  Analyse descendante 

Après avoir mis les différentes étapes de traitement dans l’ordre, il peut s’avérer nécessaire de décomposer le problème associé à chaque étape en sous problèmes jusqu’à atteindre des taches élémentaires en se mettant à la place de l’utilisateur.

Par exemple, « chercher le maximum d’une suite de valeurs » peut se décomposer en :

  • Obtenir les valeurs
  • Comparer la première à la deuxième et conserver la plus grande
  • Comparer la valeur trouvée précédemment à la 3ème et conserver la plus grande
  • Répéter l’opération jusqu’à avoir comparé toutes les valeurs.
  • Annoncer la plus grande valeur trouvée

 

Pas mal ! Mais…comment obtenez-vous les valeurs ??? Pouvez-vous préciser ?

Autre exemple : Calcul du PGCD par la méthode d’Euclide

Obtenir A et B

Calculer la val. abs. de la différence entre A et B

Remplacer le plus grand de A et B par cette différence

Répéter jusqu’à ce que A=B

Afficher résultat

  A  B

  24  9

15

  15  9…

  6  3

  3  3

2.3  Troisième étape : Détermination des ressources – Notion de variable

La « ressource » cache une notion de coût. Coût mémoire, coût processeur, coût en temps, coût en place…



Dans ce cours, nous parlerons de ressource lorsqu’il s’agira de place mémoire pour stocker une information. Afin de définir la taille de la zone mémoire nécessaire au stockage de cette information (ainsi que le principe de codage et décodage, nous y reviendrons) il faut réserver une variable de stockage.

 La notion de variable : une variable est une ressource matérielle permettant de stocker une information. Cette ressource, prise dans les barrettes mémoire, doit être dimensionnée et typée.

2.4  Quatrième étape : l’algorithme, organigramme ou l’utilisation d’un pseudo langage.

Un algorithme correspond à l’élaboration, dans un pseudo langage proche du langage humain, d’une succession d’actions permettant de mener à bien un objectif donné.

2.4.1  Conception 

o  Reprendre une à une les taches élémentaires issues de l’analyse descendante et écrire la succession d’instruction à faire exécuter par la machine pour réaliser chaque tache.

o  commenter l’algorithme pour le rendre compréhensible,

o  respecter une présentation rigoureuse (syntaxe et indentation) et  choisir des noms significatifs aux variables lors des définitions des zones de stockage des données  (voir les annexes pour les règles d’écriture).

2.4.2  Avantages 

Le pseudo code obtenu est indépendant du langage d’implémentation final. La réalisation du programme ne sera plus qu’une étape de traduction.

2.4.3  Exemple : Calcul du PGCD par la méthode d’Euclide

Algorithme PGCD-Euclide

DEBUT

// declaration des variables

Variables  A, B, Diff  : entiers

// obtention des valeurs A et B

Ecrire(²entrez la valeur de A²)

Lire(A)

Ecrire(²entrez la valeur de B²)

Lire(B)

// boucle de traitement

Tant que (A<>B) faire

  Début

  Diff ← Abs(A – B) 

  Si (A>B) alors   A ←Diff

  Sinon   B ←Diff

  Fin

// Affichage du resultat

Ecrire(²Le PGCD est ²,A)

FIN

2.4.4  Organigramme

Établir l'organigramme, c'est traduire l'algorithme en une forme possédant sept sens :

tout d'abord la notion de début de traitement

puis celle d'introduction de donnée,

de traitement unitaire interne,

d'alternative qui, suivant le résultat du test, traitera l'information suivant une voie ou l'autre,

de répétitive, ou boucle, qui répétera, un certain nombre contrôlé de fois, une suite d'instructions (qui seront écrites dans le rectangle ci-contre).
Le contrôle du nombre de fois que sera exécutée la boucle se fait par un élément qui devra apparaître, une fois, avant d'entrer dans la boîte, et en fin de boite.

de sortie de résultat,

puis, enfin, de fin de traitement.

 


Exemple du PGCD

 

Tout algorithme, aussi compliqué soit-il, peut se traduire à l'aide de ces sept sens. C'est dire toute l'importance de cette formalisation.

Après l’étape de test de la solution proposée, il reste à en faire une traduction dans un langage de programmation spécifique choisi. Cette traduction est en fait l'interface entre votre algorithme ou votre organigramme et un programme (appelé interpréteur ou compilateur) implanté dans un PC ou une calculette programmable. Ce programme implanté dans votre "machine" traduira, lui aussi, en langage "machine" vos instructions pour qu'elles soient exécutées.

2.5  Cinquième étape : Test

Faire tourner le programme à la main pour en vérifier l’efficacité

A  B  Diff

 24  9  15

15  9  6

 6  3  3

3  3 

2.6  Sixième étape : Programmation en langage dit « de haut niveau »

Transcription du pseudo code dans un langage choisi pour ses spécificités, en respectant la syntaxe associée.

2.6.1  Edition d’un programme C

(Editer un programme veut dire « écrire » un programme, par référence aux éditeurs de texte bloc‑note, word, VI…)

2.6.1.1  Les bibliothèques

Le fonctionnement du pré-compilateur. (bibliothèque personnelle obligatoire !!!)

2.6.1.2  Décomposition du corps en fonctions thématiques

2.6.1.3  Le programme dit « principal »

#include “mabib.h”

int main()

{

  // declaration des variables

  int a,b,diff ;

 

  // obtention des 2 valeurs

  printf(²entrez la valeur de A²) ;

  scanf(²%d²,&a) ;

  printf(²entrez la valeur de B²) ;

  scanf(²%d²,&b) ;

  // boucle de calcul du pgcd

  while (a != b)

  {

   diff = abs(a – b) ;

   if (a>b) a = diff ;

   else b = diff ;

  }

  // affichage du resultat

  printf(²Le PGCD est %d\n²,a) ;

  return 0 ;

}

2.6.2  Relecture du code pour en vérifier la syntaxe

Attention aux « ; », au « = » (pour l’affectation) et au « == » (pour l’égalité).

2.6.3  Compilation ou Interprétation

2.6.4  Vérification syntaxique

2.6.5  Création du fichier « objet » .obj

  • Compilation séparée.


3198