Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

1 1 ELÉMENTS DE BASE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 1 ELÉMENTS DE BASE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.1 INTRODUCTION À LA PROGRAMMATION IMPÉRATIVE............................................................... 2 1.2 NOTATIONS .................................................................................................................... 3 1.3 ACTIONS / CONDITIONS..................................................................................................... 3 1.4 VALEURS, TYPES ET VARIABLES.......................................................................................... 5 1.4.1 Valeurs et types....................................................................................................... 5 1.4.2 Variables................................................................................................................ 5 a. Identificateur................................................................................................................... 5 b. Adresses ........................................................................................................................ 6 c. Déclaration et définition..................................................................................................... 7 d. Initialisation................................................................................................................... 8 1.5 ACTIONS ÉLÉMENTAIRES ................................................................................................... 8 1.5.1 Affectation.............................................................................................................. 8 1.5.2 Lecture................................................................................................................... 9 1.5.3 Ecriture.................................................................................................................11 1.6 STRUCTURES CONDITIONNELLES........................................................................................14 2 STRUCTURE DES PROGRAMMES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 8 2.1 FORME GÉNÉRALE D’UN PROGRAMME EN C..........................................................................18 2.1.1 Définition de la fonction main...................................................................................19 2.1.2 La partie déclarations (globales) .................................................................................20 2.2 LES TYPES......................................................................................................................20 2.2.1 Les types couramment rencontrés dans les langages impératifs.........................................21 2.2.2 Le type entier.........................................................................................................21 2.2.3 Le type réel............................................................................................................21 2.2.4 Le type booléen......................................................................................................21 2.2.5 Le type caractère .....................................................................................................21 2.2.6 Le type chaîne de caractères.......................................................................................21 2.2.7 Les types de base du langage C..................................................................................21 2.2.8 Le type char .......................................................................................................21 2.2.9 Le type int .........................................................................................................22 2.2.10 Le type float .................................................................................................22 2.2.11 Le type double ...............................................................................................22 2.2.12 Les qualificatifs appliqués aux types de base.............................................................23 2.2.13 Lecture et écriture de valeurs de différents types.........................................................24 2.3 DÉCLARATION ET DÉFINITION DE VARIABLES .......................................................................24 2.4 INITIALISATION..............................................................................................................26 2.5 LA DÉFINITION DE CONSTANTES.........................................................................................26 2.6 LES EXPRESSIONS ............................................................................................................27 2.6.1 Définition d’une expression.......................................................................................27 2.6.2 Opérateurs courants dans les langages impératifs ...........................................................28 2.6.3 Evaluation d’une expression......................................................................................29 2.6.4 Les conversions de type............................................................................................30 a. Conversion automatique....................................................................................................30 b. Conversion forcée...........................................................................................................31 2 1 Eléments de base 1.1 Introduction à la programmation impérative L’objet de ce cours est d’apprendre à programmer un ordinateur, i.e. d’apprendre à décrire les opérations que la machine doit effectuer pour résoudre automatiquement un problème. Il s’agit donc d’apprendre à écrire un programme et pour cela, il nous faut introduire un langage de programmation. Dès lors que les problèmes à résoudre deviennent complexes (au-delà des opérations arithmétiques élémentaires), programmer directement en langage machine devient impossible (lourdeur des programmes, niveau de détail empêchant de mettre en œuvre des raisonnements complexes, nécessité de tenir compte des caractéristiques propres de la machine...). On utilise alors un langage de programmation évolué. Langages formels et non ambigus, les langages de programmation évolués obéissent à une syntaxe stricte comme le langage machine. Ils offrent néanmoins une plus grande richesse d’expression qui permet au programmeur de s’affranchir d’un certain niveau de détail. Langages compilables, ils permettent aussi d’écrire des programmes indépendants de la machine sur laquelle ils seront exécutés. Dans ce cours, nous utiliserons le langage C. Il appartient à la famille des langages impératifs (Fortran, Cobol, Pascal, Basic, etc.), par opposition aux langages fonctionnels ou objet. Le langage C a été conçu à l’origine aux Laboratoires Bell (en même temps que le système Unix) pour faire de la programmation système. Il est très efficace et très utilisé aujourd’hui dans l’industrie. Un certain nombre de langages actuels, comme C++, Perl, ou Java, dérivent également de C et présentent avec lui des similitudes syntaxiques. On peut écrire des programmes dans de nombreux langages. L’objectif ici est pas d’apprendre à programmer en C. Il s’agit de maîtriser les bases de la programmation impérative et de les mettre en œuvre dans une programmation en langage C. Nous emploierons donc souvent un langage algorithmique indépendant de C qui nous permettra : − de souligner les étapes importantes d’un algorithme, indépendamment des détails de son implémentation ; − de maîtriser les concepts de la programmation impérative indépendamment des spécificités du C ou de tout autre langage particulier ; − de souligner les particularités de C. Rappelons en effet les trois premières phases de la conception d’un logiciel : 1. L’analyse, qui permet de spécifier le problème à résoudre et/ou d’isoler les fonctionnalités du logiciel à mettre en oeuvre. Dans cette phase on détermine « quelles sont les données et leurs propriétés, quels sont les résultats attendus et quelles sont les relations exactes entre les données et les résultats » (cf. Bibliographie [2]). 2. La conception de l’algorithme ; il s’agit généralement de déterminer la méthode de résolution d’un problème, d’en identifier les principales étapes et de la décrire dans ses grandes lignes. C’est en réalité dans cette phase qu’on spécifie la manière dont on va mettre 3 en œuvre les fonctionnalités du logiciel que l’on a isolé dans la phase d’analyse. A ce stade, certains détails peuvent encore être laissés de côté, mais il faudra veiller à ne laisser aucun point important dans l’ombre. 3. L’implémentation (ou implantation) de l’algorithme dans un langage de programmation (C dans notre cas). Il s’agit de traduire la conception de l’algorithme en un programme dans un langage de programmation particulier. A ce stade, il faut respecter la syntaxe du langage de programmation choisi et préciser tout ce qui était resté dans l’ombre. la syntaxe est l’ensemble des règles d’écriture d’un langage qui détermine l’« allure » et la structure des programmes. Cette syntaxe doit être rigoureusement suivie. Une seule virgule mal placée et le programme ne peut pas être exécuté (le compilateur ne génère pas de programme exécutable), ou pire, il « tourne » mais ne fait pas ce qui était attendu (on a des erreurs pendant l’exécution ou des résultats faux). Nous mettrons ici l’accent sur la seconde et la troisième de ces étapes. 1.2 Notations − Les exemples décrits en langage algorithmique figurent en italiques. − Les exemples de programmes ou les instructions C figurent dans ce document en police courier. − Sont notés en gras les éléments du langage nouvellement introduits ou les éléments qui font ressortir la structure des programmes. − Les crochets (<…>) sont utilisés dans la description de la syntaxe du langage pour désigner de manière générique des éléments à remplacer. On peut ainsi décrire une déclaration de fonction entière par la formule : int <identificateur de fonction>() ; qui indique que l’on peut mettre à la place de ce qui est entre crochets n’importe quel identificateur de fonction (par ex. : int maFonction() ;). − Le texte souligné représente les messages d’entrées (i.e. tapés par l’utilisateur au clavier) et les messages de sorties (affichés à l’écran). 1.3 Actions / conditions Considérons deux exemples : − Une calculatrice de bureau dont on suppose dans un premier temps qu’elle ne fait que des additions. L’addition consiste à récupérer la première et la seconde valeur donnée par l’utilisateur (1 ère et 2 nde opérandes), à en faire l’addition et enfin, à afficher le résultat. − Une billetterie automatique pour l’achat de billets de train. Le dialogue de l’utilisateur avec la billetterie permet de préciser de quel trajet il s’agit, de fixer la date et l’horaire, de déterminer le tarif auquel l’utilisateur a droit, et de calculer le prix du ou des billets demandés. Nous observons sur ces exemples que des actions complexes (ici, une addition ou un dialogue de billetterie automatique) se décomposent en une séquence d’actions plus simples. Nous verrons plus loin en quoi consistent dans un programme ces sous-actions. 4 Exemple : addition Algorithme 2 variables entières en entrée : n1, n2 1 variable entière en sortie : r début lecture de la première variable: n1 lecture de la seconde variable: n2 calcul du résultat : r = n1 + n2 affichage du résultat : r fin algorithme Exemple : billetterie Algorithme début affichage du message d’accueil (« vous êtes sur une billetterie automatique ») choix du trajet calcul du prix de base en fonction du trajet :p choix du nombre de billets : nb calcul du montant total : m = p * nb affichage du résultat : m fin algorithme Si maintenant, on considère l’opération de division, il faut vérifier avant de procéder au calcul que le diviseur n’est pas nul. Cette fois l’action correspondant au calcul est conditionnée par un test sur la valeur du diviseur. Algorithme : division Algorithme 2 variables entières en entrée : n1, n2 1 variable entière en sortie : r début lecture de la première variablel: n1 lecture de la seconde variable: n2 si (n2 ≠ 0) alors calcul du résultat : r = n1 / n2 affichage du résultat : r finsi fin algorithme Ces algorithmes représentent de manière abstraite des programmes. Ils sont constitués d’une suite d’instructions à effectuer, comme nous l’avons vu en MAMIAS. Une instruction peut être simple ou conditionnelle. La lecture d’une variable est ici une instruction simple. Le deuxième cas est introduit uploads/Litterature/ 3-cours-deug.pdf