Vous êtes sur la page 1sur 22

Cours sur le Langage C

Sommaire du Cours sur le Langage C

A) Introduction

1) Notions de base de la programmation 2) Le programme c 3) Structure d'un programme c 4) Les objets du programme

B) Production d'un exécutable

1) La chaîne de production de l'exécutable 2) Les librairies de turboc

C) Eléments de syntaxe du langage c

1) Introduction 2) Les séparateurs 3) Les délimiteurs 4) Les identificateurs 5) Les mots réservés

D) Les constantes

1) Constante entière 2) Constante nombre réel 3) Constante caractère 4) Constante chaîne de caractères

E) Les variables

1) Généralités 2) Variable globale 3) Variable locale

F) Les types de base

1) Introduction 2) Les entiers 3) Les réels

G) Expressions et opérateurs

1) Les opérateurs arithmétiques 2) Les opérateurs de manipulation de bits 3) Les opérateurs relationnels 4) Opérateurs logiques 5) L'affectation 6) Incrémentation décrémentation 7) Expression conditionnelle 8) Opérateurs d'accès aux objets 9) Opérateur sizeof 10) Opérateurs combinés

H) Priorités des opérateurs

1) Généralités 2) Tableau récapitulatif

I) Les instructions simples

1) Instruction vide 2) Instruction d'affectation 3) Instruction expression

1

1

1

1

1

2

2

2

3

3

3

3

3

3

4

4

4

4

4

5

5

5

5

6

6

6

6

7

7

7

7

8

8

8

8

8

8

8

9

9

9

10

10

10

10

4) Le bloc

10

J)

instruction conditionnelle

 

11

1) Syntaxe

 

11

2) Exemple

11

3) Remarques

11

K)

Instruction d'aiguillage

 

12

1) Syntaxe 2) Exemple 3) Utilisation de l'instruction break dans un switch

12

12

12

L)

Les instructions répétitives ou boucles

13

1) Instruction while 2) Instruction do 3) Instruction for

 

13

13

13

M)

Instructions associées aux boucles

 

14

1) Instruction break 2) Instruction continue 3) Instruction goto 4) instruction ";"

 

14

14

14

14

N)

Les directives de compilation

 

15

1) Introduction 2) Macro-définitions 3) Macro-definitions paramètrées 4) Destruction de macro-définitions 5) Inclusions de fichiers sources 6) Compilation conditionnelle

 

15

15

15

16

16

16

O)

Les fonctions

 

17

1) Généralités 2) Déclarations de fonctions 3) Définitions de fonctions 4) Appel d'une fonction 5) Passage des paramètres 6) Variables locales 7) Pointeurs de fonction

 

17

17

17

18

18

18

18

P)

Les pointeurs

 

19

1) Définitions 2) Opérations sur les pointeurs

 

19

19

Q)

Les tableaux

20

1) Les tableaux simples 2) Les tableaux à plusieurs dimensions 3) Initialisation des tableaux

 

20

20

20

Cours sur le langage C

A)A) INTRODUCTIONINTRODUCTION

1) NOTIONS DE BASE DE LA PROGRAMMATION

Le programme résout des problèmes en manipulant des données. Il faut pour cela:

w fournir les informations au programme (notions d'entrées),

w trouver une place pour les conserver en mémoire (notion de types de données et de variable);

w donner les instructions nécessaires à leur traitement (notion d'opérations),

w restituer les résultats à l'utilisateur (notion de sorties).

On peut organiser les instructions de telle façon que:

w certaines ne soient exécutées que si une condition spécifique est vraie (exécution conditionnelle),

w d'autres soient répétées un certain nombre de fois (notion de boucles),

w d'autres soient exécutables en différents points du programme (notion de sous-programme).

2) LE PROGRAMME C

Un programme C est un texte structuré en ligne, écrit à l'aide d'un éditeur de texte selon les règles de construction du langage C.

Le programme source écrit en C liste, dans un ou plusieurs fichiers portant l'extension .c, les objets et les actions nécessaires à la réalisation d'une tache par l'ordinateur.

Pour aider à la programmation une bibliothèque de sous-programmes précompilés (fichier.lib) est mise à la disposition de l'utilisateur. Les déclarations de ces primitives sont localisées dans les fichiers .h, dits fichiers d'en-têtes, lisibles à l'aide d'un éditeur de texte.

3) STRUCTURE D'UN PROGRAMME C

On peut distinguer dans un programme:

w les commentaires ou texte utile pour la présentation et la compréhension, un commentaire commence toujours par /* et se termine par */,

w le programme proprement dit écrit selon les règles du langage.

Le programme proprement dit est composé

w de blocs qui, en C, sont appelés fonctions. Une fonction est en fait un sous-programme qui réalise une action et produit une valeur;

w de listes d'objets qui vont contenir les données.

Une fonction particulière joue le rôle de fonction principale, encore communément appelée programme principal, et est repérée par le nom main.

4) LES OBJETS DU PROGRAMME

Le programme manipule, par l'intermédiaire de ses fonctions, des objets de différentes natures:

w des constantes,

w des variables, objets dont le contenu peut être modifié.

Une constante est entièrement caractérisée par sa valeur et se confond avec elle.

Une variable est localisée en mémoire et est caractérisée par:

w son type (fonction de l'objet que l'on veut y stocker, il détermine sa taille et sa structure),

w son identificateur ou nom qui permet d'accéder directement à son contenu,

w son adresse en mémoire qui permet aussi d'accéder à son contenu de manière indirecte.

Une fonction est localisée en mémoire et est caractérisée par:

w son identificateur ou nom qui permet de lancer son exécution,

w ses arguments ou liste des données qui lui sont nécessaires en entrée,

w son type ou nature de la valeur retournée en fin d'exécution.

B)B) PRODUCTIONPRODUCTION D'UND'UN EEXECUTABLEXECUTABLE

Cours sur le langage C

1) LA CHAINE DE PRODUCTION DE L'EXECUTABLE

La production d'un programme exécutable par la machine, à partir des fichiers source .c et des primitives, se fait à l'aide d'un compilateur et d'un éditeur de liens.

Source1.c compilateur Source1.obj Source2.c compilateur Source2.obj Source3.c compilateur Source3.obj
Source1.c
compilateur
Source1.obj
Source2.c
compilateur
Source2.obj
Source3.c
compilateur
Source3.obj
éditeur
de
fichier.exe
liens
primitives
bibliothèque

Les fichiers .c sont les fichiers source et contiennent le code source en C.

Les fichiers .obj sont les fichiers objets et contiennent le code objet en langage binaire.

Le fichier .exe est le programme réellement exécutable, il contient le code objet et les primitives.

2) LES LIBRAIRIES DE TURBOC

Une librairie se présente sous forme d'un fichier dans lequel a été rassemblé un certain nombre de fonctions précompilées appelées primitives.

La bibliothèque de TURBOC est placées dans TC\LIB dont les principales librairies sont:

w Cx.LIB (librairies standards), w MATHx.LIB (librairies mathématiques), w GRAPHICS.LIB (librairie graphique).

Toutes les primitives de la bibliothèque C sont déclarées dans les fichiers .h dits fichiers d'en-tête. Ces fichiers regroupent les prototypes ou "descriptifs des primitives en langage C".

Cours sur le langage C

C)C) ELEMENTSELEMENTS DEDE SYNTASYNTAXEXE DUDU LANGAGELANGAGE CC

1) INTRODUCTION

le

langage

C

comporte

symbolique):

6

classes

d'unités

syntaxiques

(éléments

du

langage

ayant

un

sens

w les identificateurs ou noms donnés aux objets manipulés par le programme,

w les mots réservés ou mots clés du langage,

w les constantes ayant une valeur figée (étudiées dans le chapitre suivant),

w les opérateurs permettant de manipuler les données (étudiés dans un autres chapitre),

w les délimiteurs et

w les séparateurs permettant aux compilateur de distinguer les différentes unités du langage.

2) LES SEPARATEURS

Ils peuvent être:

w un ou plusieurs caractères espace, tabulation, interligne, retour chariot,

w ; termine une déclaration de variable ou une instruction,

w , sépare deux éléments dans une liste.

3) LES DELIMITEURS

Ils vont par deux et sont:

w ( et ) encadrent une liste d'arguments ou de paramètres,

w [ et ] encadrent la dimension ou l'indice d'un tableau,

w { et } encadrent un bloc d'instructions ou une liste de valeurs d'initialisation,

w < et > encadrent le nom d'un fichier d'en-tête,

w " et " délimitent une chaîne de caractères,

w ' et ' délimitent un caractère,

w /* et */ délimitent un commentaire

4) LES IDENTIFICATEURS

Ils permettent de référencer les objets manipulés par le programme.

Un identificateur doit être construit en respectant les règles suivantes:

w il doit commencer par une lettre (a

w les caractères suivants peuvent être des lettres, des chiffres ou le souligné et rien d'autre,

w majuscules et minuscules sont différenciées,

w seuls les 32 premiers caractères sont significatifs.

z

ou A

Z)

ou par un caractère souligné "_",

5) LES MOTS RESERVES

Ce sont des mots clés ayant une signification particulière en C, ils ne peuvent servir d'identificateurs

Type

Classe

instruction

Opérateur

étiquette

int

auto

if

sizeof

case

char

extern

else

default

short

static

while

long

register

do

unsigned

typedef

for

float

switch

double

break

struct

continue

union

goto

enum

return

void

Cours sur le langage C

D)D) LESLES CONSTANTESCONSTANTES

1) CONSTANTE ENTIERE

Elles peuvent être représentées selon 3 systèmes:

w en décimal c'est la notation usuelle (exemple: 9, -213, +65535),

w en octal le nombre est précédé du chiffre 0 (exemple: 010,0325,0177777),

w en hexadécimal le nombre est précédé de 0x ou 0X (exemple: 0xa, 0X5d, 0xFFFF).

2) CONSTANTE NOMBRE REEL

Elles peuvent être représentées selon 2 notations:

w décimale, exemple: -12.5, 456, 14.0,

w scientifique, exemple: 0.314e1, -8.56E-15.

3) CONSTANTE CARACTERE

Elles permettent de désigner les valeurs entières correspondant aux codes ASCII.

Caractère visible: Il est placé entre apostrophes, exemple: '4', 'a'.

caractère non visible et codes spéciaux

Il est noté entre apostrophes

w soit par sa valeur octale ou son caractère représentant la fonction précédé de la barre inverse \. Exemple: '\12' ou '\n'.

w soit par sa valeur hexadécimale précédée de \x. Exemple: '\xA'.

'Séquence'

Valeur (hex et octal)

Caractère

Effet

\a

0x07 ou 007 0x08 ou 010 0x0C ou 014 0x0A ou 012 0x0D ou 015 0x09 ou 011 0x0B ou 013 0x5C ou 134 0x2C ou 054

BEL

signal sonore effacement arrière saut de page interligne retour chariot tabulation horizontale tabulation verticale

\b

BS

\f

FF

\n

LF

\r

CR

\t

HT

\v

VT

\\

\

barre inverse

\'

'

apostrophe DDD=valeur octal HHH=valeur hexadécimale

\DDD

0DDD

tout

\xHHH

0xHHH

tout

4) CONSTANTE CHAINE DE CARACTERES

Suite de caractères placés entre guillemets. Elle peut contenir tous types de constantes caractères.

Si le guillemet doit figurer il doit être précédé de la barre inverse \.

Si la barre inverse doit figurer il faut la doubler.

Exemples:

"on

va

à la ligne\net

on fait un bip\7" ; "guillemet=\""

; "chemin d'accès est

c:\\new\\outils".

Toute chaîne de caractères est obligatoirement terminée par le caractère NULL ('\0'). Celui-ci est automatiquement engendré par le compilateur. Exemple: "Cours" sera représenté en mémoire par

C

o

u

r

s

\0

Il ne faut pas confondre les représentations machine du caractère 'a' et de la chaîne de caractère "a".

"" représente la chaîne de caractères vide et occupe un octet en mémoire, celui du caractère NULL.

Cours sur le langage C

E)E) LESLES VARIABLESVARIABLES

1) GENERALITES

En C tout objet manipulé par le programme doit auparavant être déclaré.

Déclarer une variable c'est définir ses caractéristiques physiques avec les mots du c selon le format:

classe type nom;

w sa classe, précise sa place dans l'espace mémoire (facultatif),

w son type, permet de définir sa taille et sa structure,

w le nom permet d'identifier la variable (identificateur).

2) VARIABLE GLOBALE

Si une variable est déclarée sans spécification de classe dans un fichier source à l'extérieur de tout bloc elle est dite globale.

w Elle est localisée dans l'espace mémoire permanent. Sa durée de vie est donc celle du programme.

w Elle est visible et utilisable par toutes les fonctions du fichier qui suivent sa définition. Sa visibilité est globale.

w Elle peut être utilisée dans d'autre fichier à condition d'y rappeler sa déclaration précédée du mot extern. Ce mot précise au compilateur que la variable est de classe externe, qu'elle a été définie dans un autre fichier et qu'il ne faut pas réserver de place mémoire.

w Son contenu est initialisé automatiquement à 0 en début d'exécution, ou à une autre valeur si vous l'indiquez explicitement lors de la déclaration.

3) VARIABLE LOCALE

Variables automatiques

Si une variable est déclarée sans spécification de classe à l'intérieur d'une fonction elle est dite de classe auto ou automatique.

w Sa place mémoire est allouée dans la pile lors de l'appel de la fonction, puis libérée lors du retour de la fonction.

w Son contenu est donc définitivement perdu entre deux appels consécutifs.

w Pour deux exécutions différentes de la fonction, la variable de la 1ière exécution est différente de la variable de la 2nde exécution.

w Elles ne sont pas initialisées automatiquement.

Variables statiques

C'est une variable dont la déclaration à l'intérieur d'une fonction est précédée du mot static.

w Elle n'est utilisable que dans la fonction où elle a été déclarée, elle est locale.

w Sa place mémoire est réservée lors de la compilation. C'est donc une variable permanente.

w Son contenu qui peut évoluer est garanti tout au long de la durée d'exécution du programme.

w Son contenu est initialisé à 0 en début d'exécution, ou à une autre valeur si vous l'indiquez explicitement lors de la déclaration.

float x,y; int n; extern int n; extern float x; { { int i,j; static
float x,y;
int n;
extern int n;
extern float x;
{
{
int i,j;
static char i;
}
}

déclaration/définition variables globales

déclaration variables globales définies ailleur

variables locales temporaires

variable locale permanente

Cours sur le langage C

F)F) LESLES TYPESTYPES DEDE BASEBASE

1) INTRODUCTION

Les types de base du C sont: les entiers et les réels. Un spécificateur peut précéder le type afin de moduler sa précision et sa taille en mémoire.

A partir des types de base on peut construire des types plus complexes: tableaux, pointeurs, structures, unions, énumérations, fonctions qui seront étudiés dans les chapitres qui leurs sont consacrés.

2) LES ENTIERS

Le type char

Les variables de ce type permettent de mémoriser les caractères ASCII. La variable contient un entier qui correspond au code ASCII signé ou non d'un des caractères de la table ASCII.

(Spécificateur ) Type

Taille (octets)

Précision

char

1

-128 127

unsigned char

1

0 255

Exemple:

Le type int

char c;

/* déclare une variable caractère nommée c*/

Leurs contenus s'identifient aux entiers relatifs.

Les variables de ce type occupent un mot mémoire (une unité adressable de la machine cible). La taille n'est donc pas définie par le langage et varie d'un matériel à l'autre. Sur vos machines:

(Spécificateur) Type

Taille (octets)

 

Précision

 

int unsigned (int) short (int) unsigned short (int) long (int) unsigned long (int)

2

-32 768

32

767

2

 

0

65

535

2

-32 768

32

767

2

 

0

65

535

4

-2 147 483 648

2

147 483 647

4

0

4

294 967 295

Exemple:

3) LES REELS

long int n,m;

/* déclaration de 2 entiers longs nommés n et m */

Leurs contenus s'identifient aux nombres fractionnaires.

(Spécificateur) Type

Taille (octets)

Précision

float

4

3.4E-38 3.4E+38

double

8

1.7E-308 1.7E+308

long double

10

3.4E-4932 1.1E+4932

Exemple:

double x,y,z;

/*déclaration de 3 réels nommés x, y et z*/

Cours sur le langage C

G)G) EXPRESSIONSEXPRESSIONS ETET OPOPERATEURSERATEURS

On peut distinguer les opérateurs unaires, qui agissent sur un opérande, les opérateurs binaires qui mettent en relation deux opérandes, les opérateurs ternaires qui mettent en relation trois opérandes.

Une expression est constitué d'opérandes et d'opérateurs. Les opérandes peuvent être des constantes, des variables ou des expressions. L'expression est évaluée à l'exécution et produit toujours une valeur qu'il est possible de réutiliser.

1) LES OPERATEURS ARITHMETIQUES

Les opérandes sont de types entier et/ou réel.

+

-

*

/

%

addition et plus unaire

soustraction et moins unaire multiplication

soustraction et moins unaire multiplication

division entière et réelle

reste de la division entière

Si les opérandes de / sont entiers il est effectuée un division entière (exemple 5/2 donne 2). Si un des opérandes est réel le division est réelle (exemple: 5.0/2 donne 2.5).

En C l'évaluation s'effectue de gauche à droite. et chaque type d'opérateur a une priorité. Le - et + unaire sont les plus prioritaires, puis viennent sur un même plan /, * et % et enfin l'addition et la soustraction.

Si il subsiste une ambiguï té dans l'ordre d'évaluation des opérations, il est alors conseillé d'utiliser les parenthèses. Tout expression entre parenthèse est évaluée en premier.

2) LES OPERATEURS DE MANIPULATION DE BITS

Ils s'appliquent aux types entier et caractères mais non aux objets de type réel.

&

ET logique (AND) OU logique (OR) OU exclusif (EOR) complément à un décalage vers la gauche décalage vers la droite

|

^

~

<<

>>

3) LES OPERATEURS RELATIONNELS

>

supérieur supérieur ou égal inférieur inférieur ou égal égalité inégalité

>=

<

<=

= =

!=

Ce sont les opérateurs de comparaisons. Ils mettent en relations deux expressions, le résultat est une nouvelle expression vraie ou fausse. Si la nouvelle expression est fausse elle prend la valeur entière 0, si elle est vraie elle prend la valeur 1.

a=1.25

expression réelle de valeur 2.5

(a*2)
(a*2)

<

(5/2)
(5/2)

expression entière constante de valeur 2

expression entière de valeur 0

Cours sur le langage C

4) OPERATEURS LOGIQUES

!

négation d'une valeur logique ET logique de deux valeurs OU logiques de 2 valeurs logiques

&&

||

Ces opérateurs interviennent sur des valeurs de type entier. w La valeur 0 est considéré comme faux, w toutes les autres valeurs sont considérées comme vrai.

Les valeurs produites sont 0 pour faux et 1 pour vrai.

Exemple: si i=1 et a=3 alors l'expression (i<10)&&(a!=2) est vraie et vaut 1.

5) L'AFFECTATION

C'est l'opération la plus répandue, elle est symbolisée par =, elle introduit le résultat de l'expression de droite dans la variable qui est à gauche.

exemples: i=8

k=j&0377

Une affectation est une expression qui prend la valeur de l'expression de droite. Cette valeur peut donc être réutilisée. exemple: x=y=z affecte à y et x le contenu de z (opération effectuée de droite à gauche). x=2*(y=z) met le contenu de z dans y et 2*z dans x.

6) INCREMENTATION DECREMENTATION

++ ajoute 1 à la variable qui lui est associée, ainsi ++x et x++ sont équivalents à x=x+1.

-- retranche 1 à la variable qui lui est associée, ainsi --x et x-- sont équivalent à x=x-1.

Si l'opérateur est placé devant il y a incrémentation ou décrémentation avant utilisation, si il est placé derrière elle aura lieu après l'utilisation.

Exemple: y = x = 0

y = x++ donne 0 dans y et 1 dans x

alors que y = ++x donne 1 dans y et dans x.

7) EXPRESSION CONDITIONNELLE

Elle s'écrit (expression)?(expression1):(expression2).

Expression est évaluée, si la valeur est vraie (différente de 0) c'est expression1 qui est évaluée, sinon (valeur 0) c'est expression2 qui est évaluée.

Exemple: SI a < b alors z = a sinon z = b peut s'écrire z = (a < b) ? a : b.

8) OPERATEURS D'ACCES AUX OBJETS

L'opérateur unaire & fournit l'adresse de la variable qui le suit. L'opérateur unaire * fournit le contenu dont l'expression suit. Il ne faut pas les confondre avec la multiplication et le ET binaire. Si adr_obj = &obj alors obj = *adr_obj soit obj = *&obj.

9) OPERATEUR SIZEOF

Il donne la taille en octet de l'opérande qui lui est associé. Syntaxe: sizeof(opérande).

10) OPERATEURS COMBINES

Toutes les expressions de la forme <variable> = <variable> <opérateur> <expression> peuvent être remplacées par <variable> <opérateur> = <expression>.

Exemple: a = a + b est condensé en a += b; de même a = a|b se condense en a |= b etc

Cours sur le langage C

H)H) PRIORITESPRIORITES DESDES OPEOPERATEURSRATEURS

1) GENERALITES

Lors de l'évaluation des expressions et afin de lever toute ambiguï té , certaines règles sont appliquées systématiquement par le compilateur:

w les opérations les plus prioritaires sont appliquées en premier, w les opérateurs de même priorité sont appliqués de la gauche vers la droite (sauf les opérateurs unaires, les affectations et l'expression conditionnelle); w les expressions entre parenthèses sont évaluées en premier.

2) TABLEAU RECAPITULATIF

Opérateurs

Symboles

ordre d'évaluation

appel de fonction indexation champ de structure

( )

gauche à droite -->

[ ]

->, .

 

négation logique négation bit à bit incrémentation décrémentation moins unaire conversion indirection adresse taille

!

droite à gauche

~

<-----

++

--

-

(<type>)

*

&

sizeof

multiplication

*

-->

division

/

modulo

%

addition

+

-->

soustraction

-

décalages

<< , >>

-->

relationnels

<, <=, >, >=

-->

égalité

=

-->

différence

!=

et bit à bit

&

-->

ou exclusif bit à bit

^

-->

ou bit à bit

|

-->

et logique

&&

-->

ou logique

||

-->

expression conditionnelle

? :

<-----

affectation affectations étendues

=

<-----

+=, -=, *=, /=, %=, >>=, <<=, &=, |=, ^=

expression composée

,

-->

Cours sur le langage C

I)I) LESLES INSTRINSTRUCTIONSUCTIONS SIMPLESSIMPLES

Le texte en gras indique les mots du C.

Les éléments entre crochets [ ] sont facultatifs.

Les éléments entre < et > encadre le texte qui n'est pas à taper mot à mot.

1) INSTRUCTION VIDE

Le point virgule seul signifie que le traitement est inexistant.

;

2) INSTRUCTION D'AFFECTATION

<variable> = <expression>;

La valeur résultant de l'évaluation de l'expression est placée dans la variable. Une conversion du type du résultat vers le type de la variable réceptrice peut intervenir si les deux types sont différents.

Exemple:

int i;

char c;

double x;

i=12;

c=2*i;

/* expression de type entier convertie en caractère */

x=i/5;

/* expression de type entier convertie en double */

x=i/5.0; /* expression de type double comme la variable */

3) INSTRUCTION EXPRESSION

<expression>;

La valeur résultant de l'évaluation est inutilisée et donc perdue. Un telle instruction est généralement une expression d'affectation ou un appel de fonction retournant un résultat indéfini ou inutilisé.

4) LE BLOC

Les accolades sont utilisées pour regrouper plusieurs instruc- tions et en faire une instruction composée appelée bloc. Une telle construction est syntaxiquement équivalente à une instruction simple.

Les déclarations dans un bloc (si il y en a) doivent être au dé- but, les objets ainsi définis ne sont visibles que dans le bloc lui même.

Le bloc peut apparaître partout ou une instruction est atten- due.

L'accolade fermante n'est jamais suivie d'un point-virgule.

{

 

[<déclarations>]

<instruction>;

<instruction>;

}

Cours sur le langage C

J)J) INSTRUCTIONINSTRUCTION CONDICONDITIONNELLETIONNELLE

1) SYNTAXE

if (<expression>)

<instruction1>;

[else

<instruction2>;]

Lorsque l'expression délivre la valeur vrai (entier non nul) <instruction1> est exécutée. Dans le cas contraire (zéro) <instruction2> est exécutée si elle est présente.

2) EXEMPLE

if (delta<0)

/* teste le discriminant */

printf("racines imaginaires");

else if (delta = = 0) x = -b/(2*a); else

/* peut aussi s'écrire if (!delta) */ /* une racine double */

{

/* deux racines réelles */

x1=(-b-sqrt(delta))/(2*a);

x2=(-b+sqrt(delta))/(2*a);

}

3) REMARQUES

Du fait que le else est facultatif une ambiguï té peut survenir lorsque un if suit un autre if.

Exemple: if (e1) if (e2) action1 else action2

Pour lever l'ambiguï té on adopte la règle qui associe le premier else rencontré avec le if le plus proche qui le précède. Ainsi action2 sera effectué si e1 est vrai et si e2 est faux.

Cours sur le langage C

K)K) INSTRUCTINSTRUCTIONION D'AIGUILLAGED'AIGUILLAGE

1) SYNTAXE

switch(<expression-entière>)

{

case<valeur1>:<instruction-1>;

case<valeur2>:<intruction-2>;

case<valeuri>:<instruction-i>;

case<valeurn>:<instruction-n>;

[default

:<inst-défaut>;]

}

La valeur entière produite par l'expression est recherchée parmi les constante <valeuri> puis l'instruc- tion associée est exécutée ainsi que toutes les instructions qui suivent.

Dans le cas où la valeur n'est pas trouvée c'est l'instruction <inst-défaut> qui est exécutée si elle est présente.

2) EXEMPLE

char c;

switch (c)

{

 

case 'a':

case 'e':

case 'i':

case 'o':

case 'u':

case 'y':printf("c est une voyelle");

}

3) UTILISATION DE L'INSTRUCTION BREAK DANS UN SWITCH

Dès qu'une instruction break; est rencontrée elle provoque le sortie de l'instruction switch et la poursuite à l'instruction qui suit.

Exemple: ici error est un entier qui contient un code d'erreur.

int error;

switch (error) { case 0:break;

/* pas d'erreur */

case 1:

case 2:

case 3:printf("erreur numéro %d",error);break;

case -1:printf(""erreur catastrophique");break; default:printf("erreur %d inconnue",error);

}

Cours sur le langage C

L)L) LELESS INSTRUCTIONSINSTRUCTIONS REPETREPETITIVESITIVES OUOU BOUCLESBOUCLES

1) INSTRUCTION WHILE

while(<expression>) <instruction>

Tant que expression fournit une valeur vraie (entier non nul) l'instruction est exécutée.

Le test de boucle est effectué en début de boucle. <instruction> peut ne pas s'effectuer.

Exemple: while (n>0) {n=n-1} /* à la fin on a 0 dans n si n est positif ou nul sinon n inchangé */

On peut écrire l'exemple précédent des façons suivantes:

while(n>0) {n-=1} while(n>0) {n--}

while(n--)

/* si on est sûr que n>0 */

2) INSTRUCTION DO

do <instruction> while <expression>;

L'instruction est effectuée tant que expression fournit une valeur vraie (non nulle).

Le test de boucle est effectué en fin de boucle. <instruction> s'effectue au moins une fois.

Exemple: do {n=n-1} while (n>0); /* identique au précédent si n>0 sinon on a n-1 dans n */

3) INSTRUCTION FOR

for(<inst-initiale>;<condition-fin>;<inst-incr>) <instruction>

<inst-initiale> définit l'action correspondant à l'initialisation. Cette instruction est exécutée une seule fois, avant la première itération. C'est une instruction simple.

<condition-fin> est une expression qui doit être égale à faux (zéro) pour stopper la boucle.

<inst-incr> définit le calcul à effectuer entre deux itérations (avant d'effectuer l'évaluation de <condition-fin>). C'est une instruction simple.

<instruction> est le corps de la boucle ou itération.

Un ou plusieurs termes peuvent être absents. Les séparateurs point virgule permettent de lever les ambiguï tés qui en découleraient. Ceci permet d'avoir les configurations suivantes:

for(;test;incr) <instruction> /* pas d'initialisation */

for(init;test;) <instruction> for(;test;) <instruction> for(;;)

/* pas de progression */ /* identique à while(test) <instruction> */ /* boucle infinie */

Exemple: comptage des parenthèses ouvrante et fermante d'une chaîne entrée au clavier.

for(begin=0,end=0;(c=getchar())!='\n;){

switch(c){ case '(':++begin;break; case ')':++end;

}

}

printf("nombre de ( = %d",begin); printf("nombre de ) = %d",end); if(begin-end) printf("erreur de parenthèses");

Cours sur le langage C

M)M) INSTRUCTIONSINSTRUCTIONS ASSOASSOCIEESCIEES AUXAUX BOUCLESBOUCLES

1) INSTRUCTION BREAK

Syntaxe: break;

Elle provoque une sortie immédiate de la boucle en cours d'exécution. Le programme se poursuit à l'instruction qui suit immédiatement la boucle.

while (1) {

if (exp) break;

}

suit immédiatement la boucle. while (1) { if (exp) break; } for (;;) { if (exp)

for (;;) {

if (exp) break;

}

while (1) { if (exp) break; } for (;;) { if (exp) break; } Elle est

Elle est aussi utilisée pour sortir après l'exécution d'un cas dans un switch.

2) INSTRUCTION CONTINUE

Syntaxe: continue;

Elle donne le contrôle à la fin de la boucle sans en sortir, en sautant ainsi la séquence d'instruction comprise entre le continue et la fin de boucle. Elle a pour effet de provoquer une nouvelle itération. Ce qui revient à redonner le contrôle au niveau du test de la condition. Dans le cas du for le troisième champ <inst-incr> est exécuté.

for le troisième champ <inst-incr> est exécuté. while (exp) { if (test) continue; } 3) INSTRUCTION

while (exp) {

if (test) continue;

}

3) INSTRUCTION GOTO

do {

}
}

if (test) continue;

while (exp);

syntaxe: goto <label>;

Label est un identificateur spécifiant l'endroit où doit être fait le branchement.

L'instruction oblige le programme à se poursuivre à l'instruction préfixée par le label.

Cette instruction en langage évolué est à utiliser le moins possible.

Exemple:

goto etiq;

etiq: printf("sortie de boucle");

4) INSTRUCTION ";"

C'est l'instruction ne rien faire. Elle permet par exemple de terminer une boucle while sans corps de boucle: while ((c=getchar())= =' '||c= ='\t'); /* permet d'ignorer espace et tabulation */.

Cours sur le langage C

N)N) LESLES DIRECTIVESDIRECTIVES DEDE COMPILATIONCOMPILATION

1) INTRODUCTION

Les directives de compilation commencent toujours par le symbole #. Elles ne sont pas exécutables.

Tout compilateur comprend un préprocesseur. Son action est uniquement une transformation du texte en fonction des directives de compilation données par le programmeur. Il est lancé automatiquement avant la compilation proprement dite pour préparer le fichier source.

On distingue trois catégories de directives:

w la directive de substitution symbolique: #define, w la directive d'inclusion de fichier: #include, w les directives de compilation conditionnelle: #if #else #endif #ifdef #ifndef.

2) MACRO-DEFINITIONS

#define <identificateur> <chaîne de caractères>

Cette directive ordonne au préprocesseur de remplacer toute apparition ultérieure de <identificateur> par <chaîne de caractères>.

Exemple:

#define PI 3.14159 #define BIP '07' #define NB_ELT (sizeof(tab) / sizeof(tab[0])

Le substitution débute à partir de sa substitution jusqu'à la fin du fichier, ou jusqu'à sa prochaine redéfinition (nouveau #define avec le même identificateur), ou encore jusqu'à son invalidation par la directive: #undef <identificateur>.

<chaîne de caractères> débute après le premier espace suivant l'identificateur et se termine à la fin de la ligne.

La substitution n'a pas lieu dans les chaînes de caractères entre guillemets.

3) MACRO-DEFINITIONS PARAMETREES

#define <ident>(<liste-paramètres>) <chaîne>

Remplace les apparitions de <identificateur>(<liste-paramètres>) par la chaîne de caractères qui suit.

De plus, une substitution de chaque paramètre de la liste de la macro, par les paramètres correspondant sera effectuée au point d'appel.

<chaîne> débute après le premier espace et se termine à la fin de la ligne.

<liste-paramètres> est une suite d'identificateurs séparés par des virgules.

Exemple:

#define inf(x,y) ((x<y)?(x):(y))

c=inf(a,b);

/* sera remplacé par c=((a<b)?(a):(b)) par le préprocesseur */

d=inf(c,2*a); /* d=((c<2*a)?(c):(2*a)) */

Les paramètres x et y sont appelés paramètres formels, ils ne servent qu'à écrire la macro, ils sont remplacés aux différents points d'appel par les paramètres effectifs ou expressions dont les valeurs vont effectivement servir à l'évaluation. Il faut autant de paramètres effectifs que de paramètres formels.

Cours sur le langage C

4) DESTRUCTION DE MACRO-DEFINITIONS

#undef <macro>

Détruit le sens accordé à la macro.

5) INCLUSIONS DE FICHIERS SOURCES

#include <fichier>

Demande au préprocesseur de rechercher et d'inclure le contenu complet du fichier spécifié.

Si <fichier> est un fichier d'en-tête du C localisé dans le répertoire spécial la directive s'écrit:

#define <stdio.h> #define <conio.h>

Si <fichier> est un autre fichier la directive s'écrit:

#define "perso.x" #define "usr\connun\pile.h"

Un fichier include peut contenir des déclarations usuelles, des définitions de variables globales, des constantes symboliques prédéfinies et une ou plusieurs fonctions.

6) COMPILATION CONDITIONNELLE

C'est l'une des trois directives suivantes:

#if <expression constante> <liste instructions 1> [#else <liste instructions 2>] #endif

#ifdef <identificateur> <liste instructions 1> [#else <liste instructions 2>] #endif

#ifndef <identificateur> <liste instructions 1> [#else <liste instructions 2>] #endif

Si la valeur produite par le if est vraie c'est <liste d'instructions 1> qui sera compilé, sinon ce sera <liste d'instructions 2> si le else est présent.

<expression constante> doit être évaluable lors de la compilation: la valeur produite est vraie si le résultat est différent de zéro, fausse sinon.

#ifdef <identificateur> est vrai si <identifivateur> a été défini dans une directive #define, faux sinon.

#ifndef <identificateur> est la condition inverse.

Exemple:

#define DEBUG 1 /* on mettra DEBUG à 0 si on ne veut pas compiler instructions-1 */

#if DEBUG

instructions-1

#endif

instructions-2

/* n'est compilé que si DEBUG est différent de zéro */

/* est compilé dans tous les cas */

Cours sur le langage C

O)O) LESLES FONCTIONSFONCTIONS

1) GENERALITES

Une fonction est un sous-programme qui réalise une action et produit une valeur éventuellement indéfinie. L'action réalisée est définie dans un bloc.

Les fonctions ne peuvent s'imbriquer (une fonction ne peut contenir une autre fonction).

Déclarer une fonction c'est donner au reste du programme les indications qui permettront aux autres fonctions (main comprise) de l'appeler.

Définir une fonction c'est indiquer le contenu réel de la fonction elle-même.

2) DECLARATIONS DE FONCTIONS

Déclarer une fonction c'est donner son prototype, il est de la forme:

<type> <nomfonction> ([<info_param1>,<info_param2>,etc.]);

Ceci précise le nom de la fonction, le type de la valeur qu'elle retourne et, entre parenthèses, les informations concernant les paramètres formels ou arguments.

<info_param> précise pour chaque paramètre le type de donnée et son nom.

Lorsqu'aucun type n'est précisé, celui-ci est supposé être int par défaut. Si la fonction n'a pas de valeur à retourner elle sera de type void.

Même si la liste de paramètres est vide les parenthèses qui l'entourent restent obligatoires.

Exemples:

float get_ratio(double x,int y); int max(int a,b); void toto();

/* identique à max(int a,b); */ /* identique à void toto(void); */

3) DEFINITIONS DE FONCTIONS Elle est de la forme

<type> <nomfonction> ([<info_param1>,<info_param2>,etc.])

{

[<déclarations locales>]; <instructions>;

}

On distingue l'en-tête, qui correspond au prototype sans point-virgule, et le corps entre accolades qui est constitué d'un bloc indiquant le contenu réel de la fonction.

Toutes les déclarations faites à l'intérieur ne sont visibles (c'est à dire peuvent être utilisées) que dans cette fonction.

l'instruction

Toute

fonction

qui

n'est

pas

de

type

void

devrait

normalement

comporter

return[(<expression>)]; qui définit la valeur qui doit être retournée à l'appelant.

Exemples:

int max(int a,b) { return((a>b)? a : b);

}

void erreur(char mess[16]) {

printf("***erreur***/n>>%16s/n",mess);

}

Cours sur le langage C

4) APPEL D'UNE FONCTION

L'appel d'une fonction est réalisée par:

<nomfonction> (<liste des paramètres effectifs>);

Les paramètres effectifs sont séparés par des virgules dans la liste.

L'exécution du programme est interrompue, la liste des paramètres effectifs est mise en correspondance avec la liste des paramètres formels et les instructions de la fonction sont exécutées, puis la valeur résultat de la fonction est retournée à l'appelant.

Exemples:

int j,r;

r=max(2*j,10);

if (r>100) erreur("dépassement");

/* initialise les paramètres formels a et b respectivement à 2*j et 10 */

5) PASSAGE DES PARAMETRES Les paramètres formels sont en fait des variables locales à la fonction qui sont initialisées lors de l'appel par les valeurs des paramètres effectifs (valeurs effectivement passées).

Les valeurs des paramètres effectifs sont recopiées dans les emplacements mémoire de la pile correspondant aux paramètres formels. La fonction travaille donc sur des copies et non sur les originaux qui restent intacts. On dit que le passage des paramètres se fait par valeur.

Si la fonction a pour but de modifier le contenu des originaux il faut donc passer en argument l'adresse du paramètre effectif et non sa valeur.

6) VARIABLES LOCALES Les variables déclarées dans le corps de la fonction sont locales, elles sont crées dans la pile lors de l'appel de la fonction comme les paramètres formels mais ne sont pas initialisées (elles sont de classe auto).

Les noms des variables locales à un bloc doivent être tous différents.

Ces noms peuvent être les mêmes que ceux des variables définies au niveau global; dans ce cas ces variables globales de mêmes noms ne sont plus visibles dans la fonction ou dans le bloc.

L'attribut static permet de définir des variables locales rémanentes, il spécifie que cette variable doit être allouée dans un emplacement mémoire permanent et non plus dans la pile comme les variables automatique (auto). La durée de vie d'une telle variable est alors celle du programme complet, en conséquence, cette variable conserve sa valeur entre deux appels de la fonction.

Exemple:

f(char x,int *y) /* définition de la fonction f */

{ x='s';

/* ne modifie pas l'original */ /* modifie l'original */

(*y)++;}

int i; char c; f(c,&i); /* appel de la fonction f */ /* x=copie de la variable c; f laisse c inchangé */ /* y=copie de l'adresse de i; f modifie le contenu de i */

7) POINTEURS DE FONCTION

L'identificateur d'une fonction sans les parenthèses à la suite représente l'adresse de la fonction. Il est donc possible de définir un pointeur sur une fonction:

int (*ptrf)();

/* ptrf est un pointeur de fonction retournant un entier; ne pas confondre avec */

int *f();

/* f est une fonction retournant un pointeur sur un entier */

Cours sur le langage C

P)P) LESLES POINTEUPOINTEURSRS

1) DEFINITIONS

Un pointeur est une variable contenant l'adresse d'un objet.

L'opérateur & unaire fournit le pointeur (adresse) sur l'opérande .

L'opérateur * unaire considère son opérande comme un pointeur et permet de désigner l'objet pointé.

Exemple:

int i,j; ptr=&i; /* ptr contient l'adresse de la variable entière i */ j=*ptr; /* met l'entier pointé par ptr dans j; équivalent à j=i */

La déclaration d'une variable pointeur fait toujours intervenir le type de l'objet pointé; on dit que le pointeur est typé.

Dans l'exemple précédent il fallait déclaré la variable ptr ainsi: int *ptr (*ptr est un entier, ptr est donc un pointeur sur entier).

On peut avoir un pointeur de pointeur: int **p_ptr.

2) OPERATIONS SUR LES POINTEURS

Pointeur NULL

NULL (en majuscules) est une valeur de pointeur constante et prédéfinie valant 0. Cette valeur appartient à tous les types de pointeurs et signifie "ne pointe aucun objet".

Incrémentation décrémentation

L'incrémentation d'un pointeur par l'entier 1 est autorisé et tient compte du type des objets pointés. Elle signifie "passer à l'objet du type pointé qui suit immédiatement en mémoire". Cette incrémentation utilise donc la taille des objets pointés. Le résultat réel est en fait une incrémentation de la valeur de cette taille.

Une incrémentation par un entier quelconque est une répétition de l'opération précédente. Dans le cas d'une valeur négative, une décrémentation à lieu.

Exemple:

int *ptr,k;

ptr++;

ptr+=k; /* le contenu de ptr est augmenté de k fois la taille d'un entier */ ptr-=k;

/* le contenu de ptr est augmenté de la taille de l'entier */

Comparaison

Il est possible de comparer deux pointeurs entre eux et de comparer un pointeur à la valeur NULL.

Soustraction

La différence de deux pointeurs de même type donne le nombre d'éléments entre les deux adresses.

Pointeurs et chaîne de caractères

Une chaîne de caractères est un tableau, l'utilisation d'une chaîne de caractères se traduit par la réservation en mémoire de la place nécessaire pour contenir cette chaîne (plus le caractère \0) et la production d'un pointeur sur le premier caractère de la chaîne. Exemple: char *p; p="Langage C"; /* p reçoit l'adresse du caractère 'L' */

Cours sur le langage C

Q)Q) LESLES TABLEAUXTABLEAUX

1) LES TABLEAUX SIMPLES

Un tableau regroupe plusieurs données de même type. Chaque donnée du tableau est appelé élément du tableau. La taille du tableau est donnée entre [ et ]. Exemples de déclaration de tableaux:

int tab[4]; char message[10];

/*tab est un tableau de 4 entiers*/ /*message est un tableau de 10 caractères*/

A chaque élément d'un tableau est associée une valeur entière appelée indice. w l'indice du premier élément est toujours 0, w l'indice d'un tableau de taille n varie donc de 0 à n-1.

Pour accéder à un élément on utilisera l'identificateur du tableau associé à une expression entre crochet dont l'évaluation fournit l'indice. Exemples d'éléments de tableaux: tab[3], mess[2+j].

2) LES TABLEAUX A PLUSIEURS DIMENSIONS Ce sont les tableaux de tableaux. Il faut donc deux indices pour accéder aux éléments.

Exemple de déclaration: int tab[3][2]; /*déclaration d'un tableau constitué de 3 tableaux de 2 entiers*/

En mémoire il faut savoir que c'est l'indice qui est le plus à droite qui varie le plus vite.

tab[0][0]

tab[0][1]

tab[1][0]

tab[1][1]

tab[2][0]

tab[2][1]

Remarques

tab[0][]

tab[1][]

tab[2][]

int tab[20]; tab[i] est le i+1 ième élément du tableau, c'est une variable. tab est une constante, c'est l'adresse du tableau ou adresse du premier élément. tab est identique à &tab[0] c'est un pointeur du type des éléments du tableau. tab étant une constante les expressions suivantes sont fausses: tab++ ; tab=expression.

double t2d[10][20]; t2d, t2d[i] avec 0 [ i [ 9 sont des constantes contenant des adresses. On a t2d =&t2d[0][0] et t2d[2]=&t2d[2][0]. t3d[i][j] 0 [ i [ 9 et 0[ j [ 19 sont des variables réelles double.

3) INITIALISATION DES TABLEAUX Un tableau peut être explicitement initialisé au moment de la compilation si il est extern ou static:

char text[10]="mon texte"; /*la dimension doit être 10 au min compte tenu du \0 de fin de chaîne*/ char text[10]={'m','o','n',' ','t','e','x','t','e','\0'};/*équivalent à la ligne du dessus*/ char text[]="mon texte";/*dimension est automatiquement calculée par le compilateur et mis à

10*/

int chiffre[10]={0,1,2,3,4,5,6,7,8,9}; /* initialisation complète du tableau chiffre */ int pair[5]={2,4,6};/*les deux derniers éléments sont initialisés à zéro*/ int tab[5][4]={

{0,1,2,3},

/* initialisation de tab[0][] */

{4,5,6,7},

/* initialisation de tab[1][] */

};

/* le reste est initialisé à 0 */

int tab[]; sans précision de dimension ni initialisation est correct si tab a été défini ailleurs avec sa dimension. Cette déclaration n'alloue aucun espace mémoire.