1

INTRODUCTION A LA
PROGRAMMATION EN LANGAGE C
 2

EXERCICES.................................................................................................................. 11

TABLE DES MATIERES

CHAPITRE IV : LES INSTRUCTIONS DE CONTROLE ................................... 12
CHAPITRE I : GENERALITES................................................................................... 4
4.1 L’INSTRUCTION IF ............................................................................................. 12
1.1 INTRODUCTION ................................................................................................... 4 4.2 L’ INSTRUCTION WHILE .................................................................................. 12
1.2 MISE EN ŒUVRE D’UN PROGRAMME C ....................................................... 4 4.3 L’ INSTRUCTION DO…WHILE ........................................................................ 13
4.4 L’ INSTRUCTION : FOR ..................................................................................... 13
4.5 L’ INSTRUCTION SWITCH ................................................................................ 14
CHAPITRE II : LES OBJETS DE BASE DU LANGAGE C ............................ 6
EXERCICES.................................................................................................................. 14

2.1 LES IDENTIFICATEURS ..................................................................................... 6 CHAPITRE V : LES TABLEAUX .............................................................................. 16

2.2 LES TYPES DE DONNEES ................................................................................... 6
2.3 LES CONSTANTES ............................................................................................... 6
2.4 LES VARIABLES ................................................................................................... 5.1 QU’EST CE QU’UN TABLEAU ? ...................................................................... 16
2.5 LES OPERATEURS ............................................................................................... 7 5.2 DECLARATION DES TABLEAUX .................................................................... 16
LES OPERATEURS MATHEMATIQUES .................................................................. 7 5.3 LES TABLEAUX A PLUSIEURS DIMENSIONS .............................................. 17
LES OPERATEURS RELATIONNELS ........................................................................ 7 5.4 LES TABLEAUX DE CARACTERES................................................................. 17
EXERCICES.................................................................................................................. 17
LES OPERATEURS LOGIQUES .................................................................................. 8
2.6 LES EXPRESSIONS ............................................................................................... 8
2.7 STRUCTURE GENERALE D’UN PROGRAMME C ........................................ 8 CHAPITRE VI : LES STRUCTURES & LES UNIONS ........................................... 19
EXERCICES ................................................................................................................... 9
6.1 LES STRUCTURES............................................................................................... 19
CHAPITRE III : LES INSTRUCTIONS PRINTF D'ENTREES/SORTIES.10 3.1 6.2 ACCES AUX CHAMPS DE LA STRUCTURE .................................................. 19
6.3 TABLEAUX DE STRUCTURES.......................................................................... 20
6.4 LES UNIONS .......................................................................................................... 20
L’AFFICHAGE DES DONNEES : ............................................................................. 10
6.5 ACCES AUX CHAMPS DE L’UNION ................................................................ 21
3.2 LA LECTURE DES DONNEES : SCANF .......................................................... 10 EXERCICES.................................................................................................................. 21
3.3 LES FORMATS DE DONNEES .......................................................................... 11
CHAPITRE VII : LES POINTEURS .......................................................................... 22

7.3 LES POINTEURS ................................................................................................... 22

 3

7.2 DECLARATION DES POINTEURS .................................................................. 22

7.3 L’OPERATEUR ADRESSE DE : & ................................................................... 22
7.4 POINTEUR VERS UNE STRUCTURE ............................................................. 23
7.5 STRUCTURE DONT UN CHAMPS POINTE VERS UNE STRUCTURE DU
MEME TYPE ............................................................................................................... 24
7.6 ACCES AUX ELEMENTS D’UNE STRUCTURE POINTEE......................... 24
7.7 DETERMINATION DE LA TAILLE ALLOUEE A UN TYPE ...................... 24
7.8 ALLOCATION ET LIBERATION D’ESPACE ................................................ 25
EXERCICES ................................................................................................................. 26

CHAPITRE VIII : LES FONCTIONS ....................................................................... 27

8.1 STRUCTURE DES FONCTIONS ........................................................................ 27

8.2 PORTEE DES VARIABLES ................................................................................. 28
EXERCICES .................................................................................................................. 29

CHAPITRE IX : LES FICHIERS ................................................................................ 30

9.1 DECLARATION DES FICHIERS ....................................................................... 30

9.2 OUVERTURE DES FICHIERS : FOPEN ........................................................... 30
9.3 OUVERTURE DES FICHIERS : FCLOSE......................................................... 31
9.4 ECRITURE SUR UN FICHIER : FPRINTF ....................................................... 31
9.5 LECTURE A PARTIR D’UN FICHIER : FSCANF ........................................... 31
EXERCICES .................................................................................................................. 32

ANNEXE : PRINCIPALES FONCTIONS DE C/C++ ............................................... 33

 4

La compilation consiste à lancer une certaine « vérification » du

programme. Le compilateur passe au peigne fin le programme et recherche
CHAPITRE I : GENERALITES
les différents types d’erreurs : les erreurs lexicales, les erreurs
syntaxiques et les erreurs sémantiques. Si le programme comporte une
quelconque erreur, un message d’erreur et de diagnostic est affiché au
1.1 Introduction : programmeur. Celui-ci doit alors apporter les corrections nécessaires et doit
refaire la compilation.

Lorsque le programme est épuré de toutes ses erreurs, le

compilateur génère alors le code objet du programme.
Le langage C est un langage de programmation connu pour son
efficacité, économie et portabilité. C’est un langage qui se situe entre les
Les programmes utilisent généralement des références externes
langages dits évolués (comme PASCAL) qui utilise un vocabulaire proche du
fournies par le langage de programmation , qui sont habituellement contenues
langage naturel, et le langage machine. Ses caractéristiques le rendent très
dans des librairies. L’édition des liens permet ainsi de résoudre ces
indiqué pour le développement des applications « orientées systèmes ».
références, et produit en cas de succès le code exécutable du programme.

En réalité il existe plusieurs versions du langage C (Turbo C, Quick C, C++,

Ces différentes étapes sont résumées par la figure suivante :
Visual C++, ...). Dans le cadre de ce document, nous développerons en priorité
les objets du langage C standard (norme ANSI), en faisant référence,
toutefois, le cas échéant aux nouvelles possibilités du langage C++.

1.2 Mise en œuvre d’un programme C :

La mise en œuvre d’un programme C, quelque soit l’environnement
choisi, passe par quatre étapes importantes :

• La saisie
• La compilation
• L’édition de lien
• L’exécution

La saisie consiste à saisir le code du programme en utilisant un

éditeur , généralement fourni par l’environnement du langage.
 5

Programme en code source

Compilation

Librairie 1

Librairie 2

Programme en code objet

…….

Librairie n

Edition de liens

Programme en code exécutable

MISE EN ŒUVRE D’UN PROGRAMME

 6

Un type de données est un domaine de données particulier , comme le type

des entiers, le type des réels, le type des caractères, ... etc. Pour le langage
CHAPITRE II : LES OBJETS DE BASE
DU LANGAGE C C, les types de base sont :

Type Domaine couvert

Int Domaine des entiers (..., -5, -4, ..., 0, +1, +2, +3, ...)
Ce chapitre a pour objet de passer en revue les objets de base de C : les Float Domaine des nombres réels (3.5, 2.55, ...)
identificateurs, les types, les variables, les expressions et les opérateurs. Double Domaine des nombres réels en double précision
Char Domaine des caractères (‘a’, ‘b’, ..., ‘1’, ‘2’, ..., ‘*’, ‘+’, ...)
2.1 Les identificateurs : Long Domaine des entiers longs. Ils sont représentés par
des mots de 32 bits (04 octets)
Un identificateur est un « nom » qui désigne un objet du langage C. Short Domaine des entiers courts. Ils sont représentés par
Exemples : des mots de 16 bits (02 octets).
Unsigned Domaine des entiers non signés

A partir de ces types de base, il est possible de construire des types de

données personnalisés aussi complexes que l’on veut.

var1
2.3 Les constantes :
montant_General
Une constante est un objet dont la valeur est fixe et connue. Une constante
x2
peut être entière , flottante ou de type caractères.
...
Exemples : 3.14, 25, ‘’Langage C’’, …
A noter l’obligation imposée par la plupart des langages de programmation de
commencer les identificateurs par une lettre alphabétique.
A remarquer que les constantes de type caractère est toujours délimitée par
le symbole double-quote (‘’).
2.2 Les types de données :
 7

Il est possible de donner une valeur initiale aux variables déclarées.

2.4 Les variables : Exemples :

Une variable en informatique désigne une zone mémoire référencée par un

int i=54 ;
identificateur. Cette zone en mémoire peut prendre une valeur variable.
int j=34 ; k=12 ;

On peut attribuer une valeur à une variable grâce à deux méthodes

différentes : l’affectation et la lecture.
2.5 Les opérateurs :
C utilise essentiellement trois types d'opérateurs qui sont : les opérateurs
mathématiques, les opérateurs relationnels et les opérateurs logiques.
L’affectation consiste à attribuer directement une valeur à la variable. Elle
est notée par le symbole ( = ). Exemple :
Les opérateurs mathématiques :

x=15 , attribue la valeur 15 à x. Opérateur Sens

x=y+z , attribue le résultat de l’expression y+z à x. Si x contenait + Addition
une valeur avant cette affectation, cette valeur serait - Soustraction
perdue. * Multiplication
/ Division
x=x+15 , affecte à x l’ancienne valeur de x ajoutée à la valeur 15. % Reste de la division
++ Incrémentation
Avant de pouvoir utiliser une variable, il est obligatoire de la déclarer au
-- Décrémentation
préalable.

« Déclarer une variable » consiste à lui préciser son type de données.

Exemples de déclarations :

int x, y, z , déclare trois variables entières de type

Les opérateurs relationnels :
entier.
float a1, a2 , déclare deux variables A1 et A2 de type
réel.
char c1 , déclare une variable C1 de type caractère.
 8

Opérateur Sens Exemples :

nom
< Inférieur à
x = (y +z) /t
> Supérieur à
prix *(1 + taxe)
== Egal à
!= Différent de
2.7 Structure générale d’un programme C :
<= Inférieur ou égal
>= Supérieur ou égal En Général, un programme C est structuré en quatre parties essentielles :

#include ....
Les opérateurs logiques : ....

Opérateur Sens
&& Et
Données et fonctions externes
|| Ou
.....
! Non
....
Les opérateurs relationnels fournissent des résultats pouvant avoir deux
valeurs possibles : Données et fonctions globales
....
1 (Vrai) ou 0 (Faux).
Main()
{ ....
2.6 Les expressions : ...
Une expression est constituée par la combinaison de champs, variables ....
mémoires, constantes, fonctions et d'opérateurs.
}
... Fonction1 ()...
... Fonction2 ()...

STRUCTURE GENERALE D’UN PROGRAMME C

 9

La partie <include> : permet de déclarer tous les fichiers à inclure dans le

programme en cours, lors de la compilation.

La partie « variables et fonctions externes » permet d’informer le

compilateur sur les variables et les fonctions externes manipulées par le
programme. Ces variables et fonctions sont déclarés dans d’autres
programmes.

La partie « variables et fonctions globales » permet de déclarer les fonction

et les fonctions qui peuvent être utilisées à n’importe quel endroit du
programme (par opposition aux variables et fonctions locales).

La quatrième partie définit les blocs de code du programme. Le nombre de

bloc est au moins égal à un (01) : le bloc principal (main). D’autres blocs
peuvent être définis.

Notez qu’il est obligatoire de terminer chaque instruction d’un programme C

par un point virgule.

Exercices :

Exercice 1 : Qu'est ce qu'un programme ? .

Exercice 2 : Que signifie "langage évolué" ?

Exercice 3 : L'ordinateur peut-il exécuter directement un programme écrit

en langage évolué ? Expliquez .

Exercice 4 : Expliquez pourquoi il est impératif de déclarer une variable

avant de pouvoir l’utiliser.
Exercice 5 : Quelle différente y’a-t-il un entier court et un entier long.
 10

%c pour un caractère,
%d pour un entier à afficher en décimal
%x pour un entier à afficher en hexadécimal.

CHAPITRE III : LES INSTRUCTIONS Le programme suivant affiche le carré d’un nombre n.
D'ENTREES/SORTIES

#Include <stdio.h>
Ce chapitre a pour objet de présenter les instructions d'entrée/sortie les void main()
plus importantes. {
int n ;
3.1 L’affichage des données : printf n=4 ;
n=n*n
Syntaxe : printf (<chaine_de_formats>, <liste_d’expressions>)
printf(‘’Le carré est égal à %d’’, n) ;
}
L’instruction printf permet d’afficher sur l’écran une liste d’expressions,
selon un format d’affichage souhaité (double, entier, réel, caractère, ...).

Exemple : Le programme suivant affiche « Bonjour » à l’écran. La première ligne du programme fait l’inclusion du fichier <stdio.h> qui définit
les instructions d’entrées/sorties.

Après la déclaration d’une variable n de type entier, le programme affecte la

valeur 4 à n. Il affecte ensuite le carré de la valeur à n, qui prend ainsi la
valeur 16.

#Include <stdio.h> La ligne printf(‘’Le carré est égal à %d’’, n) affiche à l’écran le message
suivant :
void main()
{
printf(‘’Bonjour’’) ; Le carré est égal à 16
}

La chaîne de formats est composée de séquences commençant par le 3.2 La lecture des données : scanf
caractère % suivi d’un caractère qui indique le format d’impression. Il
existe, entre autres : Syntaxe : scanf(<chaine_de_format>, <liste_de_variables>)
 11

Nous avons que , aussi bien pour l’instruction printf que scanf , il est
Cette instruction permet d’affecter une valeur tapée au clavier à une
impératif de préciser le format des expressions à afficher ou à lire ; les
variable.
différents format supportés sont :

Exemple : Le programme suivant fait l’entrée de deux valeurs qui seront

Format Signification
affectées respectivement à X et à Y. Il affiche après le résultat de la
%c caractère
somme :
%i Entier court
#include <stdio.h> %f réel (float)
%d Entier double
void main() %s Chaîne de caractères
{
int x, y ;

printf(‘’Entrez la première valeur : ‘’) ; EXERCICES :

scanf(‘’%i’’, &x) ;
Exercice 1 : Faire un programme qui lit deux nombres X et Y , calcule puis
printf(‘’Entrez la seconde valeur : ‘’) ; affiche le produit de X par Y.
scanf(‘’%i’’, &y) ;

printf(‘’La somme est égale à %i’’, x+y) ; Exercice 2 : Faire un programme qui lit deux nombres X et Y , et permute
} leurs valeurs .C'est à dire si X=15 et Y=10 , on doit avoir :
Y=15 et X=10 .

A noter la nécessité de faire précéder le nom de la variable cible par le

symbole & (« le et commercial »).

Les deux fonctions « printf » et « scanf » sont définies dans le fichier des
instructions standards d’entrée/sorties « stdio.h ». Il est nécessaire de
faire appel à l’inclusion de ce fichier grâce à l’instruction include au début du
programme.

3.3 Les formats de données :

 12

void main()
{
int x ;

CHAPITRE IV : LES INSTRUCTIONS printf(‘’Entrez votre nombre : ‘’) ;

DE CONTROLE scanf(‘’%i’’, &x) ;

if (x>0)
printf(‘’Nombre positif’’) ;
Ce chapitre a pour objet de présenter les instructions de contrôle de C : if, else
while, do-while et for. printf(‘’Nombre négatif’’) ;

}
Ce programme fait la lecture, au clavier, d'une donnée numérique qui sera
4.1 L’instruction if : affectée à la variable X. La instruction IF évalue la condition 'est-ce que X
est plus grand que zéro?'. Si la condition est vraie, le C affiche 'Nombre
Syntaxe : if (<condition>) { Bloc 1}
positif', dans le cas contraire, il affiche 'Nombre négatif ou nul'.

else { Bloc 2}
Remarquez que dans le cas où il y a plus d’une instruction à exécuter , en cas
de valeur vraie ou fausse, il y a lieu de les délimiter par les deux symboles
accolades { }.

Cette instruction permet la réalisation conditionnelle de différents

traitements. Si la condition évaluée est vraie, le C réalise la ou les 4.2 L’ instruction while :
instructions contenues dans la partie <Bloc1>. Dans le cas contraire, il réalise
Syntaxe : while (<Condition>)
la ou les instructions contenues dans la partie <Bloc2>.
{ <action1>
<action2>
Exemple : Le programme suivant permet de faire introduire une valeur au
...
clavier et de tester si oui ou non elle est nulle.
<action-n>
}

Cette instruction permet de répéter l'exécution d'un ensemble d'actions

#include <stdio.h> tant que une certaine condition est vraie.
 13

<action-n>
Exemple : Ce programme affiche les (10) premiers nombres entiers.
}
while (<condition>)

#include <stdio.h> Cette instruction, comme la précédente, permet de répéter un ensemble

d'actions tant que une certaine condition est vraie ; à la différence que
void main()
{ cette fois l’évaluation de la condition intervient après avoir exécuté le bloc
int i ; d’actions et non avant. Cela veut dire qu’il est certain que le corps de la
boucle s’exécutera au moins une fois.
i=1 ;
while (i<=10)
Voici une autre variante du programme précédent avec l’instruction do…while.
{
printf(‘’%i’’, i) ;
i++ ;
} #include <stdio.h>

printf(‘’Traitement terminé’’) ; void main()

} {
int i ;
Ce programme commence par initialiser la valeur de la variable mémoire I à 1. i=1 ;
Il répète ensuite, les instructions : ? I et I=I+1 tantque la valeur de I est do {
inférieure ou égale à 10. Dès que la valeur de I dépasse 10, le printf(‘’%i’’, i) ;
fonctionnement de la boucle s'arrête, et l'exécution poursuit à l’instruction i++ ;
qui suit immédiatement le bloc de répétition. C'est à dire que C affichera à }
while (i<=10)
la fin 'Traitement terminé'.
4.4 L’ instruction : for printf(‘’Traitement terminé’’) ;
Il est possible de rompre brusquement l’exécution de l’instruction while en }
faisant appel à l’instruction break..

4.3 L’ instruction do…while :

Syntaxe : for (<Variable>=<valeur1> ; <condition d’arrêt> ;
Syntaxe : do
<instruction-de-fin-boucle>)
{ <action1>
{ <action1>
<action2>
<action2>
...
...
 14

<action-n> default : <bloc_instructions>

} }

Cette instruction permet d’éviter les imbrications de tests qui concernent

Cette instruction permet de répéter l'exécution d'un ensemble d'actions une même expression.
pour une variable allant de valeur1 jusqu'à ce que une certaine condition
d’arrêt soit atteinte. Par exemple, le programme suivant fait la lecture, à partir du clavier, d’un
nombre entier et vérifie s’il est égal à 0, 1 au autre.
Exemple : Ce programme affiche les (10) premiers nombres entiers.
#Include <stdio.h>

#Include <stdio.h> void main()

{
void main() Int I ;
{
int i ; printf(‘’Entrez un nombre SVP :’’) ;
scanf(‘’%i’’, &i) ;
for (i=1 ; i<=10 ; i++)
{ printf(‘’%i’’, i) ; } switch (i)
{
printf(‘’Traitement terminé’’) ; case 0 : printf(‘’c’est un nombre nul’’) ;
} break ;
case 1 : printf(‘’c’est un nombre égal à un’’) ;
break ;
default : printf(‘’c’est un autre nombre’’) ;
break ;
4.5 L’ instruction switch : }

}
Syntaxe : switch (<expression>)
{ Cette instruction est bien adaptée pour la programmation d’un menu de choix
case <constante1> : <bloc_instructions> (interface à partir de laquelle l’utilisateur choisit une fonction).
break ;
case <constante2> : <bloc_instructions> EXERCICES :
break ;
case <constante3> : <bloc_instructions>
break ;
... Exercice 1 : Faire un programme C qui affiche tous les multiples de 5
inférieurs à 100 , en utilisant l'instruction for .
 15

Exercice 10 : Deux nombres entiers m et n sont dits amis si la somme des

Exercice 2 : Même problème mais en utilisant l'instruction while .
diviseurs de m (excepté lui-même) et égale à n, et
inversement la somme des diviseurs de n (excepté lui-
Exercice 3 : Faire un programme qui calcule puis affiche la somme des 10 même) est égale à m. Exemple : 220 et 284. Faire un
premiers entiers (de 1 à 10) . programme qui lit deux nombres entiers puis vérifie s’ils
sont amis.
Exercice 4 : Faire un programme qui calcule puis affiche la somme de tous
les multiples de 5 inférieurs à 100 . Exercice 11 : Faire un programme qui calcule le PPMC de deux nombres
entiers.
Exercice 5 : Faire un programme qui étant donné un nombre entier, vérifie
s'il est premier ou non . Un nombre entier est dit premier
Exercice 12 : Faire un programme qui calcule le PGCD de deux nombres
s'il n'est divisible que par lui même et par 1 .
entiers.

Exercice 6 : Faire un programme qui lit une suite de nombres entiers (on ne
Exercice 13 : Faire un programme qui calcule le nombre PI de la manière
connaît pas leur nombre , mais le dernier est égal à 0) ,
suivante :
calcule puis affiche :

PI= 4*(1- 1/3 +1/5 -1/7 +1/9 -1/11 +...)

. Le nombre total des entiers qui ont été lus.
. La valeur du plus grand entier lu .
On s'arrêtera lorsque la valeur absolue de l'un des termes
de la suite devient inférieur à 10-4 .
Exercice 7 : Même problème que l'exercice précédent mais en
calculant :
Exercice 14 : Un résultat connu en mathématiques : Tout nombre entier peut
. Le nombre total des entiers qui ont été lus.
être écrit sous forme d'un produit de puissances de
. Le nombre des entiers positifs qui ont été lus.
nombres premiers . Exemples :
. Le nombre des entiers négatifs qui ont été lus.

Exercice 8 : Faire un programme qui lit une suite de nombres entiers 24=23 * 3 , 70=2*5*7 , 350=2*52 *7
(on ne connaît pas leur nombre , mais le dernier est égal à 0
) , puis affiche le plus grand des nombres pairs lu et le plus Faire un programme qui lit un nombre entier et l'affiche
petit des nombres impairs lu . sous forme d'un produit de puissances de nombres
premiers.
Exercice 9 : Faire un programme qui lit un nombre entier et vérifie s'il est
parfait.Un nombre entier est dit parfait s'il est égal à la
somme de tous ses diviseurs (excepté lui-même). Exemple
6=1+2+3.
 16

5.2 Déclaration des Tableaux :

La déclaration d’un tableau doit préciser son type de base et le nombre de

CHAPITRE V : LES TABLEAUX ses éléments.

Exemples :

Ce chapitre a pour objet de présenter la structure de données tableau. int t[10] /* déclare un tableau t de 10 éléments entiers.
long int t1[10], t2[20] /* déclare deux tableaux t1 et t2 d’entiers longs. Le premier
5.1 Qu’est ce qu’un tableau ? : /* a 10 éléments et le second 20.

Jusqu'à présent nous n’avons traité que des variables simples (entières,
caractères, réelles, ...). Ces structures de données simples ne suffisent pour L’utilisation des tableaux recquiert la compréhension des remarques
répondre à tous les cas de modélisation informatique ; d’autres structures suivantes :
de données plus complexes sont nécessaires. Parmi ces structures, nous
trouvons les tableaux. • Les index des éléments d’un tableau vont de 0 à n-1.
• La taille d’un tableau doit être connue statiquement par le compilateur.
Un tableau peut être définit schématiquement comme une suite de variables C’est à dire qu’il est impossible d’écrire :
simples. L’accès à un élément quelconque du tableau se fait grâce à son
indice. int t[n], où n serait une variable.

... Le programme suivant fait la saisie de 5 valeurs qui seront affectées à un

0 1 2 3 ... n tableau T. Ces valeurs seront alors affichées en sens inverse (de la dernière
à la première). #Include <stdio.h>
void main()
{
T[3] signifie, par exemple, l’élément de rang 3 du tableau T. Dans le langage int T[5] ;
C, la numérotation des tableaux commence par l’indice 0. int k, v ;

for (k=0 ; k<5 ; k++)

{ scanf(‘’%i’’, &v) ;
 17

Exercice 1 : Faire un programme qui range N valeurs numériques dans un

T[k]=v
tableau, puis recherche si une valeur donnée X existe dans ce
}
tableau.
for (k=4 ; k>-1 ; k- -)
printf(‘’%i’’, T[k]) ; Exercice 2 : Faire un programme qui lit les N éléments d'un tableau
} numérique puis affiche le maximum .

Exercice 3 : Faire un programme qui lit les N éléments d'un tableau

5.3 Les tableaux à plusieurs dimensions : numérique , puis le trie par ordre croissant .

Il est possible de déclarer des tableaux à plusieurs dimensions. Par Exercice 4 : Soit une suite mathématique définie de la manière suivante :
exemple :
Un = Un-1 + 2*Un-2
int T[5][10] /* Tableau à deux dimensions (matrice de 5 lignes U0 = 1 , U1 = 3
/*et 10 colonnes).
Faire un programme qui étant donné un nombre entier N range
tous les éléments de cette suite dans un tableau .
5.4 Les tableaux de caractères : Faire un autre programme qui consulte la valeur d'un élément
quelconque Ui .
Comme pour les autres types de base, il est possible de manipuler des
tableaux de caractères. Il existe toutefois une particularité pour ces Exercice 5 : Faire un programme qui étant donnés deux tableaux numériques
derniers qui consiste en la possibilité d’affecter toute une chaîne au tableau triés A et B (dont le nombre d'éléments sont respectivement m
. et n ) en tire un nouveau tableau numérique trié C . (Faire
attention de ne pas reproduire un élément plus d'une fois) .
Exemple : Exemple :

char t[20] ; /*déclare un tableau de caractères de 20 éléments

t= ‘’Langage C’’; /* affecte la chaine de caractère ‘’Langage C’’ au
/*tableau t.

Exercices.
 18

1 5 8 9 10 14 A Exercice 9 : Faire un programme qui étant donnée une matrice de nombres ,

recherche puis affiche le plus grand élément .
2 5 6 10 11 14 15 16 B
Exercice 10 : Faire un programme qui étant donnée une matrice de nombres
, affiche le maximum de chaque colonne.
1 2 5 6 8 9 10 11 14 15 16 C
Exercice 11 : Le point de selle d'une matrice est l'élément qui est minimal
sur sa ligne et maximal sur sa colonne . Par exemple, le nombre
Exercice 6 : Faire un programme qui lit les N éléments d'un tableau de 7 de la matrice suivante est un point de selle :
caractères , et vérifie s'il s'agit d'une chaîne palindrome .
6 5 2
Une chaîne de caractères est dite palindrome si elle est
11 7 8
identique à son image miroir (c'est à dire qu'on peut la lire
14 3 1
indifféremment de droite à gauche ou de gauche à droite ) .
4 4 9
Exemples : radar, elle, sos , ... etc.

Exercice 7 : Faire un programme qui affiche tous les entiers premiers Le point de selle s'il existe est unique. Faire un programme
inférieurs à un nombre donné N . qui cherche le point de selle d'une matrice.

Exercice 12 : Faire un algorithme qui fait la somme de deux matrices

Indication : Représenter dans un tableau tous les nombres
numériques .
entiers compris entre 1 et N, puis au fur et à mesure afficher
un nombre premier et éliminer tous ses multiples.
Exercice 13 : Faire un algorithme qui fait le produit de deux matrices
numériques.
Exercice 8 : Etant donné un tableau numérique trié par ordre croissant.
Faire une recherche dichotomique pour vérifier si un nombre X
existe dans ce tableau.

La recherche dichotomique se fait de la manière suivante:

- On compare le nombre X avec l'élément du milieu du tableau.

- Si les deux valeurs sont égales on arrête la recherche , sinon
on ignore la moitié du tableau dans laquelle on n'a aucune
chance de trouver la valeur X et on considère l'autre moitié. Le
nombre X est alors comparé au milieu de cette partie , ... et
ainsi de suite.
 19

Struct <nom_structure>
{ type1 membre1 ;
type2 membre2 ;
CHAPITRE VI : LES STRUCTURES &
LES UNIONS type3 memebre3 ;
....
typen membren
}
Ce chapitre a pour objet de présenter les structures du langage C.
L’exemple suivant déclare deux variables p1 et p2 , qui ont toutes les deux la
6.1 Les Structures : même structure que personne.

Une structure en langage C est une structure de données qui regroupe des
variables hétérogènes, c’est à dire qui peuvent avoir des types différents. Struct personne
{
int age ;
C’est le cas , par exemple, des informations concernant une personne qui
float taille, poids ;
peuvent être regroupées au sein d’une même structure : char nom[20] ;
} p1, p2 ;
Struct personne
{
int age ;
float taille, poids ; 6.2 Accès aux champs de la structure :
char nom[20] ;
} Pour désigner un champs d’une structure, il faut utiliser l’opérateur de
sélection de champ qui se note . (point).
Cette déclaration précise que l’identificateur personne est une structure
composée des quatre champs : le premier est un entier nommé age, le second Par exemple, si p1 et p2 sont deux variables de type struct personne, on
est un réel nommé taille, le troisième est un réel nommé poids et le dernier désignera le champs nom de p1 par p1.nom, et on désignera le champ taille
est un tableau de 20 caractères représentant le nom de la personne. de p2 par p2.taille.
Une structure est construite selon le schéma général suivant :
Le programme suivant montre un exemple de manipulation d’une structure
personne. Il permet la saisie des renseignemens d’une personne donnée.

#Include <stdio.h>
 20

Struct personne t[100] ;

void main()
{
struct personne Pour référencer le nom de la personne qui a l’index I dans t , on écrira :
{ int age ;
float taille, poids ;
T[I].nom ;
char nom[20] ;
}
6.4 Les Unions :
int a ;
float t, p ;
char n[20] ; La structure de données « union » est une structure qui permet de manipuler
personne homme ; un champs en utilisant plusieurs types de données. En clair cela veut dire que
printf(‘’Introduisez l’age ‘’) ; la donnée peut être « vue » comme amorphe (ayant plusieurs formes).
scanf(‘’%i’’, &a) ;
homme.age=a ; L’exemple suivant déclare une union décrivant une zone mémoire qui peut
être vue, selon le cas, comme une valeur entière ou un caractère.
printf(‘’Introduisez le poids ‘’) ;
scanf(‘’%f’’, &p) ;
homme.poids=p ; Union zone
{ int i ;
printf(‘’Introduisez la taille ‘’) ; char c ;
scanf(‘’%f’’, &t) ;
}
homme.taille=t ;

printf(‘’Introduisez le nom ‘’) ; l’emploi des différents éléments d’une union se fait comme pour les
scanf(‘’%c’’, &n) ; structures. Ainsi si z est une variable de type zone, on peut alors écrire :
homme.nom=n ;

z.i = 15
z.c = ‘t’
6.3 Tableaux de structures :
D’une manière générale , la déclaration d’une union se fait selon le schéma
Une déclaration de tableau de structures se fait selon le même modèle que la
suivant :
déclaration d’un tableau dont les éléments sont de type simple.

Union <nom_union>
Supposons que l’on ait déjà déclaré la struct personne, si on veut déclarer un
{ type1 membre1 ;
tableau de 100 strcutures de ce type, on écrira :
type2 membre2 ;
type3 memebre3 ;
....
 21

typen membren Exercice 4 : Etant donné un tableau contenant les informations de N

} personnes. Chaque personne est représentée par un
enregistrement formé des champs suivants : Nom, Prénom et
La différence sémantique entre les struct et les unions est la suivante : alors Date de naissance. Le champ date de naissance est aussi un
que pour une variable de type structure tous les champs peuvent avoir en enregistrement formé des 3 champs : jour, mois et année.
même temps une valeur, une variable de type union ne peut avoir , à un
instant donné , qu’un seul champs ayant une valeur. Faire les programmes suivants :

Dans l’exemple précédent, l’union z pourra posséder soit une valeur entière, - Editer toutes les personnes nées au mois de Décembre.
soit une valeur réelle, amis pas les deux à la fois. - Editer toutes les personnes par année de naissance.

6.5 Accès aux champs de l’union :

L’accès au champs de données de l’union se fait avec le même opérateur

sélection (noté .) que celui qui sert à accéder aux champs des structures.

Exercices.

Exercice 1 : Faire un programme qui saisit dans un tableau les informations

d'un ensemble d'employés . Chaque employé est défini par : son
matricule, son nom, son prénom, et son salaire .( Utilisez une
structure d'enregistrement) .

Exercice 2 : Faire un programme qui affiche les informations de tous les

employés de l'exercice précédent dont le salaire est supérieur
à un montant donné .

Exercice 3 : Faire un programme qui trie par ordre croissant du salaire les
employés de l'exercice 1 .
 22

7.2 Déclaration des pointeurs :

La déclaration d’une variable pointeur vers un type de base a une structure

très proche de celle de la déclaration d’une variabe ayant un type de base. La
CHAPITRE VII : LES POINTEURS seule différence consiste à faire précéder le nom de la variable du signe *.

Exemples de déclarations :

Ce chapitre a pour objet de présenter les pointeurs en langage C.

float *pi ; // pi est un pointeur vers float
char *pc ; // pc est pointeur vers un caractère.
7.3 Les Pointeurs : int *s ; // s est un pointeur vers un entier

Les pointeurs sont des outils fondamentaux du langage C. Toutefois leur

maîtrise nécessite un minimum d’expérience.
Remarque importante :
Sommairement, un pointeur peut être défini comme une variable qui contient
l’adresse d’une zone mémoire (et non le contenu de cette zone), comme le En utilisant les pointeurs , il est important de faire attention à la notation .
montre le schéma suivant : Ainsi par exemple, si p est un pointeur vers un entier, il faut bien
comprendre que :

P contient l’adresse de l’entier (par exemple 1356888)

*p contient la valeur de l’entier lui-même (par exemple 15).
15

Poiteur P
7.3 L’opérateur adresse de : &
Les programmes C utilisent souvent l’opérateur & (appelé « de » ou « et
commercial »). Cet opérateur appliqué à une variable délivre l’adresse de
1356888
celle-ci, adresse qui pourra donc être affectée à une variable de type
pointeur.

Exemple :

int i ;
int *pi ;
 23

Struct personne
pi=&i ; //pi pointera vers la variable I ;
{
int age ;
float taille, poids ;
Autre exemple : char nom[20] ;
}
int i, j ;
int *pi ; void main()
{
pi=&i ; //initialisation du pointeur pi struct personne pers ; //pers est une variable de type
*pi=2 ; //initialisation de la valeur pointée par pi //struct personne
j=*pi+1 ; // la variable j aura la valeur 3 struct personne *p ; //p est un pointeur vers une
//struct personne

p=&pers ;
}

7.4 Pointeur vers une structure :

Supposons que l’on ait défini la structure personne à l’aide de la déclaration :

Struct personne
{
int age ;
float taille, poids ;
char nom[20] ;
}

On déclarera une variable de type pointeur vers une telle structure de la

manière suivante :

Struct personne *p ;

On pourra alors affecter à p des adresses de struct personne, par

exemple :
 24

7.6 Accès aux éléments d’une structure pointée :

7.5 Structure dont un champs pointe vers une structure du même type :
Supposons que nous ayons déclaré p comme étant de type pointeur vers une
Une des utilisations fréquentes des structures, est de créer des listes de struct personne , comment faire référence à un champ de la structure
structures chaînées (voir figure). Pour cela, il faut que chaque structure pointée par p ?.
contienne un champ qui soit de type pointeur vers une structure
Pour référencer le champ nom de la structure en question, on peut utiliser la
notation suivante :

(*p).nom

Il en va de même pour les autres champs : age, taille et poids, qui seront
représentés respectivement ainsi :

Exemple de liste chainée. (*p).age

(*p).poids
(*p).taille
En reprenant l’exemple de la structure personne, la liste précédente peut
être construite à partir de la déclaration suivante :
Etant donné que cette écriture est assez lourde, le langage C a prévu un
nouvel opérateur noté -> qui permet de référencer facilement les champs
Struct personne d’une structure pointée.
{
int age ; Ainsi au lieu d’écrire (*p).nom , on écrira p->nom. De même que les
float taille, poids ; autres champs pourront être référencés comme suit :
char nom[20] ;

struct personne *suivant ; p->age

} p->poids
p->taille

Le champs de nom suivant est déclaré comme étant du type pointeur vers
une struct personne. 7.7 Détermination de la taille allouée à un type :

Pour connaître la taille en octets de l’espace mémoire nécessaire pour une

variable, on dispose de l’opérateur sizeof.
 25

Cet opérateur peut être utilisé de deux manières différentes : p=malloc(sizeof(struct personne)) ;

sizeof expression
sizeof (nom-de-type)
La fonction calloc admet deux paramètres :

Exemple : 1. Le premier est le nombre d’éléments désirés.

2. Le second est la taille en octets d’un élément.
int i, taille ;
Son but est d’allouer un espace suffisant pour contenir les éléments
taille=sizeof i ;
taille=sizeof (int) ; demandés et de rendre un pointeur vers cet espace.
taille=sizeof(struct personne) ;
Exemple d’utilisation :

la première instruction taille=sizeof i permet de calculer la taille en

octets occupée par la variable mémoire i. Les deux suivantes permettent struct personne *p ;
respectivement de calculer la taille occupée par une variable de type entier int nb_elem ;
et le type structure. nb_elem=10 ;

/* allocation d’un espace de 10 éléments de type struct personne

7.8 Allocation et libération d’espace :
p=calloc(nb_elem, sizeof(struct personne)) ;
Les pointeurs permettent d’allouer et de libérer dynamiquement de l’espace On pourra alors utiliser les éléments p[0], p[1], … p[nb_elem-1].
mémoire. Cela se passe généralement lors de la manipulation des listes
chaînées (dont le nombre d’éléments n’est pas connu à l’avance et peut varier La libération de l’espace alloué par malloc ou calloc se fait au moyen de la
pendant l’exécution). procédure free qui admet un seul paramètre : le pointeur précédemment
rendu par malloc ou calloc.
Pour l’allocation, on dispose de deux fonctions malloc et calloc :
Exemple :
La fonction malloc admet un paramètre qui est la taille en octets de l’élément
struct personne *p ;
désiré, et elle rend un pointeur vers l’espace alloué.
int nb_elem ;

Exemple : nb_elem=10 ;

struct personne *p ; /* allocation d’un espace de 10 éléments de type struct personne

p=calloc(nb_elem, sizeof(struct personne)) ;
 26

Exercice 9.4 : Soit une suite mathématique définie de la manière suivante :

free(p) ;
Un = Un-1 + 2*Un-2
U0 = 1 , U1 = 3

Faire un programme qui étant donné un nombre entier N range

EXERCICES :
tous les éléments générés de cette suite dans une liste
Exercice 1 : Soit une liste chaînée de nombres triée par ordre croissant . linéaire.
Ecrire les programmes suivante :
Faire un autre programme qui consulte la valeur d'un élément
a. Recherche si un nombre donné X existe dans cette liste. quelconque Ui .
b. Insère un nombre X au bon endroit de la liste de manière à
préserver l'ordre . Exercice 9.5 : Pour représenter les polynômes on a pensé à utiliser les
c. Supprime le premier élément rencontré dont la valeur est X. listes. Chaque monôme est ainsi représenté par un élément de
liste à trois champs : le coefficient du monôme , son exposant
Exercice 2 : Refaire l'exercice précédent avec une liste bidirectionnelle et le lien vers le monôme suivant. Exemple :
puis une liste circulaire.
Le polynôme : 4*x3 + 5*x2 + 7*x + 12
Exercice 3 : Soit une liste linéaire d'éléments Employé , dont chacun est
formé des champs suivants : sera représenté ainsi :

. Numéro de l'employé .
. Nom de l'employé . 4 3 5 2 7 1 12 0
. Prénom de l'employé .
. Salaire de l'employé .
Faire un programme qui étant données deux listes représentant
deux polynômes (dont les adresses des premiers éléments sont
Ecrire les programmes suivants :
respectivement Tête1 et Tête2) , construit une nouvelle liste
représentant le polynôme résultat de la somme.
. Insérer un nouvel employé en fin de liste .
. Supprimer un employé de numéro donné .
. Afficher tous les employés dont le salaire est
supérieur à un montant donné .
. Trier la liste par ordre croissant des salaires .
 27

Float Somme (float x, float y)

{
return(x+y)
}

#include
Le programme suivant <stdio.h>
utilise la fonction somme précédente pour faire la
CHAPITRE VIII : LES FONCTIONS
somme de deux nombres a et b introduits par l’utilisateur :
float somme (float x, float y) ;
void main()
{
float a, b ;
Ce chapitre a pour objet de présenter la structuration des fonctions (sous-
programmes) dans les programmes C. printf(‘’Introduisez le premier nombre ‘’) ;
scanf(‘’%f’’, &a) ;
8.1 Structure des fonctions : printf(‘’Introduisez le second nombre ‘’) ;
scanf(‘’%f’’, &b) ;
La structure générale des fonctions en C obéit au schéma suivant :
printf(‘’La somme est %f = ’’, somme(a, b)) ;
<type_fonction> <nom_fonction> (type1 argument1, type2 argument2, }
...,
float Somme (float x, float y)
typen argumentn) {
{ return(x+y)
Corps de la fonction }

le type de la fonction permet de préciser le type du résultat rendu par la Au moment de l’appel de la fonction somme, les paramètres x et y (appelés
fonction. Si la fonction ne renvoit aucun résultat, sa déclaration doit être paramètres formels) sont remplacés respectivement par a et b (appelés
précédée par le mot réservé void. paramètres effectifs).

Exemple : la fonction suivante réalise la somme de deux nombres réels x et y. Notez qu’on doit informer le compilateur du nom de la fonction avant le bloc
(main).
 28

8.2 Portée des variables : d=20;

return(a+b+d);
}
Il existe en réalité deux sortes de variables en C : les variables globales et
les variables locales. int fonc2(void)
{
int e; /* déclaration d’une
Les variables globales sont des variables qui peuvent êtres « vues » et
variable locale */
utilisées par tous les blocs d’instructions (programme principal main et les
toutes les autres fonctions). Leur durée de vie est donc égale à la durée de e=20;
vie du programme principal. return(a+c+e); /* il y a une erreur dans
cette ligne */
Les variables a et} b sont des variables globales. Elles peuvent utilisées dans
Les variables locales, par contre, sont des variables déclarée localement à
le programme principal (main) et tous les autres blocs (exemple : fonc1 &
l’intérieur d’un bloc. Leur durée de vie est égale à la durée de vie du bloc qui
fonc2).
les a crées. A la sortie de ce bloc, ces variables sont détruites.

Cependant, la variable c est une variable locale. Elle n’est vue que dans le bloc
Le programme suivant résume la différence entre les deux types de correspondant au programme principal (main). De ce fait, une erreur sera
variables : signalée à la compilation : lors du passage sur le bloc fonc2, le compilateur
conclura que la variable c n’est pas définie !.
#include <stdio.h>

int a,b ; /* déclaration de variables

globales */
int fonc1(void);
int fonc2(void);

void main()
{
int c; /* déclaration d’une variable
locale */
a=5; b=10; c=15;
printf("%i", a+b+c);
printf("%i", fonc1());
printf("%i", fonc2());
};

int fonc1(void)
{
int d; /* déclaration d’une
variable locale */
 29

EXERCICES :

Exercice 1 : Ecrire une fonction ABS qui calcule la valeur absolue d'un
nombre .

Exercice 2 : Ecrire une procédure Permute qui permute le contenu de deux

variables numériques. Utilisez cette procédure pour faire la
permutation circulaire du contenu de trois variables.

Exercice 3 : Ecrire une fonction qui étant donné un rayon R, calcule la

surface du cercle correspondant .

Exercice 4 : Ecrire une fonction qui calcule la nième puissance d'un nombre
X.

Exercice 5 : Faire une fonction Fact qui calcule la factorielle d'un nombre
entier N . Rappelons que la factorielle d'un nombre notée n! est
: n! = 1*2*3*4*...*(n-1)*n

Exercice 6 : Utiliser la fonction de l'exercice précédent pour faire un

programme qui lit 10 nombres entiers et calcule la somme de
leurs factorielles .
 30

9.2 Ouverture des fichiers : fopen

Lorsqu’on désire accéder à un fichier, il est nécessaire avant tout d’ouvrir le

fichier à l’aide de la fonction fopen dont la syntaxe est :

CHAPITRE IX : LES FICHIERS fopen(<nom_physique>, <mode>)

Le nom physique est une chaîne de caractères représentant le nom réel du

fichier auquel on veut accéder sur un disque, exemple : ‘’resultat.dat’’.
Le présent chapitre fait une introduction à la manipulation des fichiers
comme supports d’entrée/sortie.
Le mode précise le mode d’utilisation du fichier. Il peut être choisi parmi les
trois cas suivants :
9.1 Déclaration des fichiers :

La déclaration d’un fichier se fait au moyen de l’instruction FILE qui est • ‘’r’’ : Ouverture en lecture (read). Dans ce cas le fichier ouvert ne peut
contenue dans le fichier <stdio.h>. être que lu et ne peut être modifié.
• ‘’w’’ : Ouverture en écriture (write). Dans ce cas le fichier est remis à
L’exemple suivant déclare un fichier fp : zéro avant de recevoir de nouvelles données.
• ‘’a’’ : Ouverture en ajout (append). Dans ce cas le contenu du fichier
ouvert est conservé, et les nouvelles données seront rajoutées à
#include <stdio.h> la fin de celles qui existent déjà.

void main()
{ La fonction fopen retourne une valeur de type pointeur vers FILE. Si
FILE *fp ; l’ouverture a réussi, la valeur retournée permet de repérer le fichier, et
…………
………… devra être passée en paramètre à toutes les procédures d’entrées/sorties
} sur le fichier. Si l’ouverture s’est avéré impossible (cas d’un fichier
inexistant qu’on veut lire, par exemple) fopen rend la valeur NULL.

Exemple : Cet exemple tente d’ouvrir le fichier ‘’resultat.dat’’. Si l’ouverture

ne réussit pas, le programme affiche un message d’alerte à l’utilisateur.

#include <stdio.h>
 31

void main() }
{
FILE *fp ; 9.4 Ecriture sur un fichier : fprintf
fp=fopen(‘’resultat.dat’’, ‘’r’’) ;
if (fp==NULL) L’instruction fprintf est analogue à printf à l’execption que fprintf s’applique
printf(‘’Impossible d’ouvrir ce fichier’’) ; pour un fichier sur disque alors que printf s’applique pour la sortie standard
………… (écran). Les formats admissibles sont rigoureusement les mêmes pour les
…………
deux instructions.
} fichiers : fclose
9.3 Ouverture des
L’exemple suivant#include
écrit dans le fichier ‘’nombre’’ les 100 premiers entiers :
<stdio.h>
Après avoir terminé les entrées/sorties sur un fichier, il est fortement
recommandé de le fermer en utilisant la fonction fclose, dont la syntaxe
void main()
est :
{
FILE *fp ;
fclose(<nom_fichier>) int i ;

fp=fopen(‘’nombre’’, ‘’w’’) ;
if (fp==NULL)
Exemple : Cet exemple complète le programme précédent en faisant une printf(‘’Impossible d’ouvrir ce fichier’’) ;
ouverture d’un fichier en lecture, puis en le fermant grâce à l’instruction
fclose. for(i=1 ;i<=100 ; i++)
{ fprintf(fp, ‘’%d’’, i) ;
}

#include <stdio.h> fclose(fp) ;

}
void main()
{
FILE *fp ;
9.5 Lecture à partir d’un fichier : fscanf
fp=fopen(‘’resultat.dat’’, ‘’r’’) ; Comme pour scanf, l’instruction fscanf permet de lire des données
if (fp==NULL)
formatées à partir d’un fichier . Le programme suivant complète le
printf(‘’Impossible d’ouvrir ce fichier’’) ;
programme précédent en ouvrant le fichier ‘’nombre’’ en lecture après
fclose(fp) ; l’écriture des 100 premiers entiers.
 32

• Saisie d’un nouvel étudiant

• Affichage des données du fichier.
• Suppression d’un nouvel étudiant
#include <stdio.h> • Tri du fichier

void main()
Exercice 2 : Ecrire un programme C qui recopie le contenu d’un fichier sur
{
FILE *fp ; un autre.
int i , n;

fp=fopen(‘’nombre’’, ‘’w’’) ;
if (fp==NULL)
printf(‘’Impossible d’ouvrir ce fichier’’) ;

for(i=1 ;i<=100 ; i++)

{ fprintf(fp, ‘’%d’’, i) ;
}

close(fp) ;
fp=fopen(‘’nombre’’, ‘’r’’) ;
while (fscanf(fp, ‘’%d’’, &n) !=EOF)
printf(‘’%d’’, n) ;

fclose(fp) ;
}

EXERCICES :

Exercice 1 : Soit un fichier destiné à contenir les informations des

étudiants. Chaque étudiant est définit par les rubriques
suivantes : matricule, nom et moyenne.

Ecrire un programme C qui appelle les fonctions suivantes :

 33

ANNEXE: PRINCIPALES FONCTIONS ); souhaité.

DE C/C++ dec : nombre de positions
décimales.
Sign : signe du nombre.
Fonction Rôle Fichiers entêtes double exp( double calcule l’exponentielle d’un nombre math.h
nécessaires x ); x
int abs( int n ); Calcule la valeur absolue d’un math.h double fabs( double x calcule la valeur absolue d’un math.h
nombre entier n. ); nombre réel x.
double acos( double x calcule l’arc-cosinus d’un nombre math.h char *_fcvt( double convertit un nombre réel x en une Stdlib.h
); réel x. value, int chaîne de caractères.
double asin( double x calcule l’arc-sinus d’un nombre x. math.h count, int
); *dec, int *sign
);
double atan( double x calcule l’arc-tangente d’un math.h
); nombre x. double floor( calcule le nombre entier supérieur math.h
double x ); ou égal à x.
double atof( convertit une chaine de Math.h double fmod( calcule le reste de la division de math.h
double x, deux nombres x et y.
const char caractère en un nombre réel. et
double y );
*string ); stdlib.h
int atoi( const char convertit une chaine de Math.h double _hypot( double calcule l’hypoténuse d’un triangle Math.h
*string ); caractère en un nombre entier. et x, double y ); droit : racine carré de x2 + y2.
stdlib.h
long atol( const convertit une chaine de Math.h int _inp( unsigned lit un octet (byte) à partir d’un Conio.h
char *string caractère en un entier long. et short port ); port.

); stdlib.h unsigned short

double ceil( double x donne l’entier supérieur ou égal math.h _inpw(
); à x. unsigned short
port );
char *_cgets( char lit à partir du clavier une chaine Conio.h unsigned long
*buffer ); de caractères. _inpd(
unsigned short
double cos( double x calcule le cosinus d’un nombre x math.h
); port );
double cosh( double calcule le cosinus hyperbolique math.h
x ); unsigned short _inpw( lit un mot (word) à partir d’un port. Conio.h
d’un
unsigned short port );
nombre x
unsigned long lit un double-mot à partir d’un port. Conio.h
char *_ecvt( convertit un nombre x en une Stdlib.h
double chaîne de caractères.
value, int Value : valeur à convertir.
count, int count : le nombre de positions
*dec, int *sign
 34

_inpd(
unsigned short
port );

islower (int c) teste si un caractère est miniscule. Ctype.h

Dans l’affirmatif, la fonction
renvoie une valeur non nulle.
isprint (int c) teste si un caractère est Ctype.h
imprimable.
ispunct (int c) teste s’il s’agit d’un caractère de Ctype.h
ponctuation.
isspace (int c) teste s’il s’agit d’un caractère Ctype.h
espace.
isupper (int c) teste s’il s’agit d’un caractère Ctype.h
majuscule.
isxdigit (int c) teste s’il s’agit d’un caractère Ctype.h
hexadécimal.
char *_itoa( int convertit un entier en une chaîne Stdlib.h
value, char de caractères.
*string, int Value : valeur.
radix ); Radix : base d’énumération choisie.

int _kbhit( void ); renvoie une valeur non nulle si une Conio.h
touche du clavier a été pressée, 0
sinon.
double log( double x ); calcule le logarithme d’un nombre x. math.h

double log10( double calcule le logarithme de base 10 math.h

x ); d’un nombre x.
unsigned long fait une rotation à gauche d’un mot Stdlib.h
_lrotl( de bits.
unsigned long Shift : est le nombre de positions
value, int shift de la rotation.
);

unsigned long fait une rotation à droite d’un mot Stdlib.h

_lrotr( de bits.
unsigned long Shift : est le nombre de positions
 35

size_t count );
char *strstr( const recherche si la chaîne string2 est String.h
char *string1, incluse dans string1. Elle renvoie,
const char dans l’affirmatif, l’indice de
*string2 ); string2.
char *_strupr( convertit une chaîne de caractères String.h
char *string ); en majuscules.
double tan( double calcule la tangente d’un nombre x. math.h
x );
double tanh( double calcule la tangente hyperbolique math.h
x ); d’un nombre x.

int tolower( int c ); convertit un caractère en string.h et

minuscule. ctype.h
int toupper( int c ); convertit un caractère en String.h et ctype.h
majuscule.