Atelier de Programmation:

- Le Langage C -
Sommaire

◼ Histoire du langage C

1. Introduction au langage

2. Éléments de base (règles d’écriture, types…)

3. Les variables

4. Opérateurs et expressions

5. Les entrées-Sorties (printf, scanf)

6. Les structures de contrôle

Sommaire

7. Les objets structurés (tableaux, structures)

8. Les Fonctions

9. Les pointeurs
 Histoire du C

◼ Origines
C a trois ancêtres : les langages CPL, BCPL et B.

CPL : (pour Combined Programming Language) a été conçu au début des

années 1960 - universités de Cambridge et de Londres. Fortement typé
mais trop complexe → disparition dans las année 70

BCPL : (pour Basic CPL) Cambridge en 1966 par Martin Richards. Version
simplifiée → Ecriture d’un 1er Compilateur et de divers systèmes
d’exploitations

B : Ken Thompson vers 1970 dans les laboratoires Bell → Version simplifiée
du BCPL
 Histoire du C

C: développé par un collègue de Ken Thompson, Dennis Ritchie qui ajouta les
tableaux, les pointeurs, les nombres à virgule flottante, les structures...
1972 fut l'année de développement la plus productive et sans doute l'année
de baptême de C. En 1973, C fut suffisamment au point pour que 90% de
UNIX puisse être récrit avec.

- Une 1ère définition du langage est apparue en 1978 avec l’ouvrage de

Ritchie et Kernighan « The C programming language ».

- Son succès international a contribué à sa normalisation:

1- ANSI (American National Standard Institute
2- ISO (International Standadization Organisation
3- CEN (Comité Européen de Normalisation) en 1993
 1. Introduction au langage C

- Le langage C est un langage de bas niveaux, dans le sens où il permet la

manipulation de données que manipulent les ordinateurs (Bit, octet, adresse) ≠
Langages évolués (Pascal, Fortran, ADA)

- Il est suffisamment général pour permettre de développer des application de

type scientifique ou de gestion basée sur l’accès aux bases de données (Word
et Excel sont écrits à partir de C et C++)

- Il est un des 1ers langages offrant des possibilités de programmation modulaire:

Un programme peut être constitué de plusieurs module
 1. Introduction au langage C
- Un langage de programmation a pour finalité de communiquer avec la machine. Le
langage maternel de la machine n'utilise que deux symboles (0 et 1): c'est le langage
machine.

Exemple: le nombre 5 est reconnu par une machine par la succession des symboles 101
(c'est la représentation du nombre en base 2).

De même, les opérations qu'une machine est capable d'exécuter sont codées par des
nombres, c'est-à-dire une succession de 0 et 1. Par exemple, l'instruction Machine
00011010 0001 0010 demande à la machine d'effectuer l'opération 1+2.

Ce langage est le seul qui soit compris par l'ordinateur, Est-il alors le seul moyen pour
communiquer avec celui-ci???

Réponse : Non, utilisation du langage assembleur : add $1 $2

Il fut suivi par des langages plus sophistiqués et de plus en plus proche du langage
humain
 1. Introduction au langage C

- La programmation structurée (Fortran, Pascal, C, Perl, Tcl ),

- La programmation structurée et modulaire (Ada, Modula),
- La programmation fonctionnelle (Lisp)
- La programmation logique (Prolog)
- La programmation objet (C++, Java, VB.net, C# …).

Compilateur
 1. Introduction au langage C
Qu’est ce qu’un programme C?

C’est un texte écrit avec un éditeur de texte, respectant une certaine syntaxe et
stocké sous forme d'un ou plusieurs fichiers (généralement avec l'extension .c). A
l'opposé du langage assembleur, les instructions du langage C sont obligatoirement
encapsulées dans des fonctions et il existe une fonction privilégiée appelée main qui
est le point de départ de tout programme.
Exemple:
#include<stdio.h>
int main()
{
printf(’’Bonjour!’’);
return 0;
}
Source.c Compilation Objet.o Edition des liens Exécutable
 2. Éléments de base
2.1 les fichiers include

Exemple:
# include <stdio.h>
void main()
{
printf(’’Bonjour!’’);
}

La directive #include inclue le fichier stdio.h au programme avant la compilation (pour

pouvoir utiliser la fonction prédéfinie printf.

On parle alors de préprocesseur

 2. Éléments de base
2.2 les Commentaires

Exemple:
# include <stdio.h> //pour pouvoir utiliser la fonction printf
void main()
{
printf(’’Bonjour!’’);
}
/*Ce programme imprime la chaine de
caractère ‘’Bonjour!’’ à l’écran*/
 2. Éléments de base
2.3 Présentation de quelques instructions du langage C
 2. Éléments de base
2.3 Présentation de quelques instructions du langage C

Exemple 2 :
 2. Éléments de base
2.4 Les identificateurs

Les identificateurs servent à désigner les différents objets manipulés par le

programme: Variables, fonctions, …

- Commence nécessairement par une lettre

- une lettre majuscule est tenue pour différente de la lettre minuscule correspondante;
- Au plus 31 caractère
- Le caractère _ (appelé « blanc souligné ») est considéré comme une lettre ; il peut
donc figurer à n'importe quelle place dans un identificateur: _Total2, Prix_unit
- Ne peut être un des mots réservés du C
 2. Éléments de base
Les Mots réservés

Les mots suivants sont réservés. Leur fonction est prévue par la syntaxe de C et ils ne
peuvent pas être utilisés dans un autre but :

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

 2. Éléments de base
2.5 Les Types dans C

Les types de base du langage C se répartissent en 3 grande catégories en fonction

de la nature des informations qu’ils permettent de représenter:

◼ Nombres entiers (int)

◼ Nombres flottants (float ou double)

◼ Caractère (char): apparaît en C comme un cas particulier de int.

Ils peuvent être signés ou non signés : signed ou unsigned (unsigned int x;)
 2. Éléments de base
a. Les Types Entiers

◼ short int ou short (entier sur 16 bits : - 32 768 à 32 767)

◼ int (entier sur 32 bits : - 2 147 483 648 à 2 147 483 647)

◼ long int ou long (entier sur 32 bits ou 64 bits, selon les machines)

Chacun des 3 peut être nuancé par l’utilisation du qualificatif unsigned pour ne

représenter que des nombres positifs:

Exemple: unsigned short x; x peut aller de 0 à 65 535

pas de bit réservé pour le signe

- C accepte les constantes entière en notation décimale, hexadécimale ou octale

 2. Éléments de base
b. Les Types Flottants

Float : codé sur 4 octets avec 1 bit de signe, 23 bits de mantisse et 8 bits
d'exposant
Double : codé sur 8 octets avec 1 bit de signe, 52 bits de mantisse et 11
bits d'exposant
Long : codé sur 10 octets avec 1 bit de signe, 64 bits de mantisse et 15 bits
d'exposant

- C accepte les constantes flottante en notation décimale ou scientifique

3.5e+3 3500 2.43 -0.38 -.38 4. .27

2. Éléments de base
c. Le Type Char

En C, un caractère est un entier signé codé sur 1 octet

Notation des constantes caractères : ‘a’ , ‘$’ ..

Important: ‘a’ ≠ ‘’a’’

Il existe des caractères non imprimables, tel que le changement de ligne, de

Tabulation, … en voici un tableau récapitulatif
2. Éléments de base

NOTATION RESULTAT
\a cloche ou bip (alert ou audible bell)
\b Retour arrière (Backspace)
\f Saut de page (Form Feed)
\n Saut de Ligne (Line Feed)
\r Retour chariot (Carriage Return)
\t Tabulation horizontaLe (HorizontaL Tab)
\v Tabutation verticale (VerticaL Tab)
\\ \
\' ‘
\ '' ‘’
\? ?
 2. Éléments de base
A propos du type booléen :

Pas de type booléen en C. Le type booléen est représenté par un entier. Il se comporte
comme la valeur booléenne vraie si cette valeur entière est non nulle.

Dans un contexte qui exige une valeur booléenne (comme les tests, par exemple), un
entier non nul équivaut à vrai et la valeur zero équivaut à faux
 3. Les Variables
3.1 Declaration

Type nom_de_la_variable [= valeur] ;

Exemple:
• int nb;
• float x = 2.34;//déclaration et initialisation
• char c = 'x';
• long a, b, c;
• double r = 7.1974851592;
 Constante
◼ Une constante identifie (avec les variables) les donnée
manipulées dans un algorithme.
◼ Une constante est une donnée dont la valeur reste fixe au
cours de l’exécution d’un programme.
Exemple:
Pi=3.14
Tva=0.18
En C Exemple

#define nom_constante valeur #define pi 3.14

const type nom_constante=valeur const double pi=3.14

23
4. Opérateurs et Expressions

◼ Les opérateurs sont des symboles qui permettent

de manipuler des objets(variables et constantes).
◼ En C, on distingue plusieurs types d’opérateurs:
➢ Les opérateurs de calcul
➢ Les opérateurs de comparaison
➢ Les opérateurs logiques
➢ Les opérateurs d’incrémentation
➢ Les opérateurs bit-à-bit
➢ Etc.

24
 Opérateurs arithmétiques
Opérateur Opération Exemple
= affectation x=7
+ addition x+3
- soustraction x-3
* produit x*3
/ division x/3
% reste de division x%3

◼ Remarque: le quotient de deux entiers fournit un entier. Ainsi 5/2 vaut 2; en

revanche, le quotient de deux flottants (noté, lui aussi, /) est bien un flottant
(5.0/2.0 vaut bien approximativement 2.5).
25
Opérateurs relationnels

Opérateur Opération Exemple

== égalité x==3
< infériorité stricte x<3
<= infériorité large x<=3
> supériorité stricte x>3
>= supériorité large x>=3
!= différence x!=3

26
 Opérateurs logiques
Opérateur Opération

|| OU logique (=1 si les deux opérandes sont

vraies)
&& ET logique (=1 si l’une des opérandes est
vraie)
! NON logique

Toute valeur numérique non nulle correspond à Vrai et la valeur 0

correspond à Faux !!

27
 Opérateurs d’incrémentation/décrémentation

Opérateur Opération Exemple

++ incrémentation x++
(x=x+1) ++x
-- décrémentation x- -
(x=x-1) - -x

Opération Description Résultat (x=7)

y=x++ passe d’abord la valeur de x à y puis
incrémente x.
y=x- - passe d’abord la valeur de x à y puis
décrémente x.
y=++x incrémente x puis passe la nouvelle valeur à
y.
y=- - x incrémente x puis passe la nouvelle valeur à
y. 28
 Opérateurs d’assignation

Opérateur Opération Exemple Résultat (x=7)

+= addition + affectation x+=2

-= soustraction + affectation x-=2

*= produit + affectation x*=2

/= division + affectation x/=2

29
 Priorité des opérateurs
Priorité Opérateurs
+ + + + + ++ () []
++++++++ -- ++ !
+++++++ * / %
++++++ + -
+++++ < <= >=
++++ == !=
+++ &&
++ ||
+ = += -= *= /=

30
 4. Opérateurs et Expressions
Conversions implicites :
◼ On peut écrire des expressions mixtes dans lesquelles interviennent des opérandes
de types différents:
int n,p; float x; n*x + p
(int * float) + int
Conversion implicite: int → float ( float*float) + int
float + int
On parle de conversion d’ajustement de type: int→long→float→double→long double
L’opérateur de CAST :

Exemple: int n=10, p=3;

(n/p) aura comme valeur 3
(double) n/p aura comme valeur 3.33333…
 5. Les Entées-Sorties

Affichage à l’écran
◼ Fonction de la bibliothèque stdio (Standard Input/Output)
Syntaxe 1 : printf("texte ") ;
Syntaxe 2 : printf("texte1 %x1 texte2 %x2... ",<expr1>,<expr2>,...) ;
◼ printf("format de l’affichage", var) permet d'afficher la valeur de la
variable var (c'est l'équivalent de écrire en pseudo code).
◼ printf("chaine") permet d'afficher la chaîne de caractères qui est
entre guillemets " "
◼ int a=1, b=2;
printf("a vaut :%d et b vaut:%d \n ", a, b); //a vaut 1 et b vaut 2
◼ float r= 7.45; printf(" le rayon =%f \n ",r);
 5. Les Entées-Sorties

Saisie au clavier
◼ Fonction de la bibliothèque stdio (Standard Input/Output)
Syntaxe : scanf("%x1 %x2...", &<variable1>, &<variable2>,...) ;

Exemple:
int n;
printf("n=");
scanf("%d",&n);
 Formats de représentation
Symbole Type Description
%d ou %i int entier relatif
%u unsigned int entier naturel
%o int entier exprimé en octal
%x ou %X int entier exprimé en hexadécimal
%f double, float réel en notation décimale
%e ou %E double, float réel en notation exponentielle
%c char caractère
%s char* chaîne de caractères

34
 Application

Ecrire un Programme C permettant de saisir

le rayon d’un cercle, calculer et afficher sa
surface.

35
Structures de contrôle
◼ Les structures de contrôle définissent la façon avec laquelle
les instructions sont effectuées. Elles conditionnent l'exécution
d'instructions à la valeur d'une expression
◼ On distingue :
➢ Les structures alternatives (tests) : permettent
d’effectuer des choix càd de se comporter différemment
suivant les circonstances (valeur d'une expression). En C,
on dispose des instructions : if…else et switch.
➢ Les structures répétitives (boucles) : permettent de
répéter plusieurs fois un ensemble donné d’instructions.
Cette famille dispose des instructions : while, do…while et
for
L’instruction if…else
◼ Syntaxe : If (expression)
bloc-instruction1
else
bloc-instruction2
• bloc-instruction peut être une seule instruction terminée par un
point-virgule ou une suite d’instructions délimitées par des
accolades { }
•expression est évaluée, si elle est vraie (valeur différente de 0),
alors bloc-instruction1 est exécuté. Si elle est fausse (valeur 0)
alors blocinstruction2 est exécuté

◼ La partie else est facultative. S’il n’y a pas de traitement à

réaliser quand la condition est fausse, on utilisera simplement
la forme : If (expression) bloc-instruction1
if…else : exemples
◼ float a, b, max;
if (a > b)
max = a;
else
max = b;
◼ int a;
if ((a%2)==0)
printf(" %d est paire" ,a);
else
printf(" a est impaire ",a);
Imbrication des instructions if
◼ On peut imbriquer plusieurs instructions if…else
◼ Ceci peut conduire à des confusions, par exemple :
➢ if (N>0)

if (A>B)
MAX=A;
else MAX=B; (interprétation 1 : si N=0 alors MAX prend la
valeur B)
➢ if (N>0)

if (A>B)
MAX=A;
else MAX=B; (interprétation 2 : si N=0 MAX ne change pas)
◼ En C un else est toujours associé au dernier if qui ne possède pas
une partie else (c’est l’interprétation 2 qui est juste)
 Imbrication des instructions if
◼ Conseil : pour éviter toute ambiguïté ou pour forcer une certaine
interprétation dans l’imbrication des if, il vaut mieux utiliser les
accolades
➢ if(a<=0)
{if(a==0)
printf("a est nul ");
else
printf(" a est strictement négatif ");}
else
printf(" a est strictement positif " );
➢ Pour forcer l’interprétation 1: if (N>0)
{ if (A>B)
MAX=A;}
else MAX=B;
 L’instruction d’aiguillage switch :
◼ Permet de choisir des instructions à exécuter selon la valeur d’une
expression qui doit être de type entier
◼ la syntaxe est :
switch (expression) {
case expression_constante1 : instructions_1; break;
case expression_constante2 : instructions_2; break;
…
case expression_constante n : instructions_n; break;
default : instructions;
}
◼ expression_constante i doit être une expression constante entière
◼ Instructions i peut être une instruction simple ou composée
◼ break et default sont optionnels et peuvent ne pas figurer
Fonctionnement de switch
◼ expression est évaluée
◼ si sa valeur est égale à une expression_constante i, on se
branche à ce cas et on exécute les instructions_i qui lui
correspondent
➢ On exécute aussi les instructions des cas suivants jusqu’à
la fin du bloc ou jusqu’à une instruction break (qui fait
sortir de la structure switch)
▪ si la valeur de l'expression n'est égale à aucune des
expressions constantes
➢Si default existe, alors on exécute les instructions qui le
suivent
➢Sinon aucune instruction n’est exécutée
Switch : exemple
main( )
{ char c;
switch (c) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
case 'y': printf("voyelle\n"); break ;
default : printf("consonne\n");
}
}
 Les boucles while et do ..
while
while (condition) Do
{ {
Instructions instructions
} }
while (condition);
▪ la condition (dite condition de contrôle de la boucle) est évaluée
à chaque itération. Les instructions (corps de la boucle) sont
exécutés tant que la condition est vraie, on sort de la boucle dès
que la condition devient fausse
▪dans la boucle while le test de continuation s'effectue avant
d'entamer le corps de boucle qui, de ce fait, peut ne jamais
s'exécuter
▪ par contre, dans la boucle do-while ce test est effectué après le
corps de boucle, lequel sera alors exécuté au moins une fois
Boucle while : exemple
Un programme qui détermine le premier nombre entier N tel que
la somme de 1 à N dépasse strictement 100
main( )
{ int i, som;
i =0; som= 0;
while (som <=100)
{ i++;
som+=i;
}
printf (" La valeur cherchée est N= %d\n ", i);
}
Boucle do .. while : exemple
Contrôle de saisie d'une note saisie au clavier jusqu’à ce que
la valeur entrée soit valable
main()
{ int N;
do {
printf (" Entrez une note comprise entre 0 et 20 \n");
scanf("%d",&N);
} while (N < 0 || N > 20);
}
La boucle for
for (expr1 ; expr2 ; expr3)
{
instructions
}
◼ L'expression expr1 est évaluée une seule fois au début de
l'exécution de la boucle. Elle effectue l’initialisation des
données de la boucle
◼ L'expression expr2 est évaluée et testée avant chaque
passage dans la boucle. Elle constitue le test de continuation
de la boucle.
◼ L'expression expr3 est évaluée après chaque passage. Elle
est utilisée pour réinitialiser les données de la boucle
 Boucle for : remarques

équivaut à:
for (expr1 ; expr2 ; expr3) expr1;
{ instructions while(expr2)
instructions {
} expr3;
}

▪ En pratique, expr1 et expr3 contiennent souvent plusieurs

initialisations ou réinitialisations, séparées par des virgules
Boucle for : exemple
Calcul de x à la puissance n où x est un réel non nul et n un
entier positif ou nul
main ( )
{ float x, puiss;
int n, i;
{ printf (" Entrez respectivement les valeurs de x et n \n");
scanf ("%f %d" , &x, &n);
puiss =1
for ( i=1; i<=n; i++)
puiss*=x;
printf (" %f à la puissance %d est égal à : %f", x,n,puiss);
}
}
L’instruction break
◼ L’instruction break peut être utilisée dans une boucle (for, while,
ou do .. while).Elle permet d’arrêter le déroulement de la boucle
et le passage à la première instruction qui la suit
◼ En cas de boucles imbriquées, break ne met fin qu’ à la boucle la
plus interne
◼ En cas de boucles imbriquées, break ne met fin qu’ à la boucle la
plus interne
◼ Exemple résultat:
{int i,j; i=0,j=0
i=1,j=0
for(i=0;i<4;i++)
i=2,j=0
for (j=0;j<4;j++) i=3,j=0
{ if(j==1) break;
printf("i=%d,j=%d\n ",i,j);
}
}
L’instruction continue
◼ L’instruction continue peut être utilisée dans une boucle (for, while,
ou do .. while). Elle permet l’abandon de l’itération courante et le
passage à l’itération suivante:
➢ {int i;
for(i=1;i<5;i++)
{printf("début itération %d\n " ,i);
if(i<3) continue;
printf(" fin itération %d\n " ,i); résultat:
} début itération 1
} début itération 2
début itération 3
fin itération 3
début itération 4
fin itération 4