Programmation procédurale

Transcription

1 IUT IUT A Lyon 1 Informatique Programmation procédurale du du C-ANSI C au au C++ C++ ~ A. A. P. P. ~ Année Année ~2004 ~2004 U C L B Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 0

2 Programmation procédurale - du C-ANSI au C++ Chapitre 1 Eléments du langage C-ANSI page 1 Chapitre 2 Les types construits page 23 Chapitre 3 Les fonctions page 43 Chapitre 4 Les fichiers page 51 Chapitre 5 Compléments page 63 Chapitre 6 Les programmes multi-fichiers page 69 Chapitre 7 Du C-ANSI au C++ en programmation procédurale page 83 Annexe A La bibliothèque standard page 93 Annexe B Squelette d'un programme en langage C page 115 Annexe C Table ASCII page 117 Annexe D Bibliographie succincte page 119 Avertissement: Le présent document constitue le support papier du cours de programmation du premier semestre de première année. L'auteur n'autorise pas son utilisation ou sa diffusion en dehors du Département Informatique de l'iut-a de l'université Lyon-I. Merci de signaler les erreurs ou fautes constatées. Bonne lecture. A. P. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 1

3 CHAPITRE 1 - ELEMENTS DE BASE DU LANGAGE C-ANSI 1 Introduction: Ce polycopié s adresse aux étudiants en première année du département Informatique de l IUT-A de l Université LYON-I. Il a pour but de présenter les éléments du langage C dans l environnement système Unix, mais n a pas pour vocation d être un cours sur les concepts et méthodes de programmation. Il existe à ce propos, d autres documents au département auxquels il faut se référer. Il en est de même pour le développement de programme C ou C++ avec l'outil Visual Studio. Le lecteur trouvera en annexe une bibliographie indicative, sachant que le manuel qui fait autorité reste l ouvrage de KERNIGHAN et RITCHIE intitulé " C-ANSI " publié aux éditions MASSON. En particulier sont évoqués dans l ouvrage cité, l historique et les évolutions du langage C. 2 L organisation d un programme C : Le langage C est dédié à la programmation procédurale. Un programme est un ensemble de séquences d opérations sur des structures de données qui se déroulent suivant un schéma établi par un algorithme. La philosophie de la programmation procédurale est de décomposer et de structurer un programme pour faciliter sa construction et sa maintenance. Les niveaux de décomposition en C sont dans l ordre hiérarchique décroissant: le module : c est un fichier texte comprenant la définition de fonctions la fonction : c est un ensemble de blocs le bloc : c'est un ensemble d'instructions; un bloc est délimité par les caractères { et } l'instruction: une instruction est une structure de contrôle ou une expression; une expression se termine par la caractère; La décomposition dépend de la complexité du problème à traiter. Ainsi suivant le cas, un programme peut être obtenu à partir : d un seul module qui ne comprend qu une seule fonction (cas rare) d un seul module comprenant plusieurs fonctions de plusieurs modules comprenant eux-mêmes une ou plusieurs fonctions. Parmi l ensemble des fonctions qui constituent un programme, il en existe une particulière qui constitue le point d entrée du programme et qui s appelle main(). Il ne doit y avoir qu une seule fonction main() par programme, même s'il est composé de plusieurs modules. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 2

4 3 Production d un exécutable : Un programme exécutable est donc le résultat de la compilation et de l édition des liens entre modules. La compilation donne à partir d un fichier texte appelé source un module objet. L édition des liens est la phase qui permet à partir de plusieurs modules objets créés par l utilisateur ou déjà existants dans une bibliothèque, d obtenir un exécutable. On obtient dans l'environnement Unix donc le schéma de production suivant : Fichier source Fichier texte: le nom du fichier comprend l extension.c Compilation Phase de traduction par le compilateur Fichier objet Fichier objet : le nom est identique au fichier source mais l extension est maintenant.o Autre fichier objet Bibliothèque de fichiers objects Edition des liens Fichier exécutable Fichier exécutable d extension.e Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 3

5 Afin de faciliter la phase de compilation pour les premiers TP qui ne nécessitent pas la réalisation de plusieurs modules, il existe au département, une procédure de compilation appelée ccomp. Pour invoquer cette procédure il suffit de passer la commande : ccomp tp1.c Cette procédure génère soit un fichier exécutable d extension.e (tp1.e dans l exemple), soit un fichier des erreurs d extension.err (tp1.err ici). La compilation séparée de plusieurs modules en vue de l obtention d un exécutable est abordée au chapitre 6 du présent document. 4 Structure d un fichier texte C : Nous ne nous intéressons dans un premier temps qu aux programmes C ne comprenant qu un seul module texte; les principes de la programmation modulaire sont décrits au chapitre 6. Dans cette optique, le niveau de décomposition d'un programme est alors la fonction avec une fonction particulière appelée main(). Une fonction est paramètrable de sorte que le traitement qu elle effectue soit généralisable. La fonction main() n échappe pas à cette règle, mais dans un premier temps, on considérera qu il s agit d une fonction particulière qui ne reçoit aucun argument et qui ne retourne rien. Un programme constitué à partir d un seul module comprend donc : Des définitions générales La fonction main fonction 1 fonction 2 Exemple : Soit le programme qui souhaite la bienvenue aux nouveaux étudiants : #include <stdio.h> char pnom[25] ; void main(void) { printf("\n Entrez votre prenom : " ) ; scanf("%s",pnom) ; printf("\n\n Bienvenue a l IUT %s",pnom) ; } Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 4

6 Ce programme amène plusieurs remarques : 1. même un programme très simple invoque des fonctions qui ont déjà été écrites et qui sont archivées en tant que modules objet dans une bibliothèque. Ici les fonctions d entrée-sortie scanf et printf sont des fonctions de la bibliothèque standard fournie avec le compilateur C. 2.pour utiliser des fonctions de la bibliothèque standard, il faut annoncer le type de paramètres qu elles attendent et le type de valeur retournée s il y en a. Cette annonce est réalisée par un prototype de la fonction qui indique ces renseignements. C est le rôle de la directive #include d inclure les fichiers où se trouvent les prototypes des fonctions de la bibliothèque qui vont être utilisées. 3.la directive #include n est pas destinée au compilateur, mais au préprocesseur. Le préprocesseur effectue une analyse du texte source avant le compilateur et effectue l inclusion du texte indiqué chaque fois qu il rencontre cette directive. Ici on inclut un texte appelé <stdio.h>. Ce fichier est appelé un fichier d en-tête (ou headers d ou le.h). Tous les headers se trouvent sous le répertoire /usr/include/ ou dans /usr/local/include. Il s agit donc de fichiers texte contenant des définitions et des prototypes de fonctions. 4. pour indiquer qu une fonction ne reçoit pas d argument, on met (void) après son identificateur. Pour indiquer qu elle ne retourne rien on met void devant son identificateur. 5 Eléments du langage C : 5-1 Identificateurs, symboles, mots réservés : Un identificateur est un nom donné à une variable, une constante ou une fonction. Il est défini par le programmeur, et peut être constitué à partir de lettres (minuscules et majuscules étant différentes), du caractère de soulignement _ et de chiffres. Cependant un identificateur ne doit pas commencer par un chiffre. Les implémentations récentes du C-ANSI admettent des identificateurs pouvant aller jusqu'à 31 caractères. Les symboles sont des caractères ou groupe de caractères utilisés principalement pour représenter des opérateurs ou des caractère spéciaux. & ~ " # { } ( ) [ ] \ / * - + %, ;. < > =!? Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 5

7 Les mots réservés sont des identificateurs servant de mots-clés au langage C. auto break case char const continue default do double else enum extern float for goto if int long register return short sizeof static struct switch typedef union unsigned void volatile while Les commentaires dans un programme C commencent par la séquence /* et se terminent par la séquence */ quel que soit le nombre de lignes entre les deux. On ne peut pas inclure un commentaire dans un commentaire. 5-2 Les objets manipulés : Un objet au sens de la programmation procédurale est caractérisé par : 1) un identificateur 2) un type qui impose : une représentation interne des opérateurs associés 3) une valeur variable ou constante a) Les types de base : type char : codé sur un octet et considéré comme un entier sur 8 bits signés ou non (unsigned); un caractère est représenté par le code ASCII donné en annexe type int : entier en représentation interne en complément à 2; ils sont signés ou non signés(unsigned). On distingue : short :codés sur 2 octets long :codés sur 4 octets int :codés sur 2 ou 4 octets suivant la machine cible type float : nombre réel en représentation interne suivant la norme IEEE 754. On distingue : float : simple précision codé sur 4 octets double : double précision codés sur 8 octets Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 6

8 b) Mécanisme de construction de type : En dehors des types de base, il existe également le type tableau, le type structure, le type union, et le type pointeur. Ces types sont étudiés au chapitre 2. Enfin le langage C offre la possibilité au programmeur de construire lui-même ses propres types grâce à la directive typedef. Il s'agit en fait de renommer un type existant (soit un type de base soit un type construit) afin d'en améliorer la compréhension suivant le contexte. La syntaxe pour définir un type nouveau est la suivante: typedef type Nouveautype; Exemple: typedef int Age; /* Age est maintenant un type nouveau */ Age anciennete; /* anciennete est une variable de type Age */ c) Les constantes : constantes entières : on les exprime généralement en décimal ou en hexadécimal précédées alors de 0x.Une constante correspondant à un entier long est suffixée par la lettre L Exemple : 127 constante en base 10 0x7F constante en base L constante entier long en base constante entier long en base 8 constantes réelles : on les exprime soit avec une partie fractionnaire, soit sous forme mantisse plus exposant Exemple : 25.8 forme fractionnaire 1.03e-2 forme avec exposant constantes chaînes : en C, il n existe pas de type primitif chaîne. Une chaîne est traitée comme une suite d octets se terminant par le caractère '\0' (octet au 0 binaire). On peut définir une constante chaîne de caractères en donnant sa valeur encadrée par les caractères spéciaux " "; il s agira d une suite d octets terminée par '\0'. On peut aussi utiliser le mécanisme de substitution de texte offert par le préprocesseur, mais il ne s agira alors que de définir des constantes symboliques qui ne pourront pas être utilisées en tant que chaîne constante. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 7

9 Exemple : "ceci est un message" chaîne constante terminée par '\0' #define TAILLE 10 substitution dans le texte de TAILLE par 10 constantes caractère : une constante caractère est de type entier mais codée sur un octet. Le codage peut se faire de plusieurs façons: on écrit le caractère entre apostrophes on code le caractère en donnant la valeur décimal de con code ASCII on code le caractère sous la forme '\ooo' ou la séquence ooo est la représentation en base 8 du code ASCII du caractère à coder on code le caractère sous la forme '\xhhh' où la séquence hhh est la représentation en base 16 du code ASCII du caractère à coder Exemple : c='a' c est le caractère A c=65 idem mais on donne le code ASCII de A en décimal c='\101' code ASCII de A est en octal c='\x41' code ASCII de A est en hexadécimal Il existe également des caractères spéciaux permettant de coder des caractères courants. Ces caractères sont notés sous la forme '\lettre'. On donne ici les caractères spéciaux les plus usuels. '\b' caractère backspace (retour arrière) '\n' caractère saut de ligne (new line) '\t' caractère de tabulation horizontale '\\' caractère \ d) Les variables : On définit une variable en précisant son type et son identificateur. On ne peut pas utiliser une variable non définie. Il est possible en langage C d initialiser une variable au moment de sa définition. Exemple: int x=3; /* definition de la variable x comme entier initialisé à la valeur 3 */ Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 8

10 Les termes de déclaration et de définition sont souvent confondus. Ils ne sont pourtant pas porteur du même sens. Une définition implique une allocation mémoire, celle ci étant faite au moment de la traduction du source, alors qu'une déclaration ne constitue que l'association d'un identificateur à un type. Il n'y a pas alors de réservation mémoire; nous verrons ainsi qu'un objet peut être déclaré plusieurs fois dans le cas de la programmation modulaire, alors qu'il ne doit être défini qu'une seule fois. La définition d'un objet implique également des règles de visibilité (c'est à dire où cet objet peut être atteint). Les règles de portée des variables sont étudiées au chapitre 3. Le C-ANSI permet de préciser au moment de la définition d'un objet que ce dernier ne devra pas être modifié. On utilise pour cela le qualificatif const. Etant donné que l'objet ne pourra plus être modifié par la suite, il doit donc être initialisé au moment de sa définition. Exemple: const int x=3; 5-3 Les opérateurs : Les opérateurs permettent de construire des expressions. Ils spécifient les calculs à effectuer sur leurs arguments appelés opérandes qui sont soit des objets (variables ou constantes) soit des sous-expressions. a) Les expressions : Une expression est construite à partir d'opérandes ou d'expressions, reliés par un opérateur. Un opérateur ne peut s'appliquer que sur un certain type d'opérande. En conséquence une expression a elle même un type résultant suivant les types des opérandes et de l'opérateur qui la composent et en fonction de certaines conversions étudiées plus loin. Exemples: l'expression x + y est constitué de l'opérateur + et des opérandes x et y qui peuvent être de type int ou float. Le résultat est de type int si x et y sont de type int; il est de type float si x et/ou y sont de type float. l'expression x + (y*z) est constituée de l'opérande x et de la sous-expression (y*z). Le type du résultat est soit int soit float suivant le type des opérandes. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 9

11 b) Les opérateurs arithmétiques : Il y a quatre opérateurs arithmétiques de base applicables sur des opérandes de type entier ou réel; le type char étant considéré comme un entier on pourra donc lui appliquer également les opérateurs arithmétiques. Outre ces opérateurs de base, on dispose pour les entiers uniquement, de l'opérateur modulo qui représente le reste de la division entière. + addition - soustraction * multiplication / division % modulo (sur les entiers uniquement) Le résultat (sauf pour le modulo) est fonction du type des opérandes. Si l'un des deux opérandes est de type réel, le résultat de l'expression devient réel. Au moment de l'affectation de l'expression, des règles de conversion sont mises en œuvre; ces règles sont étudiées plus loin. Exemple: Supposons la variable définie de la sorte: int i=5; Dans ces conditions l'expression i/3 donne 1; en effet le résultat de l'expression est entier car les 2 opérandes sont entiers. En revanche l'expression i/3.0 donne ; le résultat de l'expression est réel car un des 2 opérandes est réel. c) Les opérateurs d'incrémentation : Pour les types entiers et réels, le C propose des opérateurs d'incrémentation et de décrémentation. Ces opérateurs sont notés: ++ incrémentation -- décrémentation Suivant l'écriture, il s'agit de pré-incrémentation ou de post-incrémentation ; de même pour la décrémentation. Exemples: considérons les définitions suivantes (on suit dans l'ordre l'évolution des variables): int i=1; int j, k, l, m; j=++i; incrémente i de 1 (pré-incrémentation) puis affecte i à j; donc i vaut 2 et j vaut 2 Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 10

12 k=i++; affecte i à k puis incrémente i de 1 (post-incrémentation); donc k vaut 2 et i vaut 3 l=--i; décrémente i de 1 (pré-décrémentation) puis affecte i à l; donc i vaut 2 et l vaut 2 m=i--; affecte i à m puis décrémente i de 1 (post-décrémentation); donc m vaut 2 et i vaut 1 i++; incrémente i de 1 j--; décrémente j de 1 d) Les opérateurs de traitement de bits : Ces opérateurs s'appliquent uniquement à des opérandes de type entier, et sont utiles pour intervenir directement sur le contenu en mémoire d'une variable. Il s'agit des opérateurs suivants: ~ opérateur unaire de complémentation << opérateur de décalage à gauche >> opérateur de décalage à droite & opérateur ET bit à bit opérateur OU inclusif bit à bit ^ opérateur OU exclusif bit à bit Exemples: On considère les objets de type entier i et j, et le caractère c: i=i<<3; j=~i; c=c&0x0f; décale i de 3 positions binaires à gauche affecte à j le complément de i applique un ET logique bit à bit entre l'octet et l'octet c (masque les 4 bits de poids fort de c) e) Les opérateurs relationnels : Il s'agit des opérateurs de comparaison qui s'appliquent sur des opérandes de type entier ou réel. Le résultat de l'expression est faux (=0) ou vrai ( 0). Cependant en langage C, il n'existe pas de type booléen de base. Aussi le résultat d'une expression est codé par un entier. Cet entier vaut 0 si le résultat de l'expression est considéré comme faux; toute autre valeur est interprétée comme donnant un résultat vrai. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 11

13 == égalité (attention aux deux signes =)!= différence > >= < <= f) Les opérateurs logiques : Les opérateurs logiques permettent de construire une expression logique à partir d'opérandes eux-mêmes logiques. Ce sont:! opérateur unaire de négation (ne prend qu'un seul opérande) && opérateur ET logique (renvoie 0 si un des deux opérandes vaut 0) opérateur OU logique (renvoie 0 si les deux opérandes valent 0) g) Opérateur d'affectation : Il s'agit d'un opérateur qui copie le résultat de l'expression à droite dans la variable désignée à gauche de l'opérateur. L'opérateur est désigné par le caractère =. identicateur_objet=expression; Le langage C allège l'écriture de l'affectation lorsque l'expression de droite porte elle même sur la variable affectée à gauche, ceci grâce à des opérateurs d'affectation de la forme op= où op est un des opérateurs arithmétiques ou un des opérateurs de traitement de bits sauf bien sûr l'opérateur unaire de complémentation ~. Exemple: x+=2; x*=y; est équivalent à x=x+2; est équivalent à x=x*y; Remarques: 1) L'opérateur d'affectation ne peut être utilisé qu'avec les types de base. Le C-ANSI a généralisé cet opérateur aux structures et aux unions, mais on ne peut pas l'utiliser avec les tableaux. 2) Attention à ne pas confondre l'opérateur d'affectation = avec l'opérateur logique de comparaison ==. Ceci peut donner lieu à des résultats surprenants lors des évaluations d'expression; ainsi l'expression c=3 donne comme résultat vrai quelle que soit la valeur de c, alors que le résultat de l'expression c==3 dépend effectivement de la valeur de c. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 12

14 h) Autres opérateurs : l'opérateur sizeof L'opérateur sizeof permet de récupérer sous forme d'entier la taille mémoire en nombre d'octets nécessaire pour représenter un objet ou un type donné. La syntaxe est la suivante: sizeof(objet ou type) l'opérateur?: L'opérateur?: est un opérateur ternaire qui permet de constituer une expression conditionnelle simple. La syntaxe est la suivante: expression1? expression2 : expression3 L'évaluation s'effectue de la sorte: si expression1 est vraie (résultat non nul) alors c'est expression 2 qui fournit le résultat de l'expression, sinon c'est expression3. Ceci est illustré par l'exemple suivant : valabs = (x >= 0)? x : -x; i) Priorité des opérateurs : Le tableau ci-après donne la priorité des opérateurs du plus prioritaire au moins prioritaire, avec pour un même niveau de priorité l'ordre d'évaluation (l'associativité) de gauche à droite ou de droite à gauche. Opérateur Associativité Arité () [] ->. de G à D 2! ~ (type) * & sizeof de D à G 1 * / % de G à D de G à D 2 << >> de G à D 2 < <= > >= de G à D 2 ==!= de G à D 2 & de G à D 2 ^ de G à D 2 de G à D 2 && de G à D 2 de G à D 2?: de D à G 3 = += -= *= /= %= >>= <<= &= ^= = de D à G 2, de G à D 2 Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 13

15 j) Règles de conversion : Des conversions peuvent être mises en œuvre par le compilateur lors: de l'évaluation des expressions des affectations du passage de paramètres à une fonction du retour de l'appel d'une fonction Les conversions appliquées sont soit des conversions implicites automatiquement appliquées, soit des conversions explicites demandées par le programmeur. conversions implicites Les conversions automatiques transforment la représentation interne d'un opérande en une représentation plus large. Les règles appliquées sont les règles dites de promotion numérique: char short int long unsigned char unsigned short unsigned int int float double Pour les calculs, on applique les règles de promotion en fonction du type des deux opérandes: si l'un est de type long, l'autre est converti en long si l'un est de type unsigned l'autre est converti en unsigned si l'un est de type float l'autre est converti en float si l'un est de type double l'autre est converti en double dans tous les autres cas, les deux opérandes sont convertis en int conversions explicites Le programmeur peut demander explicitement une conversion de type à l'aide d'un opérateur de conversion appelé cast operator ou opérateur de coercition de type. La syntaxe de cette demande de conversion est très simple, elle s'exprime de la sorte: (type) expression où type représente le type dans lequel l'expression doit être convertie. 5-4 Les structures de contrôle : Les structures de contrôle servent à traduire soit un schéma alternatif soit un schéma répétitif. le test if a) Les structures alternatives : Il s'agit de la traduction du schéma si (condition) alors...sinon...finsi. La syntaxe en langage C est de la forme: Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 14

16 if (<expression_logique>) <bloc1> else <bloc2> Un bloc est délimité par les caractères { et }; il comprend des instructions terminée par la caractère ; la partie else étant facultative. Lorsque le bloc ne comprend qu'une seule instruction ou bien qu'il est constitué d'une structure de contrôle imbriquée, les délimiteurs { et } du bloc sont facultatifs. Attention: Ceci peut être source d'ambiguïté; en effet lorsqu'un bloc n'est pas explicitement délimité, le compilateur associe un else au dernier if. Pour lever toute ambiguïté, il faut recourir à l'usage des délimiteurs de blocs { et }. Ainsi dans l'exemple suivant, le else est rattaché au dernier if. if (<expression_logique_1>) if (<expression_logique_2>)...; else { /* sinon de expression_logique_2 */...;...; } D'autre part si pour une raison quelconque, on doit rajouter par la suite une instruction dans le bloc du premier if, il faut alors penser à mettre un délimiteur de bloc, sinon l'instruction rajoutée termine le if et le comportement du programme n'est pas du tout celui attendu. Pour toutes ces raisons, il est donc conseillé de recourir systématiquement aux délimiteurs de blocs. L'exemple précédent doit être écrit de la sorte: Remarque: if (<expression_logique_1>) { if (<expression_logique_2>) {...; } else {...;...; } } Les instructions placées à l'intérieur d'un bloc sont décalées pour améliorer la lisibilité; on parle d'indentation. En ce qui concerne les ouvertures et fermetures de blocs, le style d'écriture retenu ici est celui préconisé par KERNIGHAN & RITCHIE, mais d'autres styles peuvent être utilisés. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 15

17 le choix multiple switch Cette instruction évite le recours à un enchaînement de si alors sinon si en cascade. Elle permet de tester la valeur d'une expression entière uniquement parmi plusieurs valeurs possibles et d'effectuer un traitement approprié à chaque valeur. La syntaxe est la suivante: switch (<expression_entière>) { case valeur_1:...;...; case valeur_2:...;...; } case valeur-n:...;...;...; default:...;...; Les expressions valeur_1.. valeur_n doivent être des expressions constantes. Le traitement commence à la première instruction correspondant à la valeur de expression_entière lorsque celle ci est trouvée parmi les valeurs possibles valeur_i, ou bien à la première instruction correspondant à default lorsqu'elle n'est pas trouvée. S'il n'y a pas de branchement default, cela signifie qu'aucune action n'est entreprise lorsque la valeur de l'expression n'est pas trouvée. Le traitement s'arrête, soit à la première instruction de sortie break si il y en a une, soit à la fin du switch. En conséquence lorsque le programmeur veut une action particulière pour chaque valeur, il doit placer un break à la fin de la liste d'instructions associée sinon l'exécution continue dans le cas suivant. L'exemple suivant illustre ce principe. switch (rep) { /* on teste la valeur du caractère rep */ case ' ' : nb_space++; break; case '\n': case '\0': fini=1; break; /* fini=1 pour rep ='\n' ou '\0' */ default : nb_car++; } b) Les structures répétitives : l'itération bornée for Il s'agit de la traduction de la boucle pour dont la forme générale est: for(<expression_1>;<expression_2>;<expression_3>) <bloc> Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 16

18 et dans laquelle: 1. expression_1 est une liste d'instructions exécutées une seule fois avant la répétitive; il s'agira ici des initialisations 2. expression_2 est une expression logique représentant la condition de maintien dans la boucle; cette expression est évaluée avant chaque passage donc le nombre de passage dans la boucle varie de 0 à n. 3. expression_3 est une liste d'instructions exécutées à la fin de chaque passage dans la boucle; il s'agira ici de l'itération du compteur de boucle et de l'itération d'autres variables suivant les besoins 4. expression_1 et expression_3 peuvent comprendre plusieurs instructions séparées par le caractère, Dans l'exemple suivant on fait la somme des 10 premiers entiers naturels for (i=1, somme=0; i<=10; i++) somme+=i; la boucle while Il s'agit de la traduction de la boucle tant que et dont la forme générale est: while(<expression >) <bloc> et dans laquelle expression est une expression logique représentant la condition de maintien dans la boucle; cette expression étant évaluée avant chaque exécution du bloc, le nombre de passage varie de 0 à n. la boucle do while Il s'agit de la traduction de la boucle répéter... tant que et dont la forme générale est: do <bloc> while(<expression >) Cependant l'écriture diffère légèrement de celle du répéter...jusqu'à puisque expression est une expression logique représentant la condition de maintien dans la boucle et non pas la condition d'arrêt; cette expression étant évaluée après chaque exécution du bloc, le nombre de passage varie de 1 à n. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 17

19 Remarques: 1) comme dans le cas du if un bloc ne comportant qu'une seule instruction peut ne pas comprendre de délimiteurs { et }; il est cependant recommandé d'utiliser les délimiteurs pour des problèmes de maintenance 2) pour estimer la condition de maintien, il est parfois plus facile d'estimer la condition de sortie puis de complémenter cette expression 3) pour passer n fois dans une boucle, le plus simple est d'initialiser un compteur de boucle à 0 et d'écrire comme condition de maintien compteur_boucle < n l'instruction break L'instruction break sert à forcer la sortie dans le cas d'un switch, d'un do, d'un for et d'un while. Ceci provoque le branchement immédiat à l'instruction qui suit la structure de contrôle. Un cas d'utilisation relativement courant est la boucle infinie d'attente d'un événement, que l'on peut programmer de la sorte: for(;;) { if (EVENEMENT) break; /* si EVENEMENT devient VRAI on sort */ } l'instruction continue L'instruction continue sert dans le cas d'une répétitive à forcer le branchement en fin de la boucle et donc à passer directement à l'itération suivante. Dans le cas d'un for, les expressions de fin de boucle sont effectuées avant de réévaluer la condition de maintien. Exemple: while (i<10) { printf("\n entrez un entier naturel "); scanf("%d%*c",&n); if (n<0) continue;...; /* traitement si n >= 0 */...; } Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 18

20 5-5 Les entrées-sorties : On ne s'intéresse ici qu'aux entrées au clavier et aux sorties à l'écran. Il existe à cet effet des fonctions de la bibliothèque standard étudiées plus en détail en annexe. Pour utiliser ces fonctions, il faut inclure dans le fichier source le fichier d'en-tête <stdio.h>. saisie d'un caractère Pour saisir un caractère, il faut passer par la fonction getchar();il suffit d'affecter à une variable de type char le résultat retourné par cette fonction. Exemple: rep=getchar(); afficher un caractère Pour afficher un caractère, il faut passer par la fonction putchar(); l'utilisation est simple; il suffit de fournir en paramètre à cette fonction la variable de type char à afficher. Exemple: putchar(rep); saisie d'une variable Pour saisir une variable de type char, int ou float avec leur variante (short, long, double), il faut passer par la fonction scanf(). Cette fonction convertit des caractères saisis au clavier dans la représentation binaire associée au type de la variable en mémoire centrale. Par exemple lorsqu'on veut affecter un entier, celui-ci est représenté sur 4 octets en mémoire suivant le principe du complément à 2. L'utilisateur quant à lui saisit une suite de chiffres terminée par <Entrée>, chaque chiffre étant codé sur un octet d'après le code ASCII. La fonction scanf va alors effectuer la conversion de cette suite d'octets codés en ASCII suivant le format entier sur 4 octets en complément à 2. Etant donné que cette fonction peut effectuer plusieurs conversions car elle permet d'affecter soit un caractère soit un entier soit encore un réel (dont la représentation interne est sous forme IEEE 754), on doit lui préciser le format de conversion. Les différents format de conversion utilisables sont détaillés en annexe, mais les plus usités sont les suivants: %c : format de conversion en caractère %s : format de conversion en chaîne de caractères %d : format de conversion en entier signé %f : format de conversion en virgule flottante simple précision %lf : format de conversion en virgule flottante double précision Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 19

21 Exemple: scanf("%d",&x); /* saisi de l'entier x */ scanf("%c",&rep); /* saisi du caractère rep */ scanf("%f",&y); /* saisi du réel y */ scanf("%s",tab); /* saisi de la chaîne tab */ On remarque que les objets de type char, int et float doivent être précédés de l'opérateur &. Nous verrons qu'il s'agit du mécanisme de passage par référence permettant effectivement à la fonction de modifier le contenu des objets passés en argument. Nous verrons également pourquoi ceci n'est pas utile dans le cas des chaînes de caractères. Remarque: La gestion des entrées-sorties par scanf peut donner lieu à des comportements qui déroutent l'utilisateur novice. En effet, l'entrée au clavier est validée par l'appui sur la touche <Entrée>. Or cette touche génère au même titre que les autres touches, un code qui est interprété comme étant le caractère '\n' ou 0A en hexadécimal. Ce caractère peut parasiter d'autres entrées par scanf puisqu'il est dans le tampon. Afin d'éviter un parasitage possible, il est conseillé de filtrer ce caractère par l'option %*c, qui signifie que l'on a saisi aussi un octet mais qui ne sera affecté à rien. Ainsi la saisie d'un entier devient: scanf("%d%*c",&x); affichage d'une variable Pour afficher une variable de type char, int ou float avec leur variante (short, long, double), il faut passer par la fonction printf(). Cette fonction convertit en caractères affichés à l'écran le contenu d'une variable dont la représentation en mémoire centrale dépend du type de la variable. Comme dans le cas de scanf(), cette fonction peut effectuer plusieurs conversions précisées par des formats. Ces formats sont les mêmes que pour scanf() et ils sont détaillés en annexe. L'exemple suivant illustre le principe de fonctionnement de printf(). Ce qui doit être affiché est placé entre les caractères " ". On précise dans cette chaîne le texte à afficher et chaque fois qu'il doit y avoir l'affichage d'une variable, on indique non pas la variable mais le format de conversion. Les variables sont ensuite passées en paramètres et dans l'ordre; il est possible d'utiliser également les caractères spéciaux comme \n qui sert de saut de ligne.. Ici on veut afficher un entier et un réel. printf("\n\nla valeur de x est %d et celle de y est %f : ",x,y); Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 20

22 saisie au vol d'un caractère Pour saisir au vol un caractère, c'est à dire sans avoir à taper sur la touche <Entrée>, il faut passer par une fonction propre au département et qui s'appelle kbget(). Pour utiliser cette fonction, vous devez inclure le header <iutio.h> situé dans le répertoire /usr/local/include; cette fonction retourne le caractère frappé au clavier dès lors que l'utilisateur a appuyer sur une touche (cf. Annexe B). 6 Le préprocesseur C: Tout texte source écrit en langage C est d'abord analysé par le préprocesseur avant d'être traduit par le compilateur. Cette phase est automatiquement exécutée lorsqu'on invoque le compilateur (et donc lorsqu'on passe par la procédure de compilation ccomp). Le rôle du préprocesseur se limite à une simple manipulation du texte du fichier source, c'est à dire qu'en sortie du préprocesseur le fichier fourni reste du texte. On peut d'ailleurs demander uniquement le passage du préprocesseur avec l'option -E du compilateur C du GNU ou du compilateur HP-UX. Il est également possible d'invoquer directement le préprocesseur par la commande suivante: /usr/ccs/lbin/cpp nom_fichier_source.c Les directives passées au préprocesseur commencent toujours par le caractère # et elles ne comprennent pas le caractère ; qui marque la fin d'une instruction C. Le rôle du préprocesseur est de permettre: l'inclusion des fichiers d'en-tête.h: ce sont des fichiers texte qui comprennent des définitions de types, de constantes et le prototypage de fonctions; la directive d'inclusion est #include <xxxxx.h> ou encore #include "xxxxx.h" lorsque le fichier d'en-tête est situé dans le répertoire courant. Le préprocesseur inclut alors à l'emplacement de la directive le contenu du fichier.h la définition de constantes: la directive #define NOM_CONST valeur_const indique au préprocesseur qu'il doit substituer dans le texte source C toute occurrence de NOM_CONST par valeur_const la définition de macroinstructions: il s'agit de définitions paramétrées grâce à la directive #define NOM_MACRO(paramètre_1,...paramètre_n) expression. Le préprocesseur effectue là aussi la substitution à chaque occurrence dans le texte de NOM_MACRO(paramètres) par l'expression définie; comme il s'agit de substitution de texte, il faut avoir recours au parenthésage pour forcer les priorités la compilation conditionnelle: il existe des directives qui permettent de sélectionner suivant une condition certaines parties du texte source. Cet aspect est traité au chapitre 6 sur la programmation modulaire Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 21

23 Exemples: #include<stdio.h> /* inclusion du fichier d'en-tête stdio.h situé dans /usr/include */ #define MAX 10 /* définition de la constante symbolique MAX qui vaut 10 */ #define CARRE(x) ((x)*(x)) /* définition de la macro CARRE; le parenthésage permet d'invoquer la macro avec des expression comme CARRE(a+b) */ Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 22

24 Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 23

25 CHAPITRE 2 - LES TYPES CONSTRUITS 1 Le type énumération: Le type énuméré est un moyen pratique de définir une variable qui peut prendre une valeur parmi un ensemble d'entiers constants appelés constantes énumérées. La valeur des constantes énumérées peut être fixée par défaut ou bien être définie par l'utilisateur d'après le principe suivant : chaque valeur peut être imposée par le programmeur lorsqu'une valeur n'est pas imposée, elle se déduit de la précédente par incrémentation de 1 lorsqu'aucune valeur n'est imposée, la valeur de la première constante énumérée est 0, les autres se déduisant par incréments successifs La définition d'une énumération se fait grâce au mot réservé enum suivant la syntaxe: enum identificateur_enumeration{liste_constantes_enumerees}; Exemples: enum bool {FAUX,VRAI}; /* définition de la variable énumérée bool qui ne peut prendre que */ /* deux valeurs FAUX (=0) ou VRAI (=1) */ enum jour {LUNDI=1,MARDI,MERCREDI,JEUDI,VENDREDI,SAMEDI,DIMANCHE}; /* définition de la variable énumérée jour qui ne peut prendre que */ /* sept valeurs LUNDI (=1) ou MARDI (=2) ou MERCREDI (=3) etc */ enum statut {ERREUR=-1, OK=1}; /* définition de la variable énumérée statut qui ne peut prendre */ /* que deux valeurs possibles ERREUR (=-1) ou OK (=1) */ Il est souvent pratique de construire un type pour une sorte d'énumération. On passe pour cela par la directive typedef suivant la syntaxe: typedef enum {liste_constantes_enumerees} NOUVEAU_TYPE; Comme le montre l'exemple suivant, le type booléen n'existant pas en C, il est possible de définir un type que l'on appelle ici LOGIQUE et qui ne prendra que la valeur VRAI ou la valeur FAUX. typedef enum {FAUX, VRAI} LOGIQUE; On peut ensuite à tout moment définir une variable du nouveau type LOGIQUE, comme par exemple: LOGIQUE fini; Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 24

26 2 Le type tableau: 2-1 Définition: Un tableau est une structure de données qui regroupe une suite finie d'objets de même type disposés de façon contiguë en mémoire centrale. Les éléments du tableau sont formés par ces objets qui sont repérées par un rang. Le rang d'un élément est un entier ou une expression. Un tableau est caractérisé par sa dimension qui peut être un entier N quelconque, mais généralement on ne considère que des tableaux de dimension 1 (vecteur) ou 2, voire 3 (matrice). Nous ne nous intéresserons ici dans un premier temps qu'aux tableaux à une dimension. 2-2 Déclaration et initialisation d'un tableau: En langage C, on déclare un tableau en précisant l'identificateur du tableau, le type des variables qui constituent ses éléments et la taille du tableau. type_des_éléments identificateur_tableau[nombre_d'éléments]; Exemple: int tabl[10]; /*déclare un tableau de 10 entiers qui s'appelle tabl */ Comme toutes les variables en langage C, un tableau peut être initialisé à sa définition, par une liste d'éléments compris entre accolades. Les éléments de la liste sont affectés dans l'ordre aux éléments du tableau. Le nombre d'éléments de la liste doit bien sûr être inférieur ou égal au nombre d'éléments que peut contenir le tableau. Les autres éléments sont mis à zéro et il n'est pas possible d'initialiser un élément sans avoir initialisé les précédents. Dans le cas particulier des tableaux de caractères, ceux-ci peuvent être initialisés caractère par caractère, ou bien par une constante de type chaîne. Le nombre d'éléments du tableau peut être omis lorsque: le tableau est un paramètre formel d'une fonction le tableau est une variable de classe de mémorisation extern (voir chapitre 6) le tableau est explicitement initialisé lors de sa définition Exemples: int mois[] = {1,2,3,4,5,6,7,8,9,10,11,12}; char tab[] = { a, l, a, i, n, \0 } ; char tab[] = "langage" le caractère fin de chaîne \0 est alors rajouté Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 25

27 2-3 Manipulation des éléments d'un tableau: On atteint un élément d'un tableau par son rang. Dans le cas d'un tableau monodimensionnel, (vecteur), l'élément de rang i (i étant un entier ou le résultat entier d'une expression) est atteint par: identificateur_tableau[i] avec i [0..N-1] N étant la taille du tableau; En algorithmique, on considère souvent que le premier élément d'un tableau est de rang 1 alors qu'en langage C, il est de rang 0. Nous verrons par la suite pourquoi. Les éléments sont donc comptés de 0 à N-1. Par exemple, avec le tableau tabl de 10 entiers déclaré précédemment, on a: tabl[0] /* premier élément */ tabl[1] /*deuxième élément */... tabl[9] /* dixième élément */ On peut manipuler l'élément d'un tableau comme toute variable, c'est à dire: Exemples: l'affecter par une valeur ou par le résultat d'une expression donnant un type identique à celui de l'élément lui appliquer tous les opérateurs compatibles avec son type for(i=nb_elem;i>k;t[i]=t[i-1],i--); /* décalage à droite des éléments du tableau depuis le rang k */ t[i]=x; /* affectation de x à l'élément de rang i */ t[0]++; /* incrémentation du premier élément du tableau t */ 2-4 Tableau à deux dimensions: En langage C, un tableau à deux dimensions est en fait un tableau à une dimension dont chaque élément est lui même un tableau. Par exemple si on veut disposer d une matrice de caractères de 10 lignes par 20 colonnes, il faut déclarer : char tab[10][20]; /* 10 lignes et 20 colonnes */ On accède alors à un élément en précisant le numéro de ligne et le numéro de colonne. Par exemple, si on considère la matrice tab déclarée précédemment, tab[2][5] représente le cinquième élément de la deuxième ligne, car tab[2][5] correspond aussi à tab[2*20+5] en linéarisant la matrice. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 26

28 Tout comme dans le cas d'un tableau monodimentionnel, on peut initialiser une matrice en donnant la liste des valeurs par ligne et colonne, et appliquer sur chaque élément les opérateurs d'affectation et ceux compatibles avec le type des éléments de la matrice. Exemple: On détermine les éléments de la matrice D de m lignes et p colonnes résultat du produit de la matrice A de m lignes n colonnes par la matrice B de n lignes p colonnes; for(i=0;i<m;i++) { for (j=0;j<p;j++) { for(somme=0,k=0;k<n;k++) { somme+=a[i][k] * B[k][j]; } D[i][j]=somme; } } 3 Le type structure: 3-1 Définition d une structure: Une structure est un agrégat d'éléments de type différents. Chaque élément peut avoir les types suivants: types de base (caractère, entier, réel) type pointeur type structure ou union type tableau type construit par le développeur sauf une fonction (mais peut être un pointeur sur fonction) Si la structure contient une structure, cela ne peut être celle en cours de définition, mais en revanche cela peut être un pointeur sur celle ci. Les éléments qui constituent une structure sont appelés membres de la structure. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 27

29 3-2 Construction d'une structure: La définition en C d'une structure se fait à l'aide du mot réservé struct. La définition commence par le caractère { et se termine par le caractère }. Dans l'exemple suivant struct individu { char nom[20]; char prenom[15]; int age; char sexe; } etudiant; individu représente un descripteur de type struct qui contient les membres (appelés aussi parfois champs) nom, prénom, age et sexe. En revanche etudiant représente une instance de la structure, c'est à dire un objet de type struct individu. On peut initialiser une variable de type structure au moment de sa définition en la faisant suivre par une liste d'expression constante correspondant à chaque membre de la structure. Exemple: struct individu prof = {"deloin","alain",36,'m'}; Une autre façon de procéder pour construire une structure est de définir un nouveau type grâce à typedef. Ceci permet de ne pas avoir à indiquer le type struct lorsqu'on définit une variable correspondant à un descripteur de structure. Ainsi dans l'exemple suivant typedef struct individu { char nom[20]; char prenom[15]; int age; char sexe; } INDIVIDU; individu est le descripteur d'une structure contenant les membres nom, prenom, age et sexe alors que INDIVIDU est un type synonyme de struct individu. Ainsi pour déclarer les variables etudiant et prof de type structure suivant le descripteur struct il suffit maintenant d'écrire: INDIVIDU prof, etudiant; Ceci est équivalent à: struct individu prof, etudiant; On voit donc bien que individu n'est qu'un descripteur de structure et non pas un type. Le type d'une structure est donc défini par struct descripteur, comme c'est le cas ici avec struct individu. On constatera par la même occasion la souplesse apportée par le mécanisme de construction de type synonyme grâce à typedef. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 28

30 3-3 Accès aux membres d'une structure: On accède aux membres d'une structure grâce à l'opérateur. qui permet d'associer le nom du membre au nom d'une structure. Ainsi pour atteindre le membre d'une structure, il faut indiquer le nom de la variable structure suivi du nom de la variable membre d'après la syntaxe structure.membre. Exemple: struct individu { char nom[20]; char prenom[15]; int age; char sexe; } etudiant,prof; strcpy(etudiant.nom,"dugommier"); strcpy(etudiant.prenom,"robert"); etudiant.age=20; etudiant.sexe='m'; On peut utiliser le membre d'une structure comme une variable quelconque, par exemple: printf("%s",etudiant.nom); if (etudiant.age > 65 )?????; 3-4 Structures imbriquées: Une structure peut comprendre un membre de type structure pourvu que le type en question ait été défini préalablement. Exemple: struct adresse { int numero; char rue[25]; }; struct individu { char nom[20]; char prenom[15]; struct adresse adr; int age; char sexe; }; On peut initialiser au moment de la déclaration une structure imbriquée en respectant l'ordre de la construction lors de l'affectation des expressions constantes. Ainsi avec la déclaration précédente: struct individu prof = {"deloin","alain",10,"avenue joffre",36,'m'}; Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 29

31 Pour atteindre le membre d'une structure imbriquée dans une structure, on répète le mécanisme d'accès par l'opérateur. en respectant la hiérarchie de construction. L'exemple suivant s'applique à la construction précédente. printf("%s %s ",prof.nom,prof.prenom); printf("%d %s ",prof.adr.numero,prof.adr.rue); printf("%d %c ",prof.age,prof.sexe); 3-5 Affectation d une structure: Pour affecter une structure, on peut soit affecter les membres les uns après les autres, soit (et ceci depuis la norme ANSI) affecter globalement une structure par une autre structure pourvu qu'elle soit de même type. Il s agit alors d une recopie en mémoire octet par octet définie par la taille identique des deux structures. C est un mécanisme qui permet en plus de s affranchir du problème du choix de l opérateur d affectation en fonction des types des membres de la structure. Exemple : struct individu etudiant_2annee, etudiant_1annee ;... etudiant_2annee=etudiant_1annee ; 4 Le type union: 4-1 Définition d une union: Une variable de type union est une variable qui peut contenir à un moment donné des objets de type et de taille différents. La déclaration est identique à celle d'une structure sauf que le mot union remplace le mot struct. Mais contrairement à une structure, l'allocation mémoire est faite ici en recouvrement, car les différents membres sont une description différente d'une même zone mémoire. L'union est très pratique puisqu'elle permet de définir une variable qui peut contenir toutes sortes de type. Exemple: union bidon { int code; float valeur; char * libellé; } zone-trav ; A un moment donné la variable zone-trav de type union bidon peut contenir un entier un réel ou une chaîne. C est au programmeur de savoir ce qu il manipule. Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 30

32 4-2 Affectation et accès aux membres d une union: On accède aux membres de l'union de la même façon qu une structure. Pour accéder à un membre on utilise la syntaxe variable_union.membre; L'affectation se fait également comme dans le cas d'une structure. On peut imbriquer des unions dans des structures. On accède alors à la variable union comme un membre de la structure. Exemple: On considère les définitions suivantes: typedef struct { char nom[31]; char prenom[31]; } E1; typedef struct { char titre[56]; int date; } E2; typedef struct { int code; union { E1 e1; E2 e2; } enreg; } BUFF; BUFF buff; On peut alors écrire par exemple: scanf("%s",buff.enreg.e1.nom); printf("\n le nom entre vaut : %s ",buff.enreg.e1.nom); Université LYON I ~ IUT-A Département Informatique ~ A.P. ~ Programmation procédurale: du C-ANSI au C++ 31