Programmation en langage C Eléments de syntaxe - irit.frIsabelle.Ferrane/SUPPORTS_COURS/L2_SI_Poly_C... · Programmation en langage C Eléments de syntaxe Université Paul Sabatier

Programmation en

langage C

Eléments de syntaxe

Université Paul Sabatier IUP Systèmes Intelligents – L2

Module Informatique de base 2 Initiation à la programmation en langage C

Isabelle Ferrané

Université Paul Sabatier IUP Systèmes Intelligents – 1ère année

Informatique Générale – Langage C 2 Isabelle Ferrané

SOMMAIRE

I- Concepts fondamentaux du Langage C ....................................................................................................... 4

I-1. Le jeu de caractères...................................................................................................................................... 4 I-2. Identificateurs et mots clés .......................................................................................................................... 4 I-3. Les types de données .................................................................................................................................... 4 I-3.1. Le type entier : int................................................................................................................................... 5 I-3.2. Le type caractère : char .......................................................................................................................... 5 I-3.3. Les types flottants : float et double .................................................................................................. 5 I-4. Les constantes ou littéraux .......................................................................................................................... 6 I-4.1. Les valeurs entières ................................................................................................................................... 6 I-4.2. Les valeurs flottantes................................................................................................................................. 6 I-4.3. Les caractères............................................................................................................................................. 6 I-4.4. Les chaînes de caractères.......................................................................................................................... 7 I-5. Les variables et les tableaux........................................................................................................................ 7 I-5.1. Déclaration de variable simple ou de tableau........................................................................................ 8 I-5.2. Initialisation de variable simple ou de tableau ...................................................................................... 9 I-6. Les expressions............................................................................................................................................ 10 I-6.1. Expressions et opérateurs arithmétiques ............................................................................................. 10 I-6.2. Expressions et opérateurs relationnels ................................................................................................. 11 I-6.3. Expressions et opérateurs logiques ....................................................................................................... 11 I-6.4. Opérateurs d'affectation......................................................................................................................... 12 I-6.5. Priorité des opérateurs............................................................................................................................ 12 I-6.6. Opérateurs pour la manipulation de données binaires...................................................................... 13 I-7. Les instructions ........................................................................................................................................... 13 I-7.1. Instructions simples................................................................................................................................. 13 I-7.2. Instructions composées ou bloc d'instructions .................................................................................... 13 I-7.3. Instructions de contrôle .......................................................................................................................... 14

II-. Structure d'un programme en langage C................................................................................................ 19

II-1. Les directives.............................................................................................................................................. 19 II-1.1. Inclusion de fichiers ............................................................................................................................... 19 II-1.2. Définition de constantes symboliques ................................................................................................. 20 II-1.3. Compilation conditionnelle................................................................................................................... 20 II-2. Les déclarations......................................................................................................................................... 20 II-3. Les définitions de données ....................................................................................................................... 21 II-4. Les définitions de fonctions...................................................................................................................... 21 II-5. La fonction principale : main ................................................................................................................. 23

III. Les bibliothèques de fonctions standards................................................................................................ 23

III-1. Utilisation des fonctions standards ....................................................................................................... 24 III-2. La bibliothèque de fonctions standard stdio.h .............................................................................. 24 III-2.1 Les entrées-sorties de caractères ......................................................................................................... 24 III-2.2 Les entrées-sorties de chaînes de caractères...................................................................................... 25 III-2.3 Les entrées-sorties formatées............................................................................................................... 25 III-2.4 Les Entrées-Sorties dans un fichier .................................................................................................... 29 III-3 Autres bibliothèques et fonctions standards......................................................................................... 34



III.3.1. Fichier math.h : Fonctions mathématiques.................................................................................... 34 III.3.2. Fichier string.h : Manipulation de chaînes de caractères. ....................................................... 35 III.3.3. Fichier ctype.h : Fonctions testant la nature d'un caractère. .................................................... 35 III.3.4. Fichier stdlib.h................................................................................................................................ 36 III.3.5. Autres bibliothèques à connaître........................................................................................................ 37

IV- Bibliographie ............................................................................................................................................... 38



I- Concepts fondamentaux du Langage C

I-1. Le jeu de caractères Lettres : a, ..., z, A, ..., Z

Chiffres : 0,1,...,9

Caractères spéciaux : ! + - * / % < > ( ) { } [ ] ~ # = ; , : ^ \ ' " . | & _ ? espace

Commentaires : /* ceci est un commentaire */

I-2. Identificateurs et mots clés Identificateur : suite de caractères alphanumériques incluant

éventuellement le blanc souligné et commençant obligatoirement par une lettre (ex : var1, id_var).

Mots-clés : mots réservés qui ont une signification prédéfinie en C et qui ne peuvent pas être utilisés comme identificateur.

auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while

I-3. Les types de données

Type : définit un domaine de validité de données (valeurs et opérations possibles). Il se caractérise par une représentation mémoire spécifique dont la taille dépend du compilateur.

4 types scalaires prédéfinis : int, char, float et double

REMARQUES : (1) Le type booléen n'existe pas en C. La valeur de vérité FAUX est représentée par la valeur numérique 0 et VRAI par 1 (ou toute valeur différente de 0).



(2) Le type void est un type prédéfini qui a la particularité de ne pas avoir de taille. Il est utilisé généralement pour indiquer l'absence de données (cf. §II.4. définition de fonctions). I-3.1. Le type entier : int

Représentation mémoire d'une valeur entière : 2 ou 4 octets Intervalle des valeurs entières (sur 2 octets) -32768...+32767 Spécificateurs de type :

short et long

modifient la taille de la représentation mémoire d'un entier tout vérifiant l'inégalité suivante

sizeof(short) ≤ sizeof(int) ≤ sizeof(long) REMARQUE : l'opérateur sizeof appliqué à un type renvoie le

nombre d'octets occupés par toute valeur appartenant à ce type. unsigned

la taille de la représentation mémoire n'est pas modifiée, mais le bit de signe est utilisé comme un chiffre significatif.

sur 2 octets : int -32768 ... +32767 unsigned int 0 ... +65535 REMARQUE : le spécificateur unsigned peut être combiné avec

short et long.

I-3.2. Le type caractère : char Représentation mémoire d'un caractère : 1 octet

Chaque donnée de type caractère a un équivalent entier qui correspond au code ASCII du caractère.

Intervalle des valeurs des codes ASCII : 0 ...+255 ou -128 ...+127

I-3.3. Les types flottants : float et double

Représentation mémoire d'un nombre flottant : 4 octets (soit 24 bits pour la mantisse et 8 pour la partie exposant)

Représentation d'un nombre flottant double précision : 8 octets



I-4. Les constantes ou littéraux

I-4.1. Les valeurs entières

3 notations possibles :

décimale (base 10 : 0..9) ex : 15 octale (base 8 : 0..7) ex : 017 hexadécimale (base 16 : 0..9,A..F) ex : 0xF ou 0XF

Notation avec spécificateurs de type :

short int ex : 15 long int ex : 15L unsigned int ex : 15U ou 017U unsigned long int ex : 15UL ou 0xFUL

REMARQUE : avec les spécificateurs de type, le mot-clé int peut être omis.

I-4.2. Les valeurs flottantes

Elles contiennent un point décimal et/ou un exposant. Exemple :

12.3, 123E-1, 1.23E1 I-4.3. Les caractères

Notation classique :

un caractère est exprimé entre quotes (' ') ou bien représenté par son code ASCII, ici entre parenthèse. Exemple :

'A' (65) '$' (36) ' ' (32) caractère espace

Notation symbolique pour les caractères non visualisables :

sonnerie \a retour arrière \b tabulation horiz. \t tab. verticale \v retour à la ligne \n nouvelle page \f retour chariot \r caractère nul \0



REMARQUE : une notation équivalente utilise la valeur octale du code ASCII associé au caractère : \t équivaut à \11. Dans ce cas la notation octale n'est pas précédée du marqueur 0.

ATTENTION ! : le caractère nul '\0' est le caractère de code ASCII zéro. Ne pas confondre avec la lettre O ni avec le chiffre zéro (code ASCII 48).

Notation symbolique pour les caractères spéciaux :

guillemet \" point d'interrogation \? quote \' back slash \\

Précédés du caractère \ , les caractères spéciaux sont interprétés comme de simples caractères.

I-4.4. Les chaînes de caractères

Une chaîne de caractères est représentée par une suite de caractères délimitée par des guillemets. Elle peut comporter des caractères non visualisables et des caractères spéciaux :

"" /* représente la chaîne vide */ "chaîne de caractères" "\"chaîne entre guillemets\"" "retour_a_la_ligne\n"

ATTENTION ! : le compilateur place automatiquement le caractère '\0' à la fin de chaque chaîne de caractères.

ex : "chaine" comporte 6 caractères visualisables et est stockée sur 7 caractères : 'c' 'h' 'a' 'i' 'n' 'e' '\0'

I-5. Les variables et les tableaux

Variable : identificateur qui désigne une information d'un type donné. La valeur d'une variable peut être modifiée au cours du programme. Par contre, le type de la variable spécifié lors de sa déclaration est fixé une fois pour toute.

variable simple désigne des données élémentaires : entier, caractère, réel, …



variable composée regroupe un ensemble de données : tableau, structure, union,

énumération.

Tableau : variable composée représentant un ensemble de valeurs de même type. Chaque valeur ou élément du tableau est identifiée au moyen d'un indice.

Si TAB est le nom du tableau alors TAB[i] désigne

l'élément d'indice i ATTENTION ! : si N est la taille du tableau alors l'indice prend obligatoirement ses valeurs dans l'intervalle 0..N-1.

Si TAB est le nom du tableau, alors TAB[0] désigne le premier élément du tableau et TAB[N-1] le dernier.

Tableau multidimentionnel : un tableau peut avoir plusieurs dimensions. Il

est alors défini comme un tableau d'éléments qui sont eux-mêmes des tableaux.

Si TAB est un tableau à 2 dimensions DIM1 et DIM2, alors, pour toute valeur de i comprise entre 0 et DIM1-1, TAB[i] est un tableau unidimentionnel comportant DIM2 éléments, désignés par TAB[i][j] avec j compris entre 0 et DIM2-1.

I-5.1. Déclaration de variable simple ou de tableau

Toute variable simple ou composée utilisée dans un programme C doit avoir préalablement été déclarée. Une déclaration associe une variable ou un groupe de variables à un type de données. Déclaration d'une variable simple :

TYPE nom_variable ;

Déclaration d'un tableau à une (1) ou N dimensions (2) :

(1) TYPE nom_tableau [taille]; (2) TYPE nom_tableau [t1][t2]...[tN];



IMPORTANT : la taille d'un tableau spécifie le nombre maximum d'éléments par dimension considérée. Elle doit être une constante entière strictement positive. Ne pas utiliser une variable pour la définir. Exemple de déclaration :

int tab[5], indice, i, j, k; char car, chaine[20]; float x, y, nb_reels[10][5];

tab est un tableau de 5 entiers, chaine un tableau de 20 caractères et nb_reels un tableau à 2 dimensions (10 lignes x 5 colonnes), chaque élément étant un nombre flottant.

I-5.2. Initialisation de variable simple ou de tableau

Opération qui consiste à attribuer une valeur initiale à une variable lors de sa déclaration.

Initialisation d'une variable simple :

TYPE nom_variable = val_initiale ;

Exemple d'initialisation :

int indice = 0 ; char car = '$' ; float x = 0.0, y = 0.0 ; long int res = 0L ;

Initialisation d'un tableau :

TYPE nom_tab [ ] = { ens_val_initiales } ; REMARQUE : Dans ce cas seulement, on peut ne pas spécifier la taille du tableau, celle-ci est alors déduite de la taille de la valeur initiale attribuée.

Exemple d'initialisation :

int filtre_binaire [] = {0, 1, 0, 0, 1} ; char chaine[] = "initialisation" ; char voyelle[6] = {'a','e','i','o','u','y'} ; float matrice[2][2] = { {0.0, 1.0} {1.0,0.0} };

filtre_binaire est un tableau de 5 entiers et chaine un tableau de 15 caractères (14 visualisables + 1 marquant la fin de chaîne).



I-6. Les expressions

Expression : représente une donnée élémentaire (nombre ou caractère). expression simple

désigne une seule entité : constante, variable, élément de tableau ou appel à une fonction : 5, X, T[i], f(X), ...

expression complexe

combinaison d'entités appelées opérandes et reliées par des opérateurs : X + 5, Y > (Z+2),...

Conversion implicite : effectuée automatiquement si les opérandes ne sont

pas de même type mais de type compatible. Ex : float X = 0 ; /* 0 --> 0.0 */

Conversion explicite : (ou cast) expression typée qui indique que la valeur

de l'expression doit être convertie dans le type spécifié avant d'être utilisée.

(TYPE) expression

ATTENTION ! : lors d'une conversion implicite ou explicite, le type de l'expression n'est pas modifié, seule sa valeur est convertie. Exemple :

float MOY = 0.0; int A = 15, B = 26;

MOY = (float) (A + B) / 2;

Le résultat de l'expression A + B est converti explicitement en valeur flottante (41 --> 41.0). La valeur 2 fait alors l'objet d'une conversion implicite (2 --> 2.0). Ainsi MOY récupère 20.5 au lieu de 20.0.

I-6.1. Expressions et opérateurs arithmétiques

Opérateurs binaires (2 opérandes) :

+ addition - soustraction * multiplication / division entière ou réelle

% modulo ou reste de la division entière



ATTENTION ! : contraintes de type : les opérandes doivent représenter des valeurs numériques. - L'opérateur % n'admet que des opérandes de type entier. - Si les 2 opérandes de l'opérateur / sont des entiers alors le résultat

obtenu est le quotient de la division entière. REMARQUE : si c1 et c2 sont des variables de type caractère (char) alors c1+c2 (resp. c1-c2) revient à faire la somme (resp. la différence) des codes ASCII. Exemple : 'B'-'A' --> 1

Opérateurs unaires (1 opérande) :

- valeur opposée ex : Y = -X ; ++ incrémentation ex : I++ ou ++I -- décrémentation ex : I-- ou --I

ATTENTION ! : La position des 2 opérateurs ++ et -- joue un rôle dans l'évaluation du résultat.

I-6.2. Expressions et opérateurs relationnels

Ces opérateurs sont utilisés pour construire des expressions logiques traduisant des conditions vraies ou fausses :

FAUX valeur égale à 0 ; VRAI 1.

opérateurs relationnels :

< inférieur > supérieur <= inférieur ou égal >= supérieur ou égal

opérateurs de comparaison :

== égalité != différent

I-6.3. Expressions et opérateurs logiques

Ces opérateurs permettent la combinaison (et, ou) ou la négation (non) d'expressions logiques (cf. § I-6.2). Toute condition dont la valeur est différente de zéro est considérée comme vraie.

Opérateurs binaires :

&& et logique || ou logique

Opérateur unaire :

! non logique



I-6.4. Opérateurs d'affectation

Affectation simple :

nom_var = expression ; ATTENTION ! : Ne pas confondre cet opérateur avec l'opérateur testant l'égalité de 2 expressions (==). REMARQUE : Une expression d'affectation renvoie la valeur affectée après conversion si nécessaire. On peut donc la trouver dans une expression plus complexe.

while ( c = getchar() ) != '$' ) ... c reçoit la valeur du caractère saisi au clavier. Cette valeur est ensuite comparée au caractère $.

Affectation combinée :

nom_var = nom_var + expression ;

peut se réécrire nom_var += expression ;

Même chose avec les autres opérateurs arithmétiques binaires :

- * / % utilisés dans des affectations peuvent se réécrire respectivement -=, *=, /=, %= .

I-6.5. Priorité des opérateurs

Priorité maximale

- ++ -- ! (TYPE) opérateurs unaires * / % - + < <= > >= == != && || = += -= *= /= %= affectations

Priorité minimale



I-6.6. Opérateurs pour la manipulation de données binaires

Opérateur unaire (opérande entier) :

~ complément à un

Opérateurs binaires (opérandes de type entier) :

& et binaire | ou binaire ^ ou exclusif binaire

>> décalage à droite << décalage à gauche

Dans les opérations de décalage, le second opérande doit être un entier non signé. Ces opérateurs peuvent également être combinés avec l'opérateur d'affectation ( &=, |=, ^=, >>=, <<= ).

I-7. Les instructions

. Instruction : il existe 3 catégories d'instructions pour traduire une action plus ou moins complexe : les instructions simples, les instructions composées et les instructions de contrôle.

I-7.1. Instructions simples

Toute instruction simple se termine par un ; . Il s'agit généralement d'une expression d'affectation ou d'un appel à un sous-programme.

Exemple d'instructions simples :

a = 3 ; c = a + b ; i++ ; j += i ; printf("resultat = %d\n", c) ; ; /* instruction vide ou nulle */

I-7.2. Instructions composées ou bloc d'instructions

Ensemble d'instructions (simples et/ou composées et/ou de contrôle) encadré par des accolades ( {...} ) et appelé généralement bloc d'instructions.



Exemple de bloc d'instructions :

{ /* debut de bloc */ printf("Message d'erreur") ; traiter_erreur (); } /* fin de bloc : pas de ; */

I-7.3. Instructions de contrôle

Elles traduisent les structures de contrôle et permettent de réaliser certaines fonctionnalités comme les tests logiques, les boucles et les sélections.

I-7.3.1. L'instruction if else

Utilisée pour les tests et les expressions conditionnelles.

. Test simple :

if (expression) instruction

expression expression logique simple (variable, appel de fonction, ...) ou complexe (conjonction et/ou disjonction et/ou négation de condition)

instruction instruction (simple, composée ou de contrôle) qui n'est exécutée que si expression est vraie (=> valeur différente de 0), sinon elle est ignorée.

ATTENTION ! : En langage C il n'y a pas de mot-clé then

Exemples de tests :

if ( Y != 0 ) X = X/Y ; if (trouve_solution) printf("OK !"); if ( (X>0) && (Y>0) ) { printf("OK !"); Z = X % Y; }

. Test avec alternative :

if (expression) instruction_1

else instruction_2



La clause ELSE exprime une alternative. instruction_1 et instruction_2 sont des instructions qui seront exécutées en fonction de la valeur de vérité de expression .

Si expression est vraie (valeur différente de 0) alors instruction_1 est exécutée et instruction_2 ignorée. Sinon (expression vaut 0) instruction_2 est exécutée et instruction_1 ignorée.

Exemple de tests avec alternative :

if ( Y != 0 ) X = X/Y ; else printf("Division par zero \n");

ATTENTION ! : On peut imbriquer plusieurs instructions de ce type, mais il faut faire attention aux ambiguïtés, c'est-à-dire savoir à quel if se rapporte un else.

Opérateur conditionnel ? : :

Certaines alternatives simples peuvent s'écrire au moyen d'un opérateur plutôt qu'avec l'instruction if else.

(expression_1) ? expression_2 : expression_3 ;

équivaut à if (expression_1) expression_2 ; else expression_3 ;

Exemple d'utilisation de l'opérateur conditionnel :

if ( A < B ) MIN = A ; else MIN = B ;

se traduira par

MIN = ( A < B ) ? A : B ;

I-7.3.2. L'instruction while

Permet la construction de boucles (exécution itérative d'une instruction tant qu'une condition est vérifiée)

while (expression) instruction La partie instruction est exécutée tant que expression est vraie (valeur différente de 0).



IMPORTANT : Pour "entrer" dans la boucle il faut s'assurer que la condition exprimée par expression est vraie. On "sort" de la boucle lorsque la condition correspondant à expression est fausse. La partie instruction doit donc obligatoirement modifier à un moment donné la valeur de l'expression sinon la boucle sera infinie !

ATTENTION ! : Il n'y a pas de mot-clé do associé à une boucle while

Exemple de boucle WHILE:

/* programme d'affichage de 10 chiffres */ #include <stdio.h> void main(void)

{ int chiffre = 0; while( chiffre <= 9) { printf("%d\n", chiffre); chiffre++; } }

I-7.3.3. L'instruction do while

Autre type de boucle ayant pour rôle de répéter l'instruction tant que la condition posée par l'expression est vraie.

La seule différence qui existe entre une boucle WHILE et une boucle DO WHILE est que, dans le premier cas, le test est fait avant de rentrer dans la boucle et dans le second il est fait après le premier passage. Par conséquent, la partie instruction d'une boucle DO WHILE est exécutée au moins une fois.

do instruction while (expression) ;

Exemple de boucle DO WHILE:

/* programme d'affichage de 10 chiffres */ #include <stdio.h>

void main(void) { int chiffre = 0;

do printf("%d\n", chiffre++); while ( chiffre <= 9) ;

} I-7.3.4. L'instruction for



Troisième type de boucle existant. Il permet d'exécuter de manière itérative une instruction un nombre donné de fois.

for (expression_1 ; expression_2 ; expression_3)

instruction

expression_1 initialise la variable de boucle (affectation) ; expression_2 représente la condition à satisfaire pour exécuter la

partie instruction. (attention! : ce n'est pas l'expression de la condition d'arrêt).

expression_3 sert à modifier la variable de boucle

(incrémentation, décrémentation ou affectation). instruction séquence de code à exécuter plusieurs fois. ATTENTION ! : Pas de mot-clé do dans un for. Une boucle for est totalement équivalente à une séquence de code incluant une boucle while (cf exemple §I.7.3.2).

Exemple de boucle FOR :

/* programme d'affichage de 10 chiffres */ #include <stdio.h> void main(void)

{ int chiffre; for (chiffre = 0 ; chiffre <= 9 ; chiffre++) printf("%d\n", chiffre); }

I-7.3.5. L'instruction switch

Ce type d'instruction permet le branchement sur un groupe d’instructions à partir d’un point d’entrée qui est fonction de la valeur de l’expression.



switch (expression) { case valeur1 : suite_instructions_1 case valeur2 : suite_instructions_2 ... case valeurN-1 : suite_instructions_N-1 case valeurN : suite_instructions_N } ATTENTION ! : Si la valeur de l’expression est égale à valeur1, toutes les séquences d’instructions (1 à N) sont exécutées successivement. Si la valeur de l’expression correspond à l’avant dernier case, seules les 2 dernières suites d’instructions sont exécutées successivement, etc.

L'instruction break provoque la sortie du bloc d’instructions dans lequel elle se trouve. L’utilisation systématique de l’instruction break dans une instruction switch, permet de n’exécuter que la suite d’instructions correspondant réellement au case.

switch (expression) { case valeur1 : suite_instructions_1 break; case valeur2 : suite_instructions_2 break; ... default : suite_instructions_N } expression est évaluée et doit renvoyer un entier ou un caractère. La valeur obtenue détermine alors directement la suite_instructions à exécuter.

Si aucune valeur ne correspond, aucune séquence d'instructions n'est exécutée à moins qu'une clause default ait été définie. Dans ce cas, ce sont les instructions associées qui sont exécutées.

On peut exprimer le fait qu'une séquence d'instructions soit commune à plusieurs valeurs comme le montre l'exemple suivant.



REMARQUE : Ce type d'instruction est plus clair qu'une suite de if else imbriqués.

Exemple de SWITCH : ... printf("Voulez-vous continuer ?: "); switch( choix = getchar() ) { case 'o' : case 'O' : fin = 0; break; case 'n' : case 'N' : fin = 1; break; default : printf("Repondre par o / n "); } ...

II-. Structure d'un programme en langage C

Un programme en langage C se décompose généralement en plusieurs parties.

II-1. Les directives

Ces directives débutent par le caractère # et s'adressent au préprocesseur. Celui-ci opère juste avant la phase de compilation proprement dite. Son rôle est de remplacer chaque directive par ce qu'elle représente. II-1.1. Inclusion de fichiers

#include Le contenu du fichier mentionné sera inclus dans le fichier source. Il s'agit en général d'un fichier contenant des déclarations de fonctions et de variables externes.

Si le fichier inclus correspond à une bibliothèque de fonctions standards, son nom doit être spécifié entre < et > :

#include <stdio.h> S'il s'agit d'un autre type de fichier, son nom sera donné entre guillemets :

#include "mon_fichier.h"



II-1.2. Définition de constantes symboliques

#define permet la définition d'une constante symbolique. Avant la compilation, chaque occurrence de celle-ci est remplacée par la valeur qui lui a été associée.

#define NOM_CONST valeur Dans d'autres cas cette directive permet simplement de définir une constante comme existante. Son existence pourra être testée avec les directives conditionnelles #ifdef ou #ifndef

II-1.3. Compilation conditionnelle

#if, #ifdef, #ifndef, #elif, #else, #endif, ... Groupe de directives qui permettent de faire de la compilation conditionnelle. Dans l'exemple suivant, la valeur attribuée à la constante symbolique CST est différente suivant la version du programme utilisée :

#if VERSION == 1 #define CST 10 #elif VERSION == 2 #define CST 20 #else #define CST 15 #endif

Elles permettent également d'éviter les inclusions multiples d'un même fichier lorsque l'on fait de la programmation modulaire. Tout fichier pouvant être inclus plusieurs fois devra alors débuter par :

#ifndef FIC_INCLUS #define FIC_INCLUS /* partie à inclure */ #endif

II-2. Les déclarations

En langage C, tout objet, que ce soit une constante, une variable ou une fonction, doit être défini avant d'être utilisé. Cependant, certains problèmes de visibilité peuvent se poser lorsque :



- la définition se trouve dans le même fichier mais après la partie de code utilisant l'objet en question (référence "en avant"); - la définition se trouve dans un autre fichier source ou unité de compilation, faisant partie du même programme (compilation séparée).

Dans ces 2 cas, il est indispensable d'inclure, avant toute utilisation, une déclaration indiquant au compilateur que l'objet utilisé est défini ailleurs : soit ultérieurement dans le même fichier, soit dans un autre fichier.

II-3. Les définitions de données

Définir un objet consiste à donner toutes ses caractéristiques : le type, le nom, la taille lorsqu'il s'agit d'un tableau, et éventuellement la valeur initiale. Exemple :

/* définition d'une constante */ const float C1 = 15.5 ;

/* définition de variables */ int TOTAL = 0, RES1, RES2 ; /* définition de tableaux */ char ch_res[10], message [] = "*** ERREUR ***";

A la différence d'une déclaration, qui n'est qu'un rappel de l'existence d'un objet, une définition associe un identificateur à un objet et s'accompagne généralement d'une allocation de l'espace mémoire nécessaire pour stocker la valeur de la donnée. Le programmeur a également la possibilité de définir un type avec le mot-clé typedef. Dans ce cas il s'agit plutôt d'un "renommage" et ne provoque pas d'allocation mémoire. II-4. Les définitions de fonctions

Le rôle d'une fonction est d'effectuer une tâche précise, à la demande d'une autre partie du programme. La fonction appelée et la partie appelante peuvent avoir à communiquer (échange d'informations). Chaque définition de fonction comporte donc 2 parties :



la spécification : cette partie rassemble les informations concernant l'interface de la fonction avec la partie appelante : nom de la fonction, type de la valeur renvoyée et liste des paramètres formels.

le corps : il s'agit d'un bloc d'instructions comportant généralement une instruction return et correspondant au travail effectué par la fonction

Syntaxe incluant la notion de prototypage de fonction (C norme Ansi) Si la fonction admet un ou plusieurs paramètres, la liste typée comportant le type et le nom de chaque paramètre formel doit être spécifiée entre parenthèses dans l’entête de la fonction (1). Si aucun paramètre n’est nécessaire le mot clé void est spécifié entre parenthèses (2). (1) type_retour nom_fonction ( type1 nom1, ... typeN nomN) { /* définition de variables locales */ ... /* instructions */ ... }

(2) type_retour nom_fonction ( void ) { /* définition de variables locales */ ... /* instructions */ ... }

L'intérêt du prototypage est de permettre au compilateur de contrôler la bonne utilisation d'une fonction. Ce contrôle porte sur le type de la valeur de retour ainsi que sur la cohérence des paramètres effectifs par rapport aux paramètres formels spécifiés dans la définition de la fonction (nombre et type). Sans ce contrôle les erreurs se produiront lors de l'exécution du programme.

IMPORTANT : lorsqu'une fonction n'est pas destinée à renvoyer une valeur, type_retour doit être défini comme void.



Exemple : void f1 (void)

f1 est définie comme ne renvoyant rien et n'admettant pas de paramètres.

II-5. La fonction principale : main

Indispensable dans un programme C, ce nom prédéfini indique qu'il s'agit du point d'entrée du programme. L'exécution du programme commencera toujours par l'exécution du code de la fonction main. Le corps de cette fonction ne comporte pas d'instruction return.

void main(void) { /* définition de variables locales */

... /* instructions */ ...

} REMARQUE : cette fonction peut éventuellement être paramétrée (selon une syntaxe spécifique), les valeurs des paramètres seront alors fournies lors de l'appel du programme. L’interface ou entête est alors : void main(int argc, char **argv) argc représente le nombre de paramètres et argv est un pointeur de pointeur de caractères et pointe sur le premier pointeur qui donne accès à la chaîne de caractères correspondant au premier argument fourni lors de l’appel du programme. La structure argv est créée et gérée par UNIX (lien avec la variable shell argv) le programme ne fait que l’utiliser. La fonction main peut également renvoyer un code de retour. A ce moment-là, le type de la valeur de retour n’est plus void mais int.

int main(void)

III. Les bibliothèques de fonctions standards



Différentes bibliothèques de fonctions standards sont à la disposition des développeurs de programmes en langage C. Chacune d’elles est dédiée à un type d’utilisation particulier et est constituée d’un fichier .h.

Exemple :

stdio.h : fonctions de gestion des entrées-sorties math.h : fonctions mathématiques string.h : fonction de gestion des chaînes de caractères …

Ces fichiers contiennent généralement : - les directives définissant les constantes symboliques utilisées (ex :

NULL, RAND_MAX, …); - les définitions de structures et de types utilisés par les fonctions de la

bibliothèque (FILE, …); - le prototypage des fonctions.

III-1. Utilisation des fonctions standards

Pour pouvoir utiliser une fonction standard, il faut inclure le fichier correspondant à la bibliothèque contenant la déclaration de la fonction Pour cela il faut utiliser la directive #include (cf. § II-1).

La première bibliothèque dont on a besoin dans un programme est celle permettant l'échange d'informations entre la machine et les dispositifs d'entrées-sorties (clavier, écran, fichiers textes, fichiers binaires, …) : la bibliothèque stdio.h

III-2. La bibliothèque de fonctions standard stdio.h Certaines des fonctions de cette bibliothèque lisent sur l'entrée standard ou écrivent sur la sortie standard. D'autres permettent le transfert d'informations depuis ou vers des fichiers de données. Ce paragraphe concerne les fonctions directementliées aux entrée-sorties standards.

III-2.1 Les entrées-sorties de caractères

la fonction getchar

int getchar()

Lit un caractère sur l'entrée standard (clavier par défaut) et renvoie le code ASCII du caractère lu (int)



la fonction putchar

int putchar( char c)

Ecrit sur la sortie standard (écran par défaut) le caractère c donné en paramètre et renvoie le code ASCII du caractère écrit (int)

III-2.2 Les entrées-sorties de chaînes de caractères

la fonction gets

char * gets( char * ch)

Lit une suite de caractères saisie au clavier et terminée par un retour à la ligne puis la place dans le tableau de caractères désigné par le paramètre fourni (ch). Le caractère de fin de ligne '\n' est normalement remplacé par le marqueur de fin de chaîne de caractères '\0'

la fonction puts

int puts( const char * ch)

Ecrit sur la sortie standard la chaîne de caractères donnée en paramètre, suivie d'un retour à la ligne. Si l'opération d'écriture s'est déroulée sans problème, la valeur renvoyée est celle du nombre de caractères écrits, sinon c'est la valeur correspondant à EOF (-1) qui est renvoyée.

III-2.3 Les entrées-sorties formatées

Ces fonctions permettent de lire et d'écrire des données de natures différentes : valeurs numérique, caractères, chaînes de caractères. Il est donc indispensable de spécifier le format de chaque donnée à traiter.

la fonction scanf

int scanf( const char * format, [arg1, …, argN))

Lit des données sur l'entrée standard. Ces données seront interprétées suivant les spécification fournies dans la chaîne format donnée en paramètr, et éventuellement stockées dans les variables représentées par arg1, … argN.



- la chaîne format : il s'agit d'une chaîne de caractères directement donnée entre " " et qui précise comment le flot de données présent sur l'entrée standard doit être interprété. Elle est composée de groupes de caractères appelés spécificateurs de format.

- le spécificateur de format : il définit le type et éventuellement la taille

de la donnée à lire. Il débute par le caractère %, suivi éventuellement d'une valeur entière correspondant à la taille maximum de la donnée (= nombre de caractères s'il s'agit d'une chaîne ou nombre de chiffres s'il s'agit d'une donnée numérique) et se termine par un caractère indiquant en quel type la donnée doit être convertie (ex : %c, %5d, …).

Caractère de conversion

Signification Type correspondant

c simple caractère char

s chaîne de caractères terminée par '\0'

char *

d entier décimal int

o entier sous forme octale

unsigned int

x entier sous forme hexadécimale

unsigned int

i entier sans distinction de forme

int

h entier court short

u entier décimal non signé

unsigned int

l entier long long

e, f ou g Nombre à virgule flottante

float

lf Nbre à virg. flottante double précision

double

Ainsi la donnée 1 peut être, selon le caractère utilisé, considérée comme un caractère ('1'), une chaîne de caractères ("1"), un entier (1) ou un réel (1.0). .

- les arguments : ils désignent l'endroit où la donnée lue va être stockée.

Dans le cas d'une donnée simple (entier, réel ou caractère), il ne s'agit pas directement du nom de la variable qui va recevoir la valeur mais de son adresse (utilisation de l'opérateur d'adressage &. Ex : N &N)



Attention ! : le cas des tableaux de caractères est différent

IMPORTANT : Le type de la donnée où doit être stockée la valeur lue doit être compatible avec celui du format associé. Il doit y avoir autant d'arguments que de spécificateurs de types.

Exemple :

int X, Y; float Z; char C, ch[20]; scanf("%d %f", &X, &Z); scanf("%c%d%s", &C, &Y, CH); scanf("%c%c%c", &CH[0], &CH[1], &CH[2]);

ATTENTION !: La chaîne format peut contenir éventuellement d'autres caractères que ceux composant les spécificateurs de format. Cela signifie alors que ceux-ci devront être trouvés tels quels dans le flot de données. S'il n'y a pas correspondance alors la lecture sera interrompue.

La fonction scanf renvoie le nombre de données lues. S'il y un problème de correspondance entre un format et une donnée, le nombre renvoyé est 0. Si le flot de données prend fin alors que d'autres données restent à lire la valeur renvoyée est -1 (EOF).

la fonction printf

int printf( const char * format, [arg1, …, argN])

Ecrit des données sur la sortie standard. Si des arguments, arg1, …, argN sont spécifiés ([…] signifiant ici facultatif), leur valeur respective est écrite sur la sortie standard conformément à la spécification de format fournie dans la chaîne format donnée en paramètre. - la chaîne format : il s'agit d'une chaîne de caractères directement

donnée entre " " et précisant comment le flot de données doit être interprété pour être écrit sur la sortie standard. Elle est composée de texte et/ou de spécificateurs de format.

- le spécificateur de format : il définit le type et éventuellement la taille de la donnée à écrire. Il débute par le caractère %, suivi :

- d'une valeur entière, qui, lorsqu'elle est précisée correspond à la taille minimum de la donnée (= nombre de caractères s'il s'agit d'une chaîne ou nombre de chiffres s'il s'agit d'une donnée numérique).



- d'une seconde valeur entière, qui, lorsqu'elle est précisée indique soit le nombre de chiffres à écrire après le point décimal lorsque la donnée est de type float ou double, soit le nombre maximum de caractères de la chaîne à écrire réellement. Afin de la distinguer de la taille minimum, cette valeur, appelée précision, est toujours précédée d'un point.

- du caractère de conversion précisant la forme selon laquelle la donnée devra être écrite.

(ex : %s, %15s, %.3f, %5.3f, …)

Caractère de conversion

Signification Type correspondant

c simple caractère char

s chaîne de caractères terminée par '\0'

char *

d ou i entier décimal signé int

o entier sous forme octale (non précédé de

0)

unsigned int

x entier sous forme hexadécimale (non

précédé de 0x)

unsigned int

f Valeur réelle ( avec point décimal mais

sans exposant)

float ou double

e Valeur réelle ( avec un seul chiffre avant le point décimal et une

partie exposant)

float ou double

g e ou f avec indication d'une précision

l Combiné avec d, u,o,i ou x pour un entier long

Long int

- les arguments : désignent les valeurs à écrire. Ils peuvent correspondre à

une constante, une expression, un appel de fonction, une variable, un tableau de caractères, …Contrairement à la fonction scanf, il ne faut pas préciser l'adresse des variables simples.

IMPORTANT : Le type de la donnée à écrire doit être compatible avec le format spécifié. Le nombre de spécificateurs de type donnés dans la chaîne format doit correspondre au nombre de données à écrire.



Exemple :

int X = 10, Y = 3; char ch[] = "EXEMPLE"; /* évaluation de la moyenne et affichage */ /* du résultat 3 chiffres après la virgule */

printf("moyenne de %d et %d = %.3f", X, Y, (float) X + Y /2); /* affichage de la chaîne EXEMPLE complétée */ /* 3 espaces pour arriver à 10 caractères */ /* minimum */

printf("%10s", ch);

/* affichage d'un simple texte avec */ /* tabulation \t et retour à la ligne \n */

printf("\tceci est uniquement du texte\n");

Des indicateurs de format peuvent modifier l'opération de lecture ou d'écriture. Ceux-ci sont alors placés après le caractère % débutant le spécificateur de type.

Indicateur Exemple Action correspondante

- %-d l'écriture de la donnée est justifiée à gauche.

* %*s la donnée est lue mais pas mémorisée

% %% écriture du caractère %

# %#o les valeurs octales ou hexadécimale sont précédées de leur marqueur respectif 0 et 0x

La fonction printf renvoie le nombre de données émises sur la sortie standard. En cas de problème elle renvoie -1 (EOF). III-2.4 Les Entrées-Sorties dans un fichier

Les entrées-sorties se font soit sur les fichiers standards (stdin, stdout, stderr), soit sur des fichiers de données enregistrés sur le disque. Il s'agit alors



de fichiers textes (suite de caractères ASCII) ou de fichiers binaires (suite de blocs d'octets correspondant par exemple à des enregistrements). Toutes les fonctions d'entrées-sorties se trouvent dans la bibliothèque standard stdio.h. Ne sont données ici que les déclarations associées aux principales fonctions. III-2.4.1. Notion de descripteur de fichier : type FILE Pour manipuler un fichier de données dans un programme C, il faut utiliser un pointeur sur un type prédéfini dans stdio.h : le type FILE.

/* pointeur nécessaire a l'utilisation */ /* d'un fichier de données */

FILE * ptr_fic;

Un élément de type FILE, appelé descripteur de fichier, est une structure contenant les informations relatives au fichier auquel il est associé (mode d'ouverture du fichier, type du fichier, position courante, ...). Le programmeur n'a pas accès directement au contenu de cette structure. Il ne peut manipuler le fichier que via le pointeur associé dans la mesure où celui-ci a reçu l'adresse du descripteur. Ce pointeur est appelé nom interne du fichier. III-2.4.2. Ouverture d'un fichier : la fonction fopen Avant de pouvoir être utilisé, tout fichier de données doit être ouvert. Pour cela, il faut préciser le nom externe du fichier (chaîne de caractères représentant le nom du fichier) et le mode d'ouverture souhaité. Connaissant ces paramètres, la fonction fopen renvoie soit l'adresse du descripteur associé au fichier ouvert, soit NULL si l'ouverture n'a pu être effectuée.

FILE * fopen ( char* NOM, char* MODE) ;

Attention !! : Toujours tester la valeur du pointeur après ouverture du fichier car s'il y a eu un problème sa valeur est égale à NULL, ce qui peut avoir des conséquences fâcheuses, si le pointeur est utilisé pour la suite du traitement.

Spécification du mode d'ouverture :

"r" ouverture en lecture uniquement et "r+" en lecture/écriture



Si le fichier n'existe pas alors il y a erreur d'ouverture.

"w" ouverture en écriture uniquement et "w+" en lecture/écriture. Si le fichier n'existe pas alors il est créé ; sinon son contenu est effacé.

"a" ouverture en écriture uniquement et "a+" en lecture/écriture. Si le fichier n'existe pas alors il est créé ; sinon l'écriture se fait en fin de fichier (l'ancien contenu est

conservé).

Attention !! : Pour les opérations de lecture/écriture sur un même fichier il faut gérer la position courante pour ne pas écrire sur les données à lire.

III-2.4.3. Fermeture d'un fichier : la fonction fclose Lorsque le fichier représenté par son nom interne, n'est plus utilisé par le programme, il doit être fermé.

int fclose ( FILE* PTR_FIC) ; III-2.4.4. Entrées-Sorties sur un fichier texte On retrouve des fonctions similaires à celles utilisées pour les entrées-sorties standard (cf. §III-2.1, §III-2.2 et §III-2.3). Elles admettent un paramètre supplémentaire précisant le nom interne du fichier (pointeur sur structure de type FILE) sur lequel l'opération de lecture ou d'écriture doit s'effectuer.

On dispose de fonctions traitant :

- un seul caractère : getc, fgetc, et putc, fputc, - une chaîne de caractères : fgets et fputs, - des entrées-sorties formatées : fscanf et fprintf.

int fgetc(FILE*) ou int getc(FILE*)

Lit un caractère simple dans le fichier désigné par le paramètre fourni

int fputc(char,FILE *) ou int putc(char,FILE *) Ecrit le caractère donné par le premier dans le fichier désigné par le second paramètre.

char* fgets(char*,int,FILE *)



Lit une chaîne d'une longueur donnée dans le fichier designé par le second paramètre et la stocke à l'adresse fournie par le premier paramètre.

int fputs(char*,FILE *) Ecrit la chaîne donnée par le premier paramètre dans le fichier désigné par le second paramètre

int fscanf(FILE* ,char*...) Lit des données dans le fichier désigné par le premier paremètre, selon le format donné par la chaîne format sur le même principe que la fonction scanf.

int fprintf(FILE* ,char*...) Ecrit des données dans le fichier désigné par le premier paramètre, selon le format spécifié par la chaîne format sur le même principe que la fonction printf

III-2.4.5. Entrées-Sorties sur un fichier binaire Les fonctions d'entrées-sorties ne sont pas les mêmes que pour un fichier texte. Il s'agit de transférer des blocs d'octets de même taille depuis (lecture), ou vers (écriture) le fichier ouvert. Pour cela on a besoin, en plus du nom interne du fichier (pointeur sur FILE), de l'adresse du premier bloc, de la taille d'un bloc et le nombre de blocs transférés simultanément.

La lecture et l'écriture d'un ou plusieurs blocs se font respectivement grâce aux fonctions fread et fwrite à partir de la position courante. Celle-ci est ensuite déplacée du nombre d'octets correspondant aux données traitées.

size_t fread(char*, int, int,FILE *)

Transfère des données d'un fichier de données binaire (= suite d'octets) dans la zone désignée par le premier paramètre. Les blocs d'octets à transférer ont une taille donnée par le deuxième paramètre, le troisième précisant le nombre de blocs à transférer, et le dernier désignant le fichier source.

size_t fwrite(char*,int,int,FILE *) Transfère, vers le fichier de données désigné par le troisième paramètre, des blocs d'octets dont la taille est donnée par le deuxième paramètre et



le nombre par le troisième. L'adresse de la zone où se trouve les données à transférer correspond à l'adresse fournie comme premier paramètre.

La position courante correspond à l'adresse du prochain octet qui fera l'objet d'une opération de lecture ou d'écriture. La valeur de la position courante peut être obtenue via la fonction ftell et modifiée via les fonctions fseek et rewind.

long int ftell(FILE*)

Renvoie la position courante du fichier désigné par le paramètre int fseek(FILE*,long int, int)

Décale la position courante du fichier désigné par le premier paramètre du nombre d'octets spécifié par le deuxième paramètre à partir de l'adresse donnée en troisième paramètre.

void rewind(FILE*)

Repositionne la position courante au début du fichier donné en paramètre.

Remarque : size_t est un type prédéfini dans la bibliothèque stdlib.h

bibliothèque et correspond à tout type d'entier, ce qui permet l’écriture de fonctions plus génériques.

III-2.4.6. Autres fonctions de manipulation de fichier : La bibliothèque stdio.h dispose également de fonctions permettant de contrôler les flux de données. La fonction feof indique si la fin de fichier a été atteinte ou non en renvoyant respectivement une valeur non nulle, 0 sinon.

int feof(FILE*)

A toute opération de lecture ou d'écriture sur un fichier donné est associé un buffer fonctionnant normalement en mode bloc ; c'est-à-dire que celui-ci mémorise la donnée à transférer et le transfert n'est effectué que lorsque le buffer est plein.

La fonction fflush permet de courcircuiter ce mécanisme en provoquant le transfert immédiat des données.

int fflush(FILE*)



D'autres fonctions permettent d'agir sur le buffer en changeant ses caractéristiques : setbuf, setvbuf.

void setbuf(FILE*, char *) void setvbuf(FILE*, char *, int, size_t)

*****************************************************************Pour connaître les spécifications détaillées des fonctions de la bibliothèque stdio.h, vous pouvez consulter le manuel en ligne : man nom_fonction *****************************************************************

EXEMPLE d'utilisation des fonctions intervenant dans la manipulation de fichiers de données texte :

#include <stdio.h>

void main (void) { FILE * ptr_fic;

char mot[11]; int nb;

/*ouverture en lecture du fichier de nom mon_fic */ ptr_fic = fopen("mon_fic", "r");

/* pour la suite ptr_fic désigne le fichier */ if(ptr_fic != NULL) { /* ouverture OK => lecture de la 1ere ligne */

fscanf(ptr_fic, "%10s %d", MOT, &NB); while(!feof(prt_fic)) {

/* traitement à faire sur tout le fichier */

............

/* lecture ligne suivante */ fscanf(ptr_fic, "%10s %d", MOT, &NB);

} fclose(ptr_fic); /* fermeture du fichier */

} else { /* message sur la sortie standard erreur */

fprintf(stderr, "Probleme d'ouverture");

/* sortie du programme */ exit(1);

} /* autres instructions */ ................

}

III-3 Autres bibliothèques et fonctions standards. III.3.1. Fichier math.h : Fonctions mathématiques.



Pour utiliser les fonctions mathématiques, il faut non seulement inclure ce fichier en début de programme mais également compiler avec l'option -lm. int abs(int) Renvoie la valeur absolue de l'entier i ceil(double) Renvoie l'entier immédiatement supérieur int floor(double) Renvoie l'entier immédiatement inférieur double cos(double) Renvoie le cosinus double sin(double) Renvoie le sinus double tan(double) Renvoie la tangente double exp(double) Elève e à la puissance donnée en paramètre double log(double) Renvoie le logarithme népérien du nombre spécifié double log10(double) Renvoie le logarithme décimal du nombre spécifié double pow(double, double) Elève le premier nombre à la puissance indiquée par le second double sqrt(double) Renvoie la racine carrée de d

III.3.2. Fichier string.h : Manipulation de chaînes de caractères.

Toute chaîne doit être terminée par le caractère nul '\0'. strcmp(char*, char*)

Comparaison lexicographique de 2 chaînes de caractères, renvoie un nombre négatif si la première est avant la seconde, positif si la première est après la seconde et nul si les chaînes sont identiques

char* strcat(char*, char*) Concatène la seconde chaîne à la chaîne première

char* strcpy(char*, char*) Copie la chaîne s2 dans la chaîne s1

int strlen(s) Renvoie la longueur de la chaîne donnée en paramètre

III.3.3. Fichier ctype.h : Fonctions testant la nature d'un caractère.

Elles renvoient une valeur non nulle si le test est positif, 0 sinon. int isalnum(c) Teste si c est un caractère alphanumérique



int isalpha(char) caractère alphabétique int isascii(char) code ascii int isdigit(char) chiffre décimal int isodigit(char chiffre octal int isxdigit(char) chiffre hexadécimal int islower(char) lettre minuscule int isupper(char) lettre majuscule int ispunct(char) caractère de ponctuation int isspace(char) caractère d'espacement int isprint(char) Teste si c est un caractère imprimable int toascii(char) Convertit le caractère en son code ascii int tolower(char) Convertit la lettre en minuscule int toupper(char) Convertit la lettre en majuscule

III.3.4. Fichier stdlib.h III.3.4.1. Fonctions de gestion de la mémoire dynamique

void * correspond à un pointeur générique c'est-à-dire à un pointeur dont le type est déterminé ultérieurement en fonction du type du paramètre passé.

size_t est une type prédéfini dans cette bibliothèque et correspond à

tout type d'entier. void *malloc(size_t)

Alloue un emplacement mémoire centrale correspondant au nombre d'octets indiqué en paramètre et renvoie l'adresse du début de la zone allouée (pointeur générique void * => conversion nécessaire en pointeur sur le type de donnée allouée)

void *calloc(size_t, size_t) Alloue la place mémoire nécessaire pour stocker un tableau correspondant au nombre d'éléments indiqué par le premier paramètre, chaque élément ayant la taille indiquée par le second paramètre. Renvoie l'adresse du début de la zone allouée (pointeur générique void * => conversion nécessaire en pointeur sur le type de donnée allouée)

void *realloc(void *, size_t)



Change la taille de la zone désignée par l'adresse fournie en paramètre en réallouant le nombre d'octets indiqué par le second paramètre. Renvoie l'adresse du début de la zone allouée car celle-ci peut avoir changé suite à une problème de place. Attention s'il s'agit de réallouer la zone correspondant à un tableau, le second paramètre doit correspondre au nombre total d'octets de la nouvelle zone et non pas la taille d'un élément comme pour la fonction calloc.

void free(void *ptr)

Libère la zone mémoire débutant à l'adresse indiquée.

III.3.4.2. Autres fonctions :

void exit(unsigned int)

Termine le programme en fermant fichiers et buffers. Le code de retour du programme correspond à la valeur donnée en paramètre.

int system(char*) Transmet une commande au système d'exploitation. Si la commande décrite par la chaîne s'est exécutée sans problème, la valeur retournée est nulle sinon -1. Un sous shell sh est lance pour exécuter cette commande

int rand (void)

Permet la génération d’un nombre pseudo-aléatoire dans l’intervalle 0 RAND_MAX (constante symbolique définie dans sdtlib.h). Pour que la suite générée varie, il est nécessaire d’appeler la fonction srand pour initialiser le générateur.

void srand (unsigned int) initialise la génération pseudo-aléatoire de nombres à partir de la valeur fournie en paramètre.

III.3.5. Autres bibliothèques à connaître



curses.h : bibliothèque pour la manipulation de structures de données pseudo-graphiques « fenêtres » sur des terminaux alphanumériques.

dirent.h : bibliothèque de fonctions de gestion des répertoires erreno.h : gestion des erreurs time.h : gestion du temps ….

IV- La compilation séparée et l’utilitaire MAKE

IV-1. Compilation séparée Cette notion est liée à celle de programmation modulaire qui consiste à concevoir une application comme une collection de modules plus ou moins autonomes.

Module : ensemble d'objets (données et sous-programmes) relatifs à une même tâche.

Certains objets définis dans un module donné peuvent être utilisés dans un autre module. On parle alors d'objets partageables. Un module correspond à une unité de compilation.

Unité de compilation : partie de code écrite dans un langage donné et pouvant être compilée séparément.

En langage C, une unité de compilation est constituée par un fichier source (fichier.c). Ainsi, un programme modulaire est constitué de plusieurs fichiers source. Chacun d'eux correspond à un module du programme et peut donc être compilé séparément.

Tout objet partageable doit être défini dans un seul module et déclaré dans tout autre module l'utilisant (une déclaration de variable ou de fonction indique que l'objet utilisé existe mais est défini dans un autre module).

Rôle de la compilation : construire un module objet (fichier.o) pour chaque module source faisant partie de l'application.

Exemple de commande de compilation d'un module : gcc -c fic1.c



Module sourcefic1.c

Module objetfic1.o

COMPILATION DUMODULE

Rôle de l'édition de liens : construire le fichier exécutable à partir de tous les modules objets composant l'application.

L'exécutable est généré seulement si aucune erreur d'édition de liens n'est détectée ; c'est-à-dire si tous les objets utilisés sont définis une et une seule fois dans l'application. Exemple de commande d'édition de liens : gcc fic1.o fic2.o fic3.o

MODULES OBJETSfic1.o fic2.o fic3.o

PROGRAMME EXECUTABLEa.out

EDITION DE LIENS

Remarque : dans toute application en langage C, il ne peut y avoir qu'une seule fonction principale main. Celle-ci doit donc se trouver dans un seul des modules constituant l'application. Attention !! : Ne pas confondre compilation séparée et inclusion de fichier. IV-2. L'utilitaire MAKE

Cet utilitaire permet d'automatiser le processus de compilation séparée d'un programme modulaire.



Pour cela, il faut constituer un fichier de directives. Chaque directive permet la génération d'un module CIBLE à partir d'une liste de DEPENDANCES et d'une REGLE de construction. Syntaxe d'une directive :

MODULE_CIBLE : LISTE_DES_DEPENDANCES REGLE_DE_CONSTRUCTION

La liste des dépendances correspond à la liste des fichiers à partir desquels le module cible va être construit.

La règle de construction correspond à la commande UNIX dont l'exécution doit produire le module cible. Attention !! : L'indentation de la règle fait partie de la syntaxe. Elle doit être décalée d'une tabulation. Exemple de directive :

# generation du module objet mod.o à partir # du fichier source mod.c et des fichiers # donnees.h et macro.h inclus dans le # fichier source mod.c mod.o : mod.c donnees.h macro.h

gcc -c mod.c Principe : Examen récursif des dépendances Lors du premier lancement, toutes les règles de construction sont exécutées et les modules cibles correspondants sont générés. Par la suite, seuls les modules ayant fait, directement ou indirectement, l'objet d'une mise à jour seront recréés.

La prise en compte d'une directive débute par l'examen de la liste de dépendances. Si cette liste contient le nom d'un autre module cible, la directive associée est traitée en priorité (vérification récursive). Il suffit que l'un des fichiers de dépendances possède une date de mise à jour plus récente que celle du module cible auquel il est associé pour que celui-ci soit reconstruit à l'aide de la règle correspondante. Lancement de l'utilitaire sous Unix :

make [options] cible_principale



Il faut spécifier le point d'entrée en donnant le nom du module à générer qui sera considéré comme la cible principale. La première directive traitée est alors celle associée à ce module.

Si le fichier de directives a été nommé makefile il n'est pas nécessaire de mentionner ce nom lors du lancement de l'utilitaire car il s'agit du nom par défaut (1).

Si un autre nom a été spécifié, généralement suffixé par mk (par exemple prog.mk), il faut utiliser l'option -f afin de préciser le nom exact du fichier de directives (2).

Dans les exemples suivants, le point d'entrée est prog.out . (1) make prog.out

(2) make -f prog.mk prog.out Attention !! : Ne pas confondre un fichier de directives avec un simple script shell contenant les commandes de compilation. Dans ce cas là, toutes les commandes sont exécutées, qu'il y ait besoin de le faire ou non (si un module n'a pas été modifié, il est inutile de le recompiler systématiquement).

V- Bibliographie

Pour compléter ce document vous pouvez vous référer à différents ouvrages :

Les bases de l’algorithmique :

"Initiation à la programmation", Claude Delannoy - Eyrolles , 1997, ISBN : 2-212-08983-X. La programmation en langage C :

"Le livre du C : premier langage", Claude Delannoy - Eyrolles , ISBN : 2-212-08838-8. "La programmation sous UNIX", Jean-Marie Rifflet, Ediscience

International, 3ème édition, 1986, ISBN : 2-84074-013-3. "Le langage C ANSI", Philippe Drix, Dunod Informatiques, 3ème édition,

1997, ISBN : 2-10-005193-8.

La programmation en langage C – Exercices corrigés :

"Exercices en Langage C", Claude Delannoy, Eyrolles, 3ème édition, 1995, ISBN : 2-212-08251-7.

"Programmation en C - Cours et problèmes", Byron S Gottfried, Série Schaum - Editions Ediscience International, Mc Graw

Hill 1993, ISBN : 2-7042-1230-9.

Documents

Programmation en langage C Eléments de syntaxe - irit.frIsabelle.Ferrane/SUPPORTS_COURS/L2_SI_Poly_C... · Programmation en langage C Eléments de syntaxe Université Paul Sabatier