Le langage C - perso.esiee.frlandschm/IN3T01/Abrégé de langage C ESIEE... · ESIEE 2010/2011...

ESIEE 2010/2011IN3T01 Abrégé de langage C

Le langage C Le langage C est le langage de développement lié à UNIX. Le système UNIX est

d'ailleurs écrit à 95% en C.C est un langage assez proche de la machine, mais portable. Le développement en C

prend en moyenne sept fois moins de temps que le même développement en assembleur par un programmeur confirmé, et le surcoût en taille mémoire des programmes et en temps d'exécution n'est de l'ordre que de une fois et demie à deux fois. De plus, sa portabilité en fait un langage de développement idéal pour l'écriture de systèmes, de SGBD ou d'autres logiciels applicatifs.

Le langage C a une réputation de difficulté à maintenir qui est due en grande partie à la tendance de certains programmeurs à utiliser des trucs et astuces permis par C au détriment de la lisibilité. Cependant, un programme C correctement construit et commenté est aussi facile à lire qu'un programme écrit dans un langage plus « clair ».

Voici un exemple de programme C, une esquisse de la commande wc d'UNIX qui compte les caractères, les mots et les lignes d'un fichier, avec la faible définition pour un mot d'être une suite de caractères sans espace, retour chariot ou tabulation.

[1] #include <stdio.h> [2] #define OUI 1 [3] #define NON 0 [4] int main(void) { [5] int c, nl, nm, nc, dans_un_mot; [6] dans_un_mot = NON; [7] nl = nm = nc = 0; [8] while ((c = getchar()) != EOF) { [9] ++nc;[10] if (c == '\n')[11] ++nl;[12] if (c == ' ' || c == '\n' || c == '\t')[13] dans_un_mot = NON;[14] else if (dans_un_mot == NON) {[15] dans_un_mot = OUI;[16] ++nm;[17] }[18] }[19] printf ("%d %d %d\n", nl, nm, nc);[20] return 0;[21]}

Les lignes sont numérotées ici pour le besoin de l'explication. Un programme C n'a pas de numéros de ligne.

JCG 1/21


Pour compiler sous UNIX ce programme, enregistré sous le nom compte_mots.c, on utilise la commande

$ cc compte_mots.c <Entrée> qui appelle le compilateur C et produit si il n'y a pas d'erreur un fichier exécutable

appelé a.out (nom donné par défaut).Si on veut lui donner un autre nom que a.out (par exemple wc), il suffit d'appeler

$ cc compte_mots.c -o wc <Entrée> La commande

$ wc < compte_mots.c <Entrée> nous donnera une sortie du genre

24 75 373$

Revenons à l'étude du programme source. La ligne [1] demande au compilateur d'inclure le texte du fichier stdio.h qui se

trouve en général dans le répertoire /usr/include et qui contient des déclarations de fonctions (comme getchar) et des définitions (comme EOF).

Les lignes [2] et [3] préviennent le compilateur que, chaque fois que dans le texte du programme il rencontrera le mot OUI (respectivement NON), il devra le remplacer par 1 (respectivement 0). Ces remplacements ne se feront évidemment pas dans les commentaires, chaînes de caractères constantes ou à l'intérieur d'un mot.

Par convention, tous les programmes C possèdent une fonction appelée main. C'est cette fonction qui est exécutée au lancement du programme. Dans notre exemple, c'est la seule fonction du programme. Elle est déclarée ligne [4].

Les fonctions C retournent en général une valeur. Si elles n'en retournent pas, on les préfixe par void pour éviter une erreur de type warning (erreur mineure, n'empêchant pas la compilation, mais signalant souvent un défaut).

Les parenthèses vides indiquent que main n'a pas de paramètres. Le texte d'une fonction est entre deux accolades { et }. Dans le texte de main, il y a cinq déclarations de variables (ligne [5] ), toutes cinq de type entier (int) et cinq instructions :

– une instruction d'affectation simple à la ligne [6]– une instruction d'affectation composée ligne [7]– une instruction de boucle : while... (ligne [8] à ligne [18]– une instruction printf d'affichage (ligne [19])– une instruction de retour (ligne [20])

JCG 2/21


L'instruction d'affectation composée n'est pas une spécificité, mais simplement la conséquence qu'en C, l'affectation peut être utilisée dans une expression, avec comme valeur celle de la partie gauche de l'affectation, et que de plus l'affectation est associative droite à gauche.

On peut donc écrire des instructions du type :a = (b = 5)+( c = 2);

qui aura exactement le même résultat queb = 5; c = 2; a = b + c;

Dans le cas de l'affectation composée du programme, tout se passe comme si l'on avait écrit :

nl = (nm = (nc = 0));L'instruction while teste une condition; si elle est vraie, exécute le corps de la boucle,

et ce tant que la condition est vraie. Ici, la condition est :Est-ce que le caractère lu dans le fichier d'entrée standard (par la fonction

getchar())et stocké dans c (par l'affectation) est différent du caractère signalant la fin de fichier (désigné par EOF). Si oui, c'est à dire si un caractère du fichier vient d'être lu, la boucle est exécutée. Sinon, on passe à l'instruction suivante (affichage).

Le corps de la boucle while est une instruction, ici composée de trois instructions encadrées entre accolades :

– incrémentation du compteur de caractère ++nc;

a exactement la même signification quenc = nc + 1;

mais est plus concise et souvent plus efficace.– une instruction de test

si le caractère lu (stocké dans c) est égal (==) au caractère de retour chariot ('\n'), on incrémente le compteur de ligne (++nl).

– une autre instruction de testsi le caractère lu est égal à un espace(' ') ou (||) s'il est égal à un

retour chariot ('\n') ou s'il est égal à une tabulation('\t'), alors on n'est pas dans un mot (dans_un_mot = NON)sinon ( c'est à dire si le caractère lu est un non-espace )

si on n'est pas dans un mot (dans_un_mot == NON)alors on rentre dans un mot (dans_un_mot = OUI)et on le compte (++nm)

L'instruction d'affichage affiche les trois variables nl, nm, nc, sous un format entier (%d) séparées par des espaces et suivies d'un retour ligne : "%d %d %d\n"

Enfin, l'instruction return termine le programme et renvoie au système la valeur 0.

JCG 3/21


1 La syntaxe C

1.1 Les règles d'écriture

1.1.1 Commentaires et espaces

Un commentaire commence par les caractères /* et se termine par */.Le commentaire /* fin de ligne est accepté par la plupart des compilateurs.Les commentaires imbriqués sont autorisés par certains compilateurs, mais pas par tous.Pour séparer les mots C, on peut utiliser des espaces, tabulations, retours ligne ou des

commentaires.

1.1.2 Les identificateurs

Un identificateur nomme une variable, une étiquette ou une fonction. Il est formé d'une suite alphanumérique commençant par une lettre. Le tiret de soulignement ( _ ) est considéré comme une lettre.

Attention : Le langage C distingue les majuscules et les minuscules.La longueur maximum d'un identificateur dépend des compilateurs (6 minimum,

souvent 32).

Certains identificateurs sont des mots réservés du langage :

auto else int typedefbreak entry long switchcase enum register unionchar extern return unsignedcontinue float short voiddefault for sizeof whiledo goto staticdouble if struct

Tableau 1 : les mots réservés du C

JCG 4/21


1.1.3 Les types simples

Le langage C possède plusieurs types simples pour les données, dont la taille mémoire en multiple de la taille d'un caractère peut être fournie par l'opérateur sizeof.

- char représente n'importe quel caractère du jeu de caractères utilisé. Un caractère est représenté sous la forme d'un entier et sa valeur dépend du code (ASCII, EBCDIC, Unicode, ...)

- short int, int, long int désignent trois types d'entiers en arithmétique modulo 2n, où n est le nombre de bits utilisés pour représenter un nombre. Les trois types respectent les règles suivantes :

1 = sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)sizeof(short) < sizeof(long)

- unsigned short int , unsigned int, unsigned long int dési-gnent les entiers non signés. Le mot int peut être omis si unsigned, short ou long est précisé.

– float et double désignent les réels simple et double précision.

1.1.4 Les constantes

Une constante entière s'écrit comme une suite de chiffres. Si elle commence par 0, elle est considérée comme octale (en base 8), par 0x ou 0X comme hexadécimale(en base 16, les valeurs de 10 à 15 sont alors représentées par a-f ou A-F). Les constantes de type long se suffixent par l (la lettre L minuscule) ou L.

Une constante de type caractère s'écrit entre apostrophes simples ( ' ). On utilise la contre-oblique \ pour représenter les caractères spéciaux selon le tableau suivant :

représentation caractère'\n' nouvelle ligne (nl)'\t' tabulation (ht)'\b' retour arrière (bs)'\r' retour chariot (cr)'\\' anti slash'\'' apostrophe'\0' nul

Tableau 2 : les constantes caractères spécialesDe plus, on peut représenter un caractère sous sa forme numérique octale '\ddd' où d

désigne un chiffre octal.Les constantes chaîne de caractères sont des suites de caractères encadrées par des

double guillemets anglais ( " ). Elles peuvent contenir les caractères spéciaux sous la forme décrite précédemment avec en plus \" pour inclure un guillemet à l'intérieur de la chaîne. Le caractère nul ('\0') est ajouté systématiquement à toute constante chaîne.

JCG 5/21


Les constantes réelles sont traitées en double précision et s'écrivent sous la forme :partie_entière[.partie_décimale]e[±]exposant

comme par exemple 0.0 -2.71828 6.02e23 1.1.5 Les variables

Une variable est un nom (identificateur) qui permet d'adresser un espace mémoire où sera stocké le contenu (la valeur) de la variable.

Une variable est déclarée parnom_type nom_variable;

Le type est nécessaire pour pouvoir réserver une place suffisante pour stocker la valeur de la variable. La variable existera tant que la fin du bloc dans lequel elle est déclarée n'est pas atteinte (variable automatique), sauf si elle est déclarée static ou extern, auquel cas elle existera depuis le début jusqu'à la fin du programme.

1.2 Les expressions et les opérateursUne expression est une constante, un identificateur, un élément de tableau, une

référence à une structure ou une union, un appel de fonction ou toute combinaison d'expressions.

1.2.1 Les opérateurs arithmétiques

+ addition- soustraction* multiplication/ division ( entière si les deux opérandes sont entiers)% reste de la division entière (17 % 5 -> 2)

Tableau 3 : les opérateurs arithmétiques

1.2.2 Les opérateurs relationnels

Ils retournent 0 si la comparaison est fausse et 1 si elle est vraie< strictement inférieur<= inférieur ou égal> strictement supérieur>= supérieur ou égal

Tableau 4 : les comparateurs arithmétiques

1.2.3 Les opérateur d'égalité et d'inégalité

Ils retournent 0 si la comparaison est fausse et 1 si elle est vraie== égal != différent

Tableau 5 : les opérateurs d'égalité

JCG 6/21


1.2.4 Les opérateurs de décalage

Ils décalent l'opérande gauche d'un nombre de bits égal à l'opérande droit>> décalage droite (si unsigned, remplissage par des 0,

sinon dépendant du compilateur)<< décalage gauche remplissage par des 0

Tableau 6 : les opérateurs de décalage

1.2.5 Les opérateurs bit à bit

Ils réalisent pour les bits de même rang de leurs opérandes l'opération logique indiquée.& et logique| ou logique^ ou exclusif

Tableau 7 : les opérateurs bit à bit

1.2.6 Les opérateurs logiques

Ils n'évaluent leur opérande droit qu'en cas de nécessité.&& et logique (retourne 1 si les deux opérandes non nuls, 0 sinon)|| ou logique (retourne 1 si un des opérandes non nul, 0 sinon)! non logique (retourne 1 si un des opérandes non nul, 0 sinon)

Tableau 8 : les opérateurs logiques

1.2.7 L'opérateur virgule expr1, expr2

évalue expr1, puis expr2 et retourne la valeur de expr2

1.2.8 Les opérateurs d'affectationl_value = expr ;

l_value est une expression permettant de désigner une adresse mémoire (identificateur de variable, indirection de pointeur, élément de tableau, référence à une structure ou à une union) , et expr une expression.

l_value et expr sont évaluées et la valeur de expr est rangée à l'endroit défini par la l_value.

+= -= *= /= %= >>= <<= &= ^= |= effectuent entre leurs deux opérandes l'opération indiquée avant le signe = et range leur

résultat dans leur membre gauchex += y est équivalent à x = x + y, mais l'adresse de x n'est recherchée qu'une

fois.

JCG 7/21


1.2.9 L'opérateur conditionnelexpr ? expr1 : expr2

Il évalue expr. Si sa valeur est non nulle, retourne la valeur de expr1 sinon la valeur de expr2.

1.2.10 Les opérateurs unaires

e représente une expression et v une l_valueopérateur description*e retourne la valeur contenue à l'adresse calculée par e&v retourne l'adresse mémoire de la variable v-e moins unaire!e non logique (si e vaut 0, retourne 1 sinon retourne 0)~e non logique bit à bit++v incrémente v et retourne sa valeur--v décrémente v et retourne sa valeurv++ retourne la valeur de v, puis l'incrémentev-- retourne la valeur de v, puis le décrémente(nom_type)e convertit e dans le type nom_typesizeof(e) taille (en char) de esizeof(type) taille (en char) d'un objet de type

Tableau 9 : les opérateurs unaires

1.2.11 La conversion de type

Des conversions de type sont effectuées automatiquement à chaque opération ou appel de fonction.

D'abord, les opérandes char ou short sont convertis en int, et ceux de type float sont convertis en double

Puis, si l'un des opérandes est double, l'autre est converti en double et le résultat est de type double.

Sinon, si l'un des opérandes est long, l'autre est converti en long et le résultat est de type long.

Sinon, si l'un des opérandes est unsigned, l'autre est converti en unsigned et le résultat est de type unsigned.

Sinon, les deux opérateurs sont de types int et le résultat de type int.

1.2.12 Priorité et ordre d'évaluation.

Le tableau suivant donne l'ordre de priorité, décroissant d'une ligne à la suivante, et le sens d'évaluation en cas d'opérateurs de même priorité d'une expression.

JCG 8/21


Opérateur Sens d'évaluation() [] -> . →! ~ ++ -- - (nom_type) * & sizeof ←* / % →+ - →<< >> →< <= > >= →== != →& →^ →| →&& →|| →?: ←= += -= *= ... ←, →

Tableau 10 : priorités des opérateurs

2 Le contrôle du programme

2.1 Les instructions de contrôleL'ordre normal d'exécution des instructions est l'ordre d'écriture de ces instructions. Une

instruction composée est une suite d'instructions, encadrée par des accolades. Sauf précision contraire, toute instruction peut être considérée comme une instruction composée.

2.1.1 L'instruction ifif (expression) instruction1

ouif (expression) instruction1 else instruction2

Si la valeur de l'expression est non nulle, c'est instruction1 qui sera exécutée. Sinon, lorsque la partie else existe, c'est instruction2.

2.1.2 L'instruction switchswitch (expression_de_type_int) instruction_composée

Selon la valeur de l'expression, le débranchement se fait sur l'une des instructions de l'instruction composée étiquetée de la manière suivante :

case expression_constante :ou

default :

JCG 9/21


Le déroulement se poursuit à l'instruction suivant l'étiquette dont la valeur est égale à la valeur de l'expression, ou à l'instruction étiquetée default jusqu'à rencontrer une instruction break; qui débranche sur l'instruction suivant l'instruction switch.

2.1.3 Les itérations ● while (expression) instruction

tant que l'expression est évaluée à une valeur non nulle, le programme exécute l'instruction.

● for (instr1; expr; instr2) instructionest équivalente à :

instr1while (expr2) {instruction instr2}

● do instruction while (expr)est équivalente à

instructionwhile(expr) instruction

● break; permet de sortir d'une l'instruction do, for, while ou switch, d'un niveau

d'imbrication seulement.● goto etiquette;

permet de débrancher inconditionnellement sur l'instruction de la même fonction étiquetée par etiquette, du type etiquette : instruction;

● continue;débranche le programme sur l'itération suivante de boucle for, while ou do.

2.2 Les fonctionsUne fonction est un morceau de programme appelable aussi souvent que nécessaire, et

qui rend souvent un programme plus lisible.● Une fonction est déclarée en spécifiant le type de résultat (void si elle ne retourne

pas de valeur, on l'appelle alors procédure) et le nom de la fonction.type_de_résultat nom_de_la_fonction(liste_de_paramètres);

● Une fonction est définie en précisant de plus le nom de ses paramètres formels, leurs types et le corps de la fonction. Une définition peut servir de déclaration.

type_de_résultat nom_de_la_fonction (liste_de_paramètres){corps_de_la_fonction}

Si le type_de_résultat n'est pas déclaré, la fonction est supposée retourner un int. Une fonction ne peut pas être définie dans une autre fonction. Le corps de la fonction

JCG 10/21


commence par la déclaration des variables locales à la fonction. Une variable locale déclarée static conservera sa valeur d'un appel à l'autre de la fonction. Une instruction return terminera l'exécution de la fonction. Il peut y avoir plusieurs instructions return dans une même fonction (mais une seule sera exécutée).

return; terminera la fonction sans transmettre de valeurreturn expr; terminera la fonction en retournant exprUne fonction ne peut retourner qu'un seul résultat de type simple (caractère, entier,

flottant, pointeur).

Une fonction peut être appelée dans une instruction ou dans une expression .Si c'est une instruction, sa valeur de retour est ignorée. Si c'est une expression, sa valeur

de retour est utilisée pour l'évaluation de l'expression. Une fonction peut s'appeler elle-même (appel récursif). Lors de l'appel, les arguments réels (ceux du programme appelant) sont copiés

dans l'ordre dans les paramètres formels (les arguments de la déclaration). Les valeurs transmises peuvent donc être modifiées sans que les paramètres réels soient modifiés.

Par exemple, int fac1(int n){ int i, res; res =1; for(i=2;i<=n;i++) res = i * res; return res;}

int fac2(int n) { int res; res = 1; for(n;n>=2;n--) res*=n; return res;}

int fac3(int n){ if (n<=1) return 1; else return n*fac3(n-1);}

L'appel à ces fonctions se fera, par exemple, de la manière suivante :a = 5; b = 2;x = fac1(a) / fac2(b) / fac3(a-b);

La première fonction est écrite dans un style classique.La deuxième se sert du fait que les paramètres ne sont transmis que par valeur, et que n

peut servir à la fois de compteur de boucle et de test.La troisième utilise la récursivité.

Attention :Le langage C ne transmet les paramètres de fonction que par copie. Si une modification

intervient dans la fonction, elle n'aura d'effet que sur la copie, pas sur l'original.Pour modifier la valeur d'un paramètre par l'intermédiaire d'une fonction, on transmet

l'adresse du paramètre à modifier, et on réceptionne cette adresse dans un pointeur.void triple(int *a) {*a *= 3;}int x=2;triple(&x); /* x vaut maintenant 6 */

JCG 11/21


3 Les types composés et les pointeurs

3.1 Les tableauxUn tableau est un ensemble de variables de même type.int a[4] ; déclare 4 variables de type int : a[0], a[1], a[2] et a[3].

Les éléments d'un tableau sont des l_values et peuvent donc apparaître à gauche d'une affectation.

Un tableau à deux dimensions est déclaré comme ceci :char ecran[24][80];

déclare un tableau de 24 lignes (de 0 à 23) de 80 caractères (de 0 à 79).ecran[i][j]

désignera le caractère j de la ligne i.

Dans les appels de fonctions, la valeur transmise pour un tableau est l'adresse du premier élément de ce tableau.

Par exemple, les chaînes de caractères étant des tableaux de caractères terminés par '\0', on peut écrire le programme suivant :

/* recopie la ch2 dans ch1 */void copie_chaine(char ch1[], char ch2[]) {/*la taille d'un tableau n'est ici pas nécessaire */ int i; for (i=0; ((ch1[i] = ch2[i]) != '\0' ; i++) ;/* le résultat de l'affectation sert au test */}

3.2 Les pointeurs

3.2.1 Définition

Un pointeur est une variable dont le contenu est l'adresse d'une l_value. Il est déclaré en précisant le type d'objet sur lequel il pointe :

int *pi;signifie que pi est destiné à contenir l'adresse d'un intUn pointeur peut être sans type. Dans ce cas, on le déclare par

void *p; 3.2.2 Opérations

L'opérateur * permet d'accéder à la valeur pointée.

JCG 12/21


L'opérateur & permet d'obtenir l'adresse d'une l_value.Par exemple,

int n,z;int *pn;

La déclaration a pour effet d'attribuer des emplacement mémoire aux variables, notées ici A1, A2 et A3 :

variable n z pnadresse mémoire A1 A2 A3

contenu indéterminé indéterminé indéterminé

pn = &n;En A3, on stocke la valeur A1 (l'adresse de n)


contenu indéterminé indéterminé A1

n = 3;En A1, on stocke 3


contenu 3 indéterminé A1

Les variables n et pn sont initialisées.

Voyons maintenant les opérations éventuelles :z = *pn;

*pn en tant que valeur signifie la valeur à l'adresse indiquée par le contenu de pnLe contenu de pn vaut A1. La valeur en A1 est 3, donc z vaut 3


contenu 3 3 A1

*pn = 5*pn, en tant que l_value signifie la l_value située à l'adresse indiquée par de pnpn vaut A1. A1 contiendra donc la valeur 5


contenu 5 3 A1

JCG 13/21


Pour un pointeur unique sur un type simple, les trois opérations possibles sont :pointeur = &l_value;/* modifie la valeur du pointeur */*pointeur = expr;/* modifie la valeur de l'objet pointé */l_value = *pointeur;/* évalue la valeur de l'objet pointé */

3.2.3 Pointeurs et tableaux

Pointeurs et tableaux sont très liés :char *cp; char colonne[80];cp = &tampon[0] ou cp = tampon

sont équivalentes. cp pointe sur le premier élément du tableau.

De même, cp = &tampon[4] ou cp = tampon + 4

sont équivalentes. cp pointe sur le cinquième élément du tableau

3.2.4 Arithmétique sur les pointeurs

L'arithmétique sur les pointeurs dépend du type pointé.Si p est un pointeur de type X, p+1 pointera sur l'élément suivant d'un tableau fictif de

X commençant en p.

3.2.5 Exemples de fonctions

void echanger(int *pi, int *pj) { int z; z = *pi; *pi = *pj; *pj =z;}

appelée par#include <stdio.h>int main() { int a=2, b=3; printf("Avant échange, a=%d b=%d\n", a, b); echanger(&a,&b); printf("Après échange, a=%d b=%d\n", a, b); return 0;}

JCG 14/21


void strcpy(char *ch1, char *ch2) {/* ch1 doit disposer d'assez de place pour

contenir ch2 */ while (*ch1++ = *ch2++) ;}

appelée par #include <stdio.h>int main() { char a[5] = "toto"; char *b = "titi"; printf("Avant copie, a=%s b=%s\n", a, b); strcpy(a, b); printf("Après copie, a=%s b=%s\n", a, b); return 0;}

3.2.6 Allocation dynamique de mémoire

Un pointeur n'est pas obligé d'être initialisé par l'affectation d'une adresse de l_value. L'allocation dynamique de mémoire permet de demander au système de la mémoire pour contenir des objets créés par le programme.

La fonction void *malloc(int n)

demande au système n octets contigus et retourne l'adresse de ces octets. ptr = malloc(100);

Cette mémoire peut être restituée par un appel à la fonction freefree(ptr);

rend la mémoire occupée par l'objet pointé par ptr.

3.3 Structures et unionsUne structure sert à regrouper des éléments de types différents. Par exemple,struct personne { char nom[20]; int age;}struct personne p[10], x, y;déclarera un tableau p de 10 personne et deux variables x et y de type personne.

Pour accéder à un des champs d'une structure, on utilise l'opérateur . (un point)x.nom sera le tableau de 20 caractères correspondant au nom de xx.age sera l'entier correspondant à l'age de x.strcpy(x.nom, "toto");x.age = 10;

JCG 15/21


Un pointeur peut pointer sur un objet de type structure :struct personne *pp;pp = &x;L'accès aux champs de la structure pointée se fait par l'opérateur -> :p->ageest équivalent à(*p).age On met des parenthèses, car . est plus prioritaire que * : *p.age <=> *(p.age) Les structures peuvent contenir des références à elles-mêmes par l'intermédiaire de

pointeurs :struct elt_liste { char c; struct elt_liste *suivant;};Dans ce cas, un élément de liste contiendra un caractère et un pointeur sur l'élément de

liste suivant.

Une union est semblable à une structure, dans le sens où elle contient des objets de types différents, mais un seul à la fois.

union nombre { int i; float r;} x;Les champs i et r seront deux façons de consulter ou de modifier le contenu de x.x.i = 2;x.r = 3.14;/* écrase la mémoire occupée par la valeur 3.14 */Attention : le langage C ne se souvient pas du type de la dernière valeur mémorisée

dans une union : c'est au programme de s'en souvenir.

4 Le préprocesseur CAvant de compiler un programme, le compilateur C lance un préprocesseur qui modifie

le texte de programme en fonction de directives ( les lignes commençant par #). Une de ses premières tâches est d'éliminer les commentaires (entre /* et */)

JCG 16/21


4.1 Constantes et macros#define identificateur objet

remplacera dans le texte du programme (sauf dans les chaînes de caractères) identificateur par objet (identificateur, constante, chaîne, opérateur, signe de ponctuation)

#define NB_COL 80#define ATTENTION_COL (NB_COL - 10)

Les parenthèses sont mises ici pour éviter que les remplacements dans le texte aient un effet non désiré.

if (ATTENTION_COL * 2 < 100) ....sera remplacé mot à mot

if ((NB_COL - 10) * 2 < 100) ....lui-même remplacé par

if ((80 - 10) * 2 < 100) ....L'effet aurait été différent sans les parenthèses

#define identificateur(arguments) chaîneremplacera toutes les occurrences de identificateur(....) par la chaîne

dans laquelle les arguments seront remplacés par les valeurs lues dans le programme :#define max(a,b) ( (a) > (b) ? (a) : (b) )

4.2 Inclusion de fichier#include "nom_fichier"

sera remplacé par le contenu du fichier, cherché dans le catalogue courant, puis dans les catalogues système

#include <nom_fichier>sera remplacé par le contenu du fichier, cherché dans les catalogues système

4.3 Compilation conditionnelleElle permet de disposer de sources qui pourront se compiler sur des machines et/ou des

compilateurs différents, à condition de distinguer les différences dans le texte du programme. #if condition texte1#else texte2#endif

permet de compiler l'un ou l'autre des textes suivant que la condition est vérifiée ou non.#ifdef identificateur texte#endif

Le texte ne sera compilé que si identificateur a fait l'objet d'une directive #define (même vide)

JCG 17/21


5 La bibliothèque standard du langage CÀ chaque fichier accédé par un programme est associé un ensemble de tampons

d'entrée-sortie. Le couple fichier-tampon est un flux (stream), désignée par un pointeur sur le type FILE, prédéfini dans stdio.h, qui définit également les trois pointeurs sur les flux généralement ouverts : stdin, stdout et stderr (entrée, sortie et sortie erreur standard), la constante NULL (absence de flux) et EOF (utilisée comme résultat lors de la fin de fichier).

5.1 La fonction printfint printf ("format", expr1, expr2, ....)

Précise un format (sous forme de chaîne de caractères) pour les données en sortie. Les éléments de la chaîne formats qui ne sont pas précédés de % sont sortis tels quels. Les formats disponibles sont les suivants :

format affichage sous forme%c caractère%d entier décimal%f flottant%o entier octal%s chaîne de caractères%u entier non signé%x entier hexadécimal%% le caractère %

Tableau 11 : formats de printf

Si # est un des formats ci-dessus,format affichage sous forme%l# type long%-# cadrage à gauche%3#f sur au moins trois positions%.12# • pour un entier, le nombre de

chiffres à afficher (ici 12)• pour un réel, le nombre de chiffres

de la partie décimale à afficher (avec arrondi)

• pour une chaînes, le nombre maximum de caractères à afficher.

Tableau 12 : préfixes des formats de printf

5.2 La fonction scanfint scanf("format",adr_var1, adr_var2, ....)

JCG 18/21


correspond à printf, mais pour les entrées. En plus, le préfixe de format * permet d'ignorer un champ d'entrée.

Par exemple,int i;float x;char nom[50];scanf("%d %f %s', &i, &x, nom);/* l'entrée 25 54.32e-1 Thompsonaffectera 25 à i, 5.432 à x et "Thompson" à nom */scanf(%2d %f %*d %2s", &i, &x, nom);/* l'entrée 56789 0123 45a72 affectera 56 à i,

789.0 à x, ignorera 0123, "45" à nom. Le prochain caractère lu sera 'a' */

JCG 19/21


Index des tableauxTableau 1 : les mots réservés du C..............................................................................................4Tableau 2 : les constantes caractères spéciales...........................................................................5Tableau 3 : les opérateurs arithmétiques.....................................................................................6Tableau 4 : les comparateurs arithmétiques................................................................................6Tableau 5 : les opérateurs d'égalité.............................................................................................6Tableau 6 : les opérateurs de décalage........................................................................................7Tableau 7 : les opérateurs bit à bit..............................................................................................7Tableau 8 : les opérateurs logiques.............................................................................................7Tableau 9 : les opérateurs unaires...............................................................................................8Tableau 10 : priorités des opérateurs..........................................................................................9Tableau 11 : formats de printf...................................................................................................18Tableau 12 : préfixes des formats de printf...............................................................................19

Table des matières 1 La syntaxe C....................................................................................................4

1.1 Les règles d'écriture..........................................................................4 1.1.1 Commentaires et espaces...................................................4 1.1.2 Les identificateurs..............................................................4 1.1.3 Les types simples...............................................................4 1.1.4 Les constantes....................................................................5 1.1.5 Les variables......................................................................6

1.2 Les expressions et les opérateurs......................................................6 1.2.1 Les opérateurs arithmétiques.............................................6 1.2.2 Les opérateurs relationnels................................................6 1.2.3 Les opérateur d'égalité et d'inégalité..................................6 1.2.4 Les opérateurs de décalage................................................6 1.2.5 Les opérateurs bit à bit.......................................................7 1.2.6 Les opérateurs logiques.....................................................7 1.2.7 L'opérateur virgule ............................................................7 1.2.8 Les opérateurs d'affectation...............................................7 1.2.9 L'opérateur conditionnel....................................................7 1.2.10 Les opérateurs unaires.....................................................8 1.2.11 La conversion de type......................................................8 1.2.12 Priorité et ordre d'évaluation............................................8

2 Le contrôle du programme..............................................................................9 2.1 Les instructions de contrôle..............................................................9

2.1.1 L'instruction if....................................................................9 2.1.2 L'instruction switch............................................................9 2.1.3 Les itérations ...................................................................10

2.2 Les fonctions...................................................................................10

JCG 20/21


3 Les types composés et les pointeurs .............................................................12 3.1 Les tableaux....................................................................................12 3.2 Les pointeurs...................................................................................12

3.2.1 Définition.........................................................................12 3.2.2 Opérations........................................................................12 3.2.3 Pointeurs et tableaux .......................................................14 3.2.4 Arithmétique sur les pointeurs.........................................14 3.2.5 Exemples de fonctions.....................................................14 3.2.6 Allocation dynamique de mémoire..................................15

3.3 Structures et unions.........................................................................15 4 Le préprocesseur C........................................................................................17

4.1 Constantes et macros......................................................................17 4.2 Inclusion de fichier.........................................................................17 4.3 Compilation conditionnelle............................................................18

5 La bibliothèque standard du langage C.........................................................18 5.1 La fonction printf............................................................................18 5.2 La fonction scanf............................................................................19

JCG 21/21

Le langage C - perso.esiee.frlandschm/IN3T01/Abrégé de langage C ESIEE... · ESIEE 2010/2011...

Documents

Transcript of Le langage C - perso.esiee.frlandschm/IN3T01/Abrégé de langage C ESIEE... · ESIEE 2010/2011...