Une introduction au langage C

Transcription

1 Une introduction au langage C 1. INTRODUCTION UN EXEMPLE DE PROGRAMME EN C LES ELEMENTS DE BASE DU LANGAGE C LES MOTS RESERVES LES CONSTANTES LES IDENTIFICATEURS LES OPERATEURS LES DELIMITEURS ET LES COMMENTAIRES LES VARIABLES, TYPES ET CLASSES REGLES DE CONVERSION OPERATEURS D'ACCES AUX OBJETS LES INSTRUCTIONS ET LES DIRECTIVES LES ENTREES / SORTIES EXECUTION CONDITIONNELLE BOUCLES ET ITERATIONS INSTRUCTIONS ASSOCIEES AUX BOUCLES FONCTIONS LES DIRECTIVES TABLEAUX, POINTEURS ET STRUCTURES LES TABLEAUX LES POINTEURS LES STRUCTURES

2 1. Introduction Un programme en langage C est une suite de déclarations, d'instructions simples, de structures de contrôle, de commentaires, de directives pour le compilateur, etc. Ecrire un programme en C suppose en premier lieu que l'algorithme a été mis au point. Le but de ce document est de présenter la syntaxe et les règles sémantiques du langage C Un exemple de programme en C /* Calcul des nombres entiers par le crible d'eratosthène */ #define SIZE 1000 int Flags[ SIZE+1 ]; void main() { int i, k, premier, compte; compte = 0; for (i=0; i <= size; i++) Flags[ i ] = 1; for (i=0; i <= size; i++) { if (Flags[ i ]) { premier = i + i + 3; printf("%d\n", premier); for (k=i+premier; k <= SIZE; k+= premier) compte++; Flags[ k ] = 0; /* enlever les multiples */ printf("%d nombres premiers", compte); Lorsqu'on relit un programme en C, on ne perçoit pas dans la plupart des cas l'algorithme mis en jeu. C'est pourquoi il est important de consigner par écrit la logique de traitement et d'expliquer le codage de la représentation informatique du monde réel par tels types de variables ou à l'aide de telle ou telle structure de données. L'indentation des lignes dans un programme permet, quant à elle, de repérer d'un seul coup d'œil les structures de contrôles associées aux traitements. 2

3 2. Les éléments de base du langage C Les mots utilisés dans le langage C peuvent être : des mots réservés, des constantes, des identificateurs, des opérateurs, des délimiteurs ou des commentaires. Attention! les minuscules et les majuscules ne sont pas équivalentes. Ainsi les mots TOTO, Toto et Toto (etc) ne sont pas identiques Les mots réservés Ils servent à spécifier les types ou les classes d'allocation des objets utilisés, à introduire un opérateur symbolique ou une instruction de contrôle ou encore à définir des étiquettes de contrôle Type Classe Instruction Opérateur étiquette int auto if sizeof case char extern else default short static while long register do unsigned typedef for float switch double break struct continue union goto enum return void

4 2.2. Les constantes Elles servent à représenter des entiers, des nombres réels (appelés encore flottants), des caractères, des chaînes de caractères ou des expressions de constantes. Un entier peut être représenté par trois systèmes de notation. La notation décimale est la plus employée, exemples: 12, 25, 56. Dans la notation octale, chaque nombre doit être précédé par le chiffre 0 ceci afin de permettre une différenciation avec la notation décimale. Les chiffres 12, 25 et 56 s'écrivent en octal : 014, 031, 070. Dans la notation hexadécimale, chaque nombre doit être précédé par les caractères juxtaposés "0X" (chiffre 0 et caractère X). Les chiffres hexadécimaux 10 à 15 sont codés à l'aide des lettres 'a', 'b,' 'c', 'd', 'e', et 'f' (indifféremment en minuscule ou en majuscule). Les chiffres 12, 25 et 56 s'écrivent en hexadécimal : 0XCc, 0X1A, 0X38. Un nombre réel comporte une partie entière suivie d'un point et d'une partie fractionnaire, éventuellement suivies d'un caractère "e" ou "E" et d'un entier exprimant le facteur d'échelle en puissance de 10. Exemples : , 0.314e+1. Un caractère s'exprime simplement à l'aide de deux quottes simples. Exemples: 'a', 'b', 'Z', ' '. Certains caractères non imprimables s'écrivent à l'aide d'une notation spéciale introduite par le caractère "\" appelé "backslash" ligne suivante \n simple quote \' tabulation \t octet binaire ddd \ddd backspace \b NUL \0 saut de page \f BIP \ Une chaîne de caractères est constituée d'une séquence de caractères délimitée par des doubles quottes. Exemple : "suite de caractères". Une chaîne de caractères se termine implicitement par le caractère nul \0. Une expression constante est composée de constantes reliées entre elles par des opérateurs. Exemples : * 75, 1<< Les identificateurs Ils servent à référencer des constantes symboliques, des variables ou des fonctions. Un identificateur est constitué d'une séquence de lettres et de chiffres (attention, les minuscules et majuscules ne sont pas identiques). Le premier caractère d'un identificateur doit être obligatoirement une lettre, ce qui permet de le différencier d'une constante. En plus des caractères alphabétiques, sont autorisés certains caractères comme le caractère "_" appelé "underscore". Les mots réservés ne peuvent être utilisés comme identificateurs. 4

5 2.4. Les opérateurs Ils sont représentés par des caractères spéciaux ou par un spécificateur de type mis entre parenthèses. Seul l'opérateur sizeof est représenté par le mot réservé "sizeof". Il existe trois classes d'opérateurs. Les opérateurs unaires agissent sur un identificateur, une constante ou une expression. Les opérateurs binaires relient deux expressions. Il n'y a qu'un seul opérateur ternaire mettant en relation trois expressions unaire binaire ternaire == =? : * +!= += & - > -=! * >= *= ++ / < /= -- % <= %= (type) = sizeof & && &= ^ ^= >> >>= << <<=. -> Les opérateurs arithmétiques permettent les opérations arithmétiques classiques: addition (+), soustraction (-), multiplication (*), division (/) et modulo ou reste de la division (%). Lors de l'évaluation d'une expression arithmétique, des règles de priorité des opérateurs, appelées précédences, existent. Les opérations avec les opérateurs les plus prioritaires sont effectuées en premier. Lorsque les opérateurs ont même précédence, l'expression est évaluée de gauche à droite. Ainsi les opérateurs *, / et % ont la même précédence et cette précédence est supérieure à celle des opérateurs + et -. Exemples : a + b * c est équivalent à a + (b * c) d * e % f est équivalent à (d * e) % f L'utilisation des parenthèses permet de forcer l'évaluation de certaines opérations avant les autres. Les opérateurs de manipulation de bits sont le ET logique (&), le OU logique inclusif ( ), le OU logique exclusif (^), le complément à 1 (~), le décalage vers la gauche (<<) et le décalage vers la droite (>>). 5

6 L'opérateur d'affectation = permet de ranger une valeur dans une variable. La partie droite de cet opérateur est un identificateur de variable. La partie gauche est soit une constante, soit une variable, soit une expression arithmétique de constantes et de variables, soit une fonction. L'évaluation de la partie gauche donne un résultat qui sera rangé dans la variable désignée par la partie droite. Exemples : compte = 0; c = getchar(); res = (j >> 5) & 0377; image[ j ][ i ]=255; En langage C, une affectation est une expression à part entière. Elle donne un résultat et peut être donc à son tour affectée, c'est à dire apparaître à gauche du signe d'affectation =. Exemple : i = j = k = 0; se lit i = (j = (k = 0); et est équivalent à k=0; j=0; i=0; De même, une affectation peut se trouver dans une expression : car_majuscule = 05 & (car = getchar() ) A des fins de simplification d'écriture, l'opérateur d'affectation peut être précédé d'un opérateur arithmétique ou de manipulation de bits. Exemples : somme += n; est équivalent à somme = somme + n; produit *= n; est équivalent à produit = produit * n; Les opérateurs d'incrémentation et de décrémentation (++ et --) permettent respectivement d'ajouter et de retrancher la valeur unité à une variable. Exemples : compte++; est équivalent à compte = compte + 1; compte--; est équivalent à compte = compte - 1; Les opérateurs relationnels (==,!=, >, >=, <, <=) mettent en relation deux expressions qui sont comparées. Une expression relationnelle donne un résultat de type entier égal à 1 si l'expression est vraie et égal à 0 sinon. Une expression relationnelle peut être utilisée à gauche de l'opérateur d'affectation ou bien dans une structure de contrôle réalisant un test (if, for, while, etc). La précédence des opérateurs relationnels est plus faible que celle des opérateurs arithmétiques. Les opérateurs logiques sont la négation unaire (!), le ET logique (&&) et le OU logique ( ). Exemple : (! expression ) est équivalent à (expression == 0) 6

7 L'opérateur conditionnel est composé de 2 symboles? (alors) et : (sinon) et de 3 expressions. Exemple : (expression_1)? expression_2 : expression_3 doit se lire si (expression_1) alors expression_2 sinon expression_3 Le résultat de l'opération ternaire conditionnelle est une expression à part entière. Exemple : max = (n > max)? n : max; Les opérateurs d'accès aux objets et l'opérateur sizeof seront explicités, plus loin, avec la notion de variable informatique. 2.5 Les délimiteurs et les commentaires Les délimiteurs sont des caractères spéciaux utilisés par le compilateur pour reconnaître les différentes unités syntaxiques du langage. Le caractère ";" sert à préciser la fin d'une déclaration de variables ou la fin d'une instruction. Le caractère "," permet de séparer 2 éléments d'une liste. Les caractères "(" et ")" sont utilisés pour encadrer une liste d'arguments ou de paramètres. Les caractères "[" et "]" pour encadrer la dimension ou l'indice d'un tableau. Les caractères "{" et "" pour encadrer un bloc d'instructions ou une liste de valeurs d'initialisation. Exemples : Cf. programme erato. Les commentaires servent à ajouter des explications dans le code source d'un programme. Ils sont très utiles pour la relecture ou la compréhension du programme que ce soit par une tierce personne ou par soi-même quelques semaines ou quelques mois après sa création. Un commentaire est une suite de caractères comprise entre les symboles "/*" et "*/". Le premier symbole introduit le début d'un commentaire. Le second indique la fin du commentaire. Un commentaire peut être constitué de plusieurs lignes. Exemples : /* ceci est un "commentaire" sur une ligne */ /* * ceci est un commentaire esthétique sur plusieurs lignes * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */ Attention, on ne peut imbriquer les commentaires les uns dans les autres. 7

8 3. Les variables, types et classes Les objets de base du langage C sont les constantes et les variables (informatiques). Une variable est définie par trois attributs: - son nom ou identificateur - son type - sa classe d'allocation en mémoire Quatre classes d'allocation existent. Elles sont introduites par les mots clés extern, static, auto et register. La classe externe permet de faire le lien avec une variable globale définie dans un autre fichier programme. La classe statique assure la résidence permanente d'une variable en mémoire centrale du début à la fin de l'exécution du programme. La classe automatique permet d'allouer dynamiquement un espace mémoire pour les variables locales temporaires d'une fonction. Par défaut, lorsque rien n'est précisé, les variables sont allouées automatiquement. La classe registre permet de placer une variable dans un registre machine. Exemples : extern int commun; static int variance; int compte; (équivalent à auto int compte;) registre k; Les variables peuvent avoir des tailles différentes selon le type d'objet auquel on fait référence : caractère, entier, flottant, pointeur, tableau, structure, etc. Exemples de définition de variables : int compte; char tab[ 10 ]; Il est possible lors de la déclaration de donner une valeur initiale aux variables. Exemples : int a = 0: char car = 'a'; float res = 2.28; static char message[] = "hello"; long megabyte = 1024*1024; Lorsqu'une variable est de type externe ou statique, l'initialisation est faite une seule fois avant le démarrage du programme. Lorsqu'une variable d'une fonction est de type automatique ou registre, l'initialisation est faite à chaque exécution de cette fonction. L'opérateur sizeof retourne la taille en octets d'une variable informatique. Exemple : sizeof (tab) donne 10 octets (10 caractères). 8

9 3.1. Règles de conversion Le langage C permet de former des expressions mettant en jeu des variables de différents types. Certaines règles implicites de conversion sont utilisées par le compilateur dans l'évaluation d'une expression arithmétique. Les types char, short et int peuvent être mélangés. Les variables de types char et short sont converties implicitement en type int. Si un des opérandes est de type long, l'autre est converti en type long et le résultat est de type long. De même pour les types float et double, si un des opérandes est de type double, l'autre est converti en type double et le résultat est de type double. Il est néanmoins possible de forcer de manière explicite une conversion par l'opérateur (type) appelé cast en anglais. Exemples : double sin(), cos(); /* fonctions à arguments de type double */ main() { int jj, kk; double zz; jj = 1; zz = sin( (double) jj); kk = (int) sin( zz ); 3.2. Opérateurs d'accès aux objets Dans l'affectation a = b le contenu de la variable b est rangé dans la variable a. L'opérateur unaire adresse (&) permet de récupérer l'adresse d'une variable. Le résultat de l'opérateur adresse est de type pointeur. Exemple : adr_obj = &obj; L'opérateur inverse de l'opérateur adresse est l'opérateur indirection (*) appelé encore opérateur "contenu de". L'opérateur unaire * permet de récupérer le contenu d'un objet pointé par une variable de type pointeur. Exemple : adr_obj1 = &objet1; objet2 = *objet1; est equivalent à objet2 = objet1; /* = *&objet1 = contenu de l'adresse de objet1 */ Comment déclarer et utiliser une variable de type pointeur sera expliqué avec les tableaux et les structures. Ne pas confondre l'opérateur unaire adresse & avec l'opérateur binaire ET logique &, ni l'opérateur unaire indirection * avec l'opérateur binaire arithmétique *. 9

10 4. Les instructions et les directives 4.1. Les entrées / sorties On appelle E/S les opérations de base permettant de lire et d'écrire des données dans un programme. Lire des données signifie importer des données à l'intérieur d'un programme dans des variables. Ecrire des données signifie exporter des données. En Langage C, la lecture et l'écriture de données s'effectuent à l'aide d'outils standard. La fonction getchar() permet de lire un caractère depuis le fichier standard d'entrée "stdin" (le clavier par défaut). Elle retourne le caractère lu, exemple : carac = getchar(c); La fonction putchar(c) avec c de type caractère permet d'écrire un caractère vers la sortie standard "stdout". Exemples : putchar("a"); putchar(c); L'utilisation des fonctions getchar et putchar nécessite l'inclusion du fichier "stdio.h" dans le fichier source. Ceci se fait à l'aide de d'une directive #include. Une directive est destinée au compilateur pour la génération du code exécutable. Une directive n'est pas une instruction et ne sera pas exécutée à l'exécution du programme. Exemple d'utilisation de getchar et putchar : /* recopie de fichier standard d'entrée */ #inlude <stdio.h> copyf() { char c; while (c = getchar())!= EOF) putchar(c); La fonction printf("format", arg1, arg2,..., argn) accepte un nombre variable d'arguments. Elle permet l'affichage selon un format donné. Le premier argument précise ce format. Il s'agit d'une chaîne de caractères contenant : du texte à imprimer tel quel et des spécificateurs de format à appliquer sur les autres arguments. Les spécificateurs commencent par la lettre % et sont suivis d'un caractère de format d'impression. Exemples : printf("bonjour tout le monde\n"); printf("15 en notation décimale %d \n", 15); printf("15 en notation octale %o \n", 15); printf("15 en notation hexadécimale %x \n", 15); printf("15 en notation flottante %f \n", 15); printf("caractère imprimable %c \n", 'a'); printf("chaîne de caractères %s \n", "une chaîne"); 10

11 Des caractères spéciaux peuvent être utilisés optionnellement afin de préciser la longueur d'impression, le cadrage à gauche ou à droite dans la zone d'impression et dans le cas des nombres flottants la position du séparateur "." des parties entière et fractionnaire. Exemples : %8d imprime sur 8 chiffres avec un cadrage à droite %-25s imprime une chaîne cadrée à gauche (-) sur 25 caractères %8.2f imprime un réel sur 8 chiffres avec 2 décimales La fonction scanf("format", arg1, arg2,..., argn) permet de lire sur le fichier d'entrée standard. La liste des arguments après le format est une liste d'adresses. Exemple : int nombre; printf("donner deux nombres décimaux :"); scanf("%d", &nombre1, &nombre2); 4.2. Exécution conditionnelle if (expression) instruction ; if (expression_1) { instruction_1 ; else if (expression_2) { instruction_2 ; else { instruction_3 ; switch (expression) { case cste_1 : instruction_1 ; break ; case cste_2 : instruction_2 ; break ; default : instruction_d ; 11

12 4.3. Boucles et itérations while (expression) { instruction_1 ; instruction_2 ; do instruction ; while (expression) for (expr_1 ; expr_2 ; expr_3) { instruction ; est équivalent à expr_1 ; while (expr_2) { instruction ; expr_3 ; Exemples : nombre = 1; while ( nombre <= 10 ) { carre = nombre*nombre; printf("nombre = %2d, carré = %3d\n", nombre, carre); nombre++; for (nombre = 1 ; nombre <= 10 ; nombre++) { carre = nombre*nombre; printf("nombre = %2d, carré = %3d\n", nombre, carre); 12

13 4.4. Instructions associées aux boucles break, continue, goto 4.5. Fonctions Une fonction est un objet externe. Il faut distinguer la déclaration de la fonction et l'appel de la fonction (présence du caractère fin d'instruction ";"). Exemple : void int2stringbin(i, s) int i, char s[]; /* types des arguments */ { int x=0, n; n = (sizeof(i) * 8) -1; /* nombre de décalages */ do { s[ x++ ] = ( (i < 0)? '1' : '0'); i <<= 1; /* decalage vers la gauche d'un bit */ while (n--); s[ x ] = '\0'; /* fin de chaîne = NUL */ La déclaration précédente définit une fonction effectuant la conversion d'un entier en chiffres binaires (suite de caractères 0 et 1). Cette fonction possède 2 arguments : le premier est un entier donné en entrée, le second est le pointeur de la chaîne de caractères recevant le résultat. Le mot clé void (ou l'absence de type) indique que la fonction ne pourra être utilisée comme une expression apparaissant à droite du signe d'affectation. L'instruction suivante permet d'appeler la fonction pour lui demander de convertir le chiffre 252 et de ranger le résultat dans la variable st. int2stringbin(252, st); La plupart du temps les fonctions sont utilisées comme des expressions retournant un résultat. Lors de la déclaration, le type du résultat retourné apparaît devant le nom de la fonction et le mot clé return permet d'indiquer la valeur retournée. Exemple : float puissance_5( r1 ) float r; { float r2; r2 = r1 * r1; return r2 * r2 * r1; 13

14 Attention en langage C, les paramètres (arguments) sont passés en valeur. Les arguments de sortie doivent être des pointeurs d'objets. void swap( x, y ) /* appel : swap( &a, &b) */ int *x, *y; { int tmp; tmp=*x; *x=*y; *y=tmp; 4.5. Les directives Les directives pour le compilateur sont introduites par des mots clés commençant par le caractère "#". La directive #include <fichier.h> demande au compilateur de lire et de prendre en compte les lignes d'un fichier situé dans un répertoire du système. La directive #include "fichier.h" demande de prendre en compte un fichier situé dans le répertoire courant (utilisateur). La directive #define SYMBOLE valeur permet de définir un symbole. Lorsque ce symbole apparaîtra ensuite dans le fichier source, il sera automatiquement substitué par sa valeur. La valeur d'un symbole peut être éventuellement réduite à une chaîne vide : le symbole existe mais n'a pas de valeur. Les directives #ifdef SYMBOLE et #ifndef SYMBOLE permettent respectivement de prendre en compte ou non les lignes suivantes situées avant la directive #endif. Exemple : #ifdef SUN message = "nous sommes sur SUN" /* si le symbole SUN existe */ #else message = "nous sommes ailleurs" #endif 14

15 5. Tableaux, pointeurs et structures 5.1. Les tableaux Un tableau est une structure de données composée d'éléments consécutifs en nombre limité. Tous les éléments d'un tableau sont du même type. Un tableau est caractérisé par son nom, son type, sa dimension et sa classe d'allocation. Exemples : auto int TabInt[ 1000 ]; /* tableau de 1000 entiers */ static char TabChr[ 2000 ]; /* tableau de 2000 caractères */ Un tableau n'est pas une variable mais est considérée comme une succession de variables. TabInt[ 0 ] TabInt[ 1 ] TabInt[ k ] est le 1er élément du tableau TabInt est le 2ème est l k_ième L'identificateur de tableau TabInt n'est pas une variable, il n'est pas possible d'y appliquer l'opérateur adresse (&). Il est possible par contre d'obtenir l'adresse de chacun des éléments du tableau : &TabInt[ 0 ] est l'adresse du premier élément Notons que lors de la déclaration [ 1000 ] indique le nombre d'éléments du tableau, alors qu'à l'utilisation [ k ] indique la position de l'élément d'indice k dans le tableau (0 <= k < 1000). Il est possible d'initialiser un tableau avec des valeurs lors de sa déclaration uniquement si sa classe d'allocation est statique ou externe. Dans ce cas, la dimension du tableau peut ne pas être spécifiée. Si elle l'est, elle doit être égale ou supérieure au nombre d'éléments de la liste d'initialisation. Exemple : static char TabChr[ 17 ] = " ABCDEF" static int TabN[ 10 ] = { 4, 3, 2, 1 static long TabL[ ] = { 2, 4, 8, 16, 32, 64 Les 6 derniers éléments du tableau TabN sont nuls et le tableau TabL possède 6 éléments. Dans une déclaration, l'opérateur [] signifie "tableau de". Il est possible de définir des tableaux à plusieurs dimensions. Ainsi l'exemple suivant permet de déclarer un tableau de 16 tableaux de 256 éléments entiers : int image[ 16 ][ 256 ]; La notation image[ 16 ] n'est pas une variable mais représente un tableau de 256 éléments. On dit qu'elle est de type tableau. 15

16 5.2. Les pointeurs Un pointeur est une variable qui contient l'adresse d'une autre variable. Pour déclarer une variable de type pointeur, on utilise l'opérateur (*) qu'il faut faire précéder par le type de la variable "pointée". Exemple : int *ptri; la variable ptri est un pointeur d'entier char *ptrc; la variable ptrc est un pointeur de caractères Un pointeur est utilisé pour référencer une zone de mémoire. Exemple : int k; int *ptr; int tab[ 100 ]; for ( k=0; k < 100; k++) tab[ k ]=0; est équivalent à for (ptr = &tab[ 0 ]; ptr <= &tab[ 99 ]; ptr++) *ptr=0; ou encore à for (ptr = tab; ptr < tab+100; ptr++) *ptr=0; On peut remarquer que l'identificateur de type tableau est en fait un pointeur vers le premier élément d'un tableau : char ptrc[ ]; est équivalent à char *ptrc; 5.3. Les structures Une structure est un agrégat de plusieurs objets de différents types. Exemple ci-après, où on définit à l'aide du mot clé struct le type d'une structure qui a pour nom "TypIndividu" : struct TypIndividu { char nom[ 16 ]; int age; ; Les variables de types TypIndividu se déclarent alors de la manière suivantes : struct TypIndividu MisterX; Il est aussi possible d'écrire directement : struct TypIndividu { 16

17 MisterX ; char nom[ 16 ]; int age; ou même encore sans donner de nom au type de la structure : struct { char nom[ 16 ]; int age; MisterX ; L'accès aux différents membres d'une structure s'effectue en utilisant les opérateurs "." et "->". L'opérateur "." permet de désigner un membre d'une structure en reliant l'identificateur de la variable "structure" au nom de ce champ. L'opérateur "->" permet de relier l'identificateur d'un pointeur de structure à un nom de champ. Exemples : struct TypIndividu MisterX, *PtrX; PtrX = &MisterX; MisterX.nom="Pierrot" est équivalent à PtrX->nom="Pierrot"; ou encore à (*PtrX).nom="Pierrot"; 17