EMIG/LGL/S3/2023 Langage C

INTRODUCTION AU LANGAGE C

I - Historique
L'histoire du langage C est intimement liée à celle du système d'exploitation UNIX. En
1969, Ken Thompson, qui travaillait pour Bell Laboratories, mit au point un système
d'exploitation denommé d'Unics (Uniplexed Information and Computing System) qui
ne tarda pas à être définitivement changé en UNIX.

A l'époque, le seul langage vraiment adapté à l'écriture de systèmes d'exploitation était

le langage Assembleur. Ken Thompson développa alors un langage de plus haut
niveau (c'est-à-dire plus proche du langage humain), le langage B (dont le nom
provient de BCPL, un sous-ensemble du langage CPL, lui-même dérivé de l'Algol, un
langage qui fut populaire à l'époque), pour faciliter l'écriture d'UNIX. C'était un langage
faiblement typé (un langage non typé, par opposition à un langage typé, est un langage
qui manipule les objets sous leur forme binaire, sans notion de type (caractère, entier,
réel, ...)) et trop dépendant du PDP-7 pour permettre de porter UNIX sur d'autres
machines. Alors Denis Ritchie et Brian Kernighan, de Bell Laboratories également,
améliorèrent le langage B pour donner naissance au langage C. En 1973, UNIX fut
réécrit entièrement en langage C. Pendant 5 ans, le langage C fut limité à l'usage
interne de Bell jusqu'au jour ou Brian Kernighan et Denis Ritchie publièrent une
première définition du langage dans un ouvrage intitulé The C Programming
Language.

Grâce à sa puissance, le langage C devint rapidement très populaire et en 1983, l'ANSI

(American National Standards Institute) décida de le normaliser en ajoutant également
quelques modifications et améliorations, ce qui donna naissance en 1989 au langage
tel que nous le connaissons aujourd'hui. L'année suivante, le langage C a été adopté
par l'ISO (International Organization for Standardization) et par l'IEC (International
Electrotechnical Commission), et a connu au fil du temps certaines révisions (dans
l'immense majorité des cas toujours compatibles avec les versions antérieures) dont
les plus importantes sont celles de 1990 (adoption par l'ISO), de 1995 (amélioration
du support du développement de programmes internationnaux) et de 1999 (ajout d'un
nombre important de nouvelles fonctionnalités).

C'est un langage qui ne dépend d'aucune plateforme matérielle ou logicielle, c'est-à-

dire qui est entièrement portable. De plus, de par sa simplicité, écrire un compilateur
C pour un processeur donné n'est pas beaucoup plus compliqué que d'écrire un
assembleur pour ce même processeur. Ainsi, là où l'on dispose d'un assembleur pour
programmer, on dispose aussi généralement d'un compilateur C, d'où l'on dit
également que le C est un "assembleur portable".

La popularité du langage C est telle que son style et sa syntaxe ont influencé de
nombreux langages :

• C++ et Objective C sont directement descendus du C (on les considère souvent

comme des extensions du C) ;
• C++ a influencé Java ;

Chargé du cours : MIDOU Moussa Page 1 sur 29

EMIG/LGL/S3/2023 Langage C

• Java a influencé JavaScript ;

• PHP est un mélange de C et de langage de shell-scripting sous Linux ;
• C# est principalement un mix de C++ et de Java, deux langages de style C,
avec quelques influences fonctionnelles d'autres langages comme Delphi et
Visual Basic.

II - Les avantages du C :
• La portabilité : Un programme développé en C sur une machine donnée peut
être porté sur d'autres machines sans le modifier.
• Une grande bibliothèque de fonctions: Le C dispose d'un grand nombre de
fonctions, que ce soit des fonctions mathématiques, de gestion de fichiers ou
d'entrées / sorties.
• Proche de la machine: Le C est très proche de la machine en pouvant accéder
aux adresses des variables.

III - Structure générale d'un programme C

La transformation d'un texte écrit en langage C en un programme exécutable par l'ordinateur
se fait en deux étapes. La compilation et l'édition de liens. La compilation est la traduction des
fonctions écrites en C en des procédures équivalentes écrites dans un langage dont la
machine peut exécuter les instructions. Le compilateur lit toujours un fichier, appelé fichier
source, et produit un fichier, dit fichier objet.

Chaque fichier objet est incomplet, insuffisant pour être exécuté, car il contient des appels de
fonctions ou des références à des variables qui ne sont pas définies dans le même fichier. Par
exemple, les programmes que vous écrirez contiennent des fonctions comme printf que vous
n'aurez certainement pas écrite vous-même. L'édition de liens est l'opération par laquelle
plusieurs fichiers objets sont mis ensemble pour se compléter mutuellement : un fichier apporte
des définitions de fonctions et de variables auxquelles un autre fichier fait référence et
réciproquement.
L'éditeur de liens (ou linker ) prend en entrée plusieurs fichiers objets et bibliothèques (une
variété particulière de fichiers objets) et produit un unique fichier exécutable. L'éditeur de liens
est largement indépendant du langage de programmation utilisé pour écrire les fichiers
sources, qui peuvent même avoir été écrits dans des langages différents.

Chaque fichier source entrant dans la composition d'un programme exécutable est fait d'une
succession d'un nombre quelconque d'éléments indépendants, qui sont :

• des directives pour le préprocesseur (lignes commençant par #),

• des constructions de types (struct, typedef),
• des déclarations de variables et de fonctions externes,
• des définitions de variables et des définitions de fonctions.

Chargé du cours : MIDOU Moussa Page 2 sur 29

EMIG/LGL/S3/2023 Langage C

•
En C on n'a pas une structure syntaxique englobant tout, comme la construction « Program
... end. » du langage Pascal ; un programme n'est qu'une collection de fonctions assortie d'un
ensemble de variables globales. D'où la question : par ou l'exécution doit-elle commencer ?
La règle généralement suivie par l'éditeur de liens est la suivante : parmi les fonctions données
il doit en exister une dont le nom est main. C'est par elle que l'exécution commencera ; le
lancement du programme équivaut à l'appel de cette fonction par le système d'exploitation.
Notez bien que, à part cela, main est une fonction comme les autres, sans aucune autre
propriété spécifique ; en particulier, les variables internes à main sont locales, tout comme
celles des autres fonctions.

Chargé du cours : MIDOU Moussa Page 3 sur 29

EMIG/LGL/S3/2023 Langage C

• Règles de bases:
En Langage C, il est souvent nécessaire d'inclure des fichiers dit d'en-tête
(HEADER:*.H) contenant la déclaration de variables, constantes ou de
procédures élémentaires. Le fichier à inclure se trouve en général dans le
répertoire des fichiers d'en-têtes (Include ) alors on écrira:
#Include <Nom_du_fichier.H>.
Si le fichier se trouve dans le répertoire courant, on écrira:
#Include "Nom_du_fichier.H"
• Toutes instructions ou actions se terminent par un point-virgule ;
• Une ligne de commentaires doit commencer par /* et se terminer par */.
• Un bloc d'instructions commence par { et se termine par }.
• Le langage C est sensible à la « casse » : les mots du langage doivent être
écrits en minuscules ; les noms de variables, constantes, fonctions doivent
toujours être écrits de la même façon : Ma_Fonction ≠ ma_fonction ≠
MA_FONCTION.

IV- Les Variables et les Constantes

• Constante : Elle ne change jamais de valeur pendant l'exécution d'un
programme.
• Variable : Elle peut changer de valeur pendant l'exécution d'un programme.
Une variable ou une constante est souvent définie par cinq éléments :
o L'identificateur : C'est le nom que l'on donne à la variable ou à la
constante.
o Le type: Si la variable est un entier ou un caractère ou une chaîne de
caractère ou un réel ou un booléen.
o La taille: C'est le nombre d'octets occupés en mémoire, elle est fonction
du type.
o La valeur: C'est la valeur que l'on attribue à la variable ou à la
constante.
o L'adresse: C'est l’emplacement où est stockée la valeur de la variable
ou de la constante. L’adresse peut encore être appelée pointeur.
4.1 - Définition des types de variables ou de constantes
4.1.1 - Les Constantes
Les constantes n'existent pas, c'est à dire qu'il n'y a pas d'allocation mémoire,
mais on peut affecter à un identificateur (Nom) une valeur constante par
l'instruction #define.
Syntaxe :
<#define> <identificateur> <valeur>;

Chargé du cours : MIDOU Moussa Page 4 sur 29

EMIG/LGL/S3/2023 Langage C

4.1.2 - Les variables.

Les variables sont définies par le type et l'identificateur.
Syntaxe:
<type> <identificateur1>,..,<identificateurn> ;

• Le type : Il détermine la taille de la variable et les opérations pouvant être

effectuées. Le type est fonction de la machine ou du compilateur utilisé.
On peut rajouter le mot unsigned devant le type de la variable, alors la
variable devient non signée et cela permet d'étendre la plage de valeurs.
• L'identificateur : C'est le nom affecté à la variable. Le nombre de
caractères peut être limité, cela dépend du compilateur utilisé.
L’identificateur d’une variable doit toujours être écrit de la même
façon : Mon_Identificateur ≠ mon_identificateur ≠ MON_IDENTIFICATEUR.

Chargé du cours : MIDOU Moussa Page 5 sur 29

EMIG/LGL/S3/2023 Langage C

Remarque: Lors de l'affectation des variables si on met 0 avant la valeur, elle sera en
Octal et si on met 0x devant une valeur elle sera hexadécimale.

Exemple :

4.1.3 - initialisations de variables.

Deux solutions sont possibles :

Chargé du cours : MIDOU Moussa Page 6 sur 29

EMIG/LGL/S3/2023 Langage C

V - Les variables dans les blocs

Il est temps de vous parler des endroits où l'on peut déclarer les variables. Deux
possibilités vous sont offertes:
•
Avant le programme principal, les variables sont dites globales. C'est-à-dire
qu'elles sont accessibles n'importe où dans le programme.
• Dans un bloc, les variables sont dites locales. C'est-à-dire qu'elles n’existent
que dans le bloc où elles ont été déclarées.
Rappel: Un bloc d'instructions commence par { et se finit par }.
Exemples:
#include <stdio.h>
/* Déclaration d'une variable globale */
int i;
main()
{
i=1; /* Initialisation de i */
printf("%d",i); /* Affichage de i */
}
Dans l'exemple ci-dessus la variable i est globale à l'ensemble du logiciel. La
valeur de i est accessible de n'importe où.

#include <stdio.h>
main()
{
/* Déclaration d'une variable locale */
int i;
i=1; /* Initialisation de i */
printf("%d",i); /* Affichage de i */
}
Dans l'exemple ci-dessus la variable i est locale au bloc main. La valeur de i
n’est accessible
que dans le bloc main.
#include <stdio.h>
main()
{
{ /* Début de bloc */
int i; /* Déclaration d'une variable locale i*/
i=1; /* Initialisation de i */
printf("i = %d\n",i); /* Affichage de i */
/* \n provoque un retour à la ligne */
} /* Fin du bloc */
printf("i = %d\n",i); /* Affichage de i */
}
Si vous tapez l'exemple ci-dessus, le compilateur va refuser d'exécuter le

Chargé du cours : MIDOU Moussa Page 7 sur 29

EMIG/LGL/S3/2023 Langage C

programme car la
variable locale i existe seulement dans le bloc où elle a été créée.

VI - Les fonctions d'affichage et de saisie.

VI.1 La fonction d'affichage.
Elle permet d'afficher des messages et/ou des valeurs de variables sous différents
formats.
Syntaxe:
printf(<"Format">,identificateur1, ....,identificateurn);
Le format : Il indique comment vont être affiché les valeurs des variables. Il est
composé de texte et de codes d'affichage suivant le type de variable.

Codes d'affichage:

Remarque : Au début d'un programme utilisant les fonctions d'affichage et de saisie il

est nécessaire d'écrire #include <stdio.h>, car toutes les fonctions sont déclarées
dans ce fichier d'en-tête.

Chargé du cours : MIDOU Moussa Page 8 sur 29

EMIG/LGL/S3/2023 Langage C

Exemple :
#include <stdio.h>
int i; /* Déclaration de variable globale */
main()
{
i=23; /* Initialisation de i */
printf(" i(dec) = %d\n",i); /* Affichage de i en décimal */
printf(" i(octal) =%o\n",i); /* Affichage de i en octal */
printf(" i(hex)= %x\n",i); /* Affichage de i en Hexadécimal */
}
On peut aussi mettre des codes de contrôles :

Exemple :
#include <stdio.h>
main()
{
printf("Salut je suis:\n\t Le roi \n\t\t A bientôt\a");
}
On peut aussi définir le type d'affichage des variables pour les nombres signés ou
flottants en rajoutant des caractères de remplissage.
• Un caractère de remplissage '0' au lieu de ' ' pour les numériques.
• Un caractère de remplissage '-' qui permet de justifier à gauche l'affichage sur la
taille minimale (défaut à droite).
• Un caractère de remplissage '+' qui permet de forcer l'affichage du signe.
• Un nombre qui précise le nombre de caractères qui doit être affiché suivi d'un point
et d'un nombre précisant combien de chiffres après la virgule doivent être affichés.
Syntaxe:
<Nb caractères affichés>.<Nombre de chiffres significatifs>
Exemple:
#include <stdio.h>
float i;

Chargé du cours : MIDOU Moussa Page 9 sur 29

EMIG/LGL/S3/2023 Langage C

main()
{
i=15.6;
/* Affichage de i normal */
printf("%f\n",i);
/* Affichage de i avec 10 caractères */
printf("%10f\n",i);
/* Affichage de i avec 10 caractères
et 2 chiffres après la virgule */
printf("%10.2f\n",i);
/* Affichage de i avec 10 caractères
et 2 chiffres après la virgule
et à gauche */
printf("%-10.2f\n",i);
/* Affichage de i avec 10 caractères
et 2 chiffres après la virgule
et à gauche
avec l'affichage du signe */
printf("%+-10.2f\n",i);
/* Affichage de i avec 10 caractères
et 2 chiffres après la virgule
avec des zéros avant le valeur */
printf("%010.2f\n",i);
}

Il existe d'autres fonctions qui permettent d'afficher des variables.

• Putchar :
Elle permet d'afficher un caractère à l'écran.
Syntaxe:
putchar(identificateur1);
Exemple:
#include <stdio.h>
char car1,car2;
main()
{
car1='A';
car2=0x42;
/* Affichage du caractère 1 -> donne un A */
putchar(car1);
/* Affichage du caractère 2 -> donne un B */
putchar(car2);
/* Affichage du caractère C */
putchar('C');
/* Retour de ligne */

Chargé du cours : MIDOU Moussa Page 10 sur 29

EMIG/LGL/S3/2023 Langage C

putchar('\n');
}

• Puts
Puts: Elle permet d'afficher une chaîne de caractères à l'écran.
Syntaxe:
puts(identificateur de chaîne de caractères);
Exemple:
#include <stdio.h>
#include <string.h>
/* Déclaration et Initialisation de message1 */
char message1[10]="Bonjour";
/* Déclaration de message2 */
char message2[10];
main()
{
/* Initialisation de message2 */
strcpy(message2,"Monsieur");
/* Affichage du message1 */
puts(message1);
/* Affichage du message2 */
puts(message2);
}

VI.2 - La fonction de saisie.

Elle permet de saisir des valeurs de variables formatées à partir du clavier. Comme
printf.
elle est composée d'un format et des identificateurs de variables à saisir. A la
différence de printf, le format ne peut contenir de texte, il est juste composé du
format des valeurs à saisir.
Syntaxe:
scanf(<"Format">,&identificateur1, ...., &identificateurn);
Remarque: Le symbole & est obligatoire devant les identificateurs car scanf attend
des adresses et non des valeurs, sauf devant un identificateur de chaîne de
caractères.
Les codes d'affichage pour printf deviennent les codes d'entrée pour scanf.

Chargé du cours : MIDOU Moussa Page 11 sur 29

EMIG/LGL/S3/2023 Langage C

Pour l'utilisation de scanf il faut inclure le fichier stdio.h au début du programme.

Exemples:
Saisie d'une variable.
#include <stdio.h>
/* Déclaration de constante */
#define PI 3.14159
/* Déclaration de variable rayon et périmètre */
float rayon,perimetre;
main()
{
/* Affichage de "Donne ton Rayon en mètre ?" */
puts("Donne ton Rayon en mètre ?");
/* Saisie du Rayon */
scanf("%f",&rayon);
/* Calcul du perimètre */
perimetre=2*PI*rayon;
/* Deux sauts de ligne */
printf("\n\n");
/* Affichage de périmetre */
printf("Le périmètre = %f",perimetre);
}
Saisie de plusieurs variables.
#include <stdio.h>
/* Déclaration de variables réelles */
float a,b,c,det;
main()
{
/* Affichage de "Donne les valeurs de a,b et c ?" */
puts("Donne les valeurs de a,b et c ?");
/* Saisie de a,b,c */
scanf("%f %f %f",&a,&b,&c);
/* Calcul du déterminant */
det=(b*b)+(4*a*c);

Chargé du cours : MIDOU Moussa Page 12 sur 29

EMIG/LGL/S3/2023 Langage C

/* Deux sauts de ligne */

printf("\n\n");
/* Affichage du déterminant */
printf("Le déterminant = %f",det);
}

Chargé du cours : MIDOU Moussa Page 13 sur 29

EMIG/LGL/S3/2023 Langage C

Exemple

La bibliothèque mathématique
En langage C, il existe ce qu'on appelle des bibliothèques "standard", c'est-à-dire des
bibliothèques toujours utilisables. Ce sont en quelque sorte des bibliothèques "de
base" qu'on utilise très souvent.
La bibliothèque mathématique contient de nombreuses autres fonctions dont vous
aurez très probablement besoin.
Pour pouvoir utiliser les fonctions de la bibliothèque mathématique, il est
indispensable de mettre la directive de
préprocesseur suivante en haut de votre programme :
#include <math.h>

Fabs
Cette fonction retourne la valeur absolue d'un nombre.

ceil
Cette fonction renvoie le premier nombre entier après le nombre décimal qu'on lui
donne.

Chargé du cours : MIDOU Moussa Page 14 sur 29

EMIG/LGL/S3/2023 Langage C

C'est une sorte d'arrondi. On arrondit en fait toujours au nombre entier supérieur.
Par exemple, si on lui donne 26.512, la fonction renvoie 27.

floor
C'est l'inverse de la fonction précédente, cette fois elle renvoie le nombre
directement en dessous.
Si vous lui donnez 37.91, la fonction floor vous renverra donc 37
pow
Cette fonction permet de calculer la puissance d'un nombre. Vous devez lui indiquer
2 valeurs : le nombre, et la
puissance à laquelle vous voulez l'élever. Voici le schéma de la fonction :
pow(nombre, puissance);
Code : C
double resultat = 0, nombre = 2;
resultat = pow(nombre, 3); // resultat vaudra 2^3 = 8

sqrt
Cette fonction calcule la racine carrée d'un nombre. Elle renvoie un double.
Code : C
double resultat = 0, nombre = 100;
resultat = sqrt(nombre); // resultat vaudra 10

sin, cos, tan

Ce sont les 3 fameuses fonctions utilisées en trigonométrie.
Le fonctionnement est le même, ces fonctions renvoient un double.
Ces fonctions attendent une valeur en radians.
asin, acos, atan
Ce sont les fonctions arc sinus, arc cosinus et arc tangente, d'autres fonctions de
trigonométrie.
Elles s'utilisent de la même manière et renvoient un double.
exp
Cette fonction calcule l'exponentielle d'un nombre.

Log
Cette fonction calcule le logarithme népérien d'un nombre (que l'on note aussi "ln")
log10
Cette fonction calcule le logarithme base 10 d'un nombre.

Chargé du cours : MIDOU Moussa Page 15 sur 29

EMIG/LGL/S3/2023 Langage C

Le bloc sinon est optionnel

Chargé du cours : MIDOU Moussa Page 16 sur 29

EMIG/LGL/S3/2023 Langage C

Chargé du cours : MIDOU Moussa Page 17 sur 29

EMIG/LGL/S3/2023 Langage C

Chargé du cours : MIDOU Moussa Page 18 sur 29

EMIG/LGL/S3/2023 Langage C

Chargé du cours : MIDOU Moussa Page 19 sur 29

EMIG/LGL/S3/2023 Langage C

VI - Opérateurs logiques

Vrai ou faux
La valeur Vrai peut être assimilée à la valeur numérique 1. En programmation C, la
valeur Vrai est associée à toute valeur non nulle.
La valeur Faux peut être assimilée à la valeur numérique 0.
L'opérateur Ou (||) correspond alors à une addition :

En lisant la valeur donnée à l'intersection de la ligne et de la colonne, on obtient donc

le résultat de notre opération.
Par exemple :
Ligne 1 / Colonne 1, VRAI ou VRAI donne VRAI, 1+1=2 (soit Vrai)

Chargé du cours : MIDOU Moussa Page 20 sur 29

EMIG/LGL/S3/2023 Langage C

En logique pure, on écrira plus 1+1=1 du fait que toute valeur non nulle est
considérée comme Vrai.
L'opérateur Et (&&) correspond alors à une multiplication :

En lisant la valeur donnée à l'intersection de la ligne et de la colonne, on obtient donc

le résultat de notre opération.
Par exemple :
Ligne 1 / Colonne 1, VRAI et VRAI donne VRAI, 1*1=1 (soit Vrai)
L'opérateur Not (!) permet d'obtenir la négation, ainsi :
!(Vrai) = Faux
!(Faux) = Vrai
Par exemple :
int i1=1;
int i2=0;
printf("i1 || i2 = %d",i1||i2);
/* affichera 1 car : vrai||faux=vrai et vrai vaut 1 */
printf("i1 && i2 = %d",i1&&i2);
/* affichera 0 car : vrai&&faux=faux et faux vaut 0 */
printf("contraire(1)=%d",!(1));
/* affichera 0 car : !(vrai)=faux et faux vaut 0 */

Combinaison
Toutes les opérations logiques peuvent se combiner entre elles. Il faut néanmoins
veiller aux différentes priorités des opérateurs et il faut que la condition dans sa
totalité soit entourée de ().
Les exemples suivants montrent ce qui est possible et ce qui ne l'est pas :

Vous verrez souvent ce type de code écrit :

if (er) {

Chargé du cours : MIDOU Moussa Page 21 sur 29

EMIG/LGL/S3/2023 Langage C

/* Alors faire quelque chose */

}
En appliquant ce qui a été vu précédemment, on en déduit que ce code signifie que
si (er != 0) /* si er différent de 0 */
{
/* Alors faire quelque chose */
}
Ce qui donne en Langage C :
if (er != 0) { /* si er différent de 0 */
/* Alors faire quelque chose */
}

Opérateur modulo
L'opérateur qui donne le reste de la division entière (opérateur modulo) est noté %
en C. Ainsi, 10%2 vaut 0 car la division entière de 10 par 2 donne 5 et il n'y a pas de
reste. En revanche, 10%3 vaut 1 car la division entière de
10 par 3 donne 3 et il reste 1. Par exemple :
int z;
z=10%2;
printf("10 modulo 2=%d\n",z);
z=10%3;
printf("10 modulo 3=%d\n",z); …va nous afficher :
10 modulo 2=0
10 modulo 3=1

Nombres pseudo‐aléatoires
Voici un petit exemple de programme qui permet d'obtenir des nombres pseudo‐
aléatoires entre 0 et 99 :
#include <stdio.h>
#include <stdlib.h> // sert pour les fonctions srand et rand
#include <time.h>
int main() {
int nb_alea=0;
/* Initialisation du générateur de nombres
basée sur la date et l'heure */
srand (time (NULL));
nb_alea = rand() % 100;
printf ("Nombre aléatoire : %d\n",nb_alea);
return 0;
}
• srand (time (NULL)) permet d'initialiser le générateur de nombres pseudo‐aléatoire.
Nous reviendrons sur ce

Chargé du cours : MIDOU Moussa Page 22 sur 29

EMIG/LGL/S3/2023 Langage C

point par la suite.

• rand() renvoie un nombre entier compris entre 0 et RAND_MAX.
• rand()%100 est donc le reste de la division entière d'un nombre pseudo‐aléatoire
(éventuellement très grand)
par 100, c'est-à-dire un nombre compris entre 0 et 99…
#include <stdio.h>
#include <stdlib.h>
int main() {
/* Pour notre information */
printf ("RAND_MAX : %ld\n", RAND_MAX);
return 0;
}

Fonction toupper()
La fonction toupper qui transforme un caractère minuscule en majuscule. Pour
l'utiliser, il faut inclure le fichier d'en‐tête ctype.h par : ‐include <ctype.h>.
La fonction toupper s'utilise de la façon suivante :
#include <stdio.h>
#include <ctype.h>
int main () {
char car;
char car_min;
car_min = 'a';
car = toupper (car_min);
printf ("%c",car);
return 0;
}
Ce programme affichera : A

V - Les chaînes de caractères

Elles sont vues par le C comme un tableau de caractères se terminant par un code
de fin appelé le caractère nul '\0'.
Syntaxe:
<type> <identificateur>[nb de caractères+1];
Exemple:
char message[10];
On a défini un tableau de caractères de 10 éléments. Le message ne pourra contenir
au plus que neuf caractères car le dixième est réservé pour le caractère de fin '\0'.
Initialisation de chaîne:
/* Déclaration d'une chaîne de caractères de 9 éléments */
char message[10];
main()
{
Chargé du cours : MIDOU Moussa Page 23 sur 29
EMIG/LGL/S3/2023 Langage C

message[0]='R';
message[1]='E';
message[2]='N';
message[3]='E';
message[4]='\0'; /* Caractère de fin */
}
ou

/* Déclaration d'une chaîne de caractères de 9 éléments */

char message[10]="RENE";
main()
{
...
}
Remarque :
Il n’est pas possible d'initialiser une chaîne de cette façon.
/* Déclaration d'une chaîne de caractères de 9 éléments */
char message[10];
main()
{
message="RENE"; /* Interdit en C */
}
On ne peut pas initialiser une chaîne de caractères de cette façon car "message" est
considéré comme une adresse par le compilateur. Pour que l'initialisation soit
correcte il faut utiliser une fonction de copie de caractères (strcpy), celle-ci recopie
un à un tous les caractères de "RENE" à partir de "message".
Remarque: strcpy est déclaré dans le fichier string.h.
Exemple:
#include <stdio.h> /* Pour Printf */
#include <string.h> /* Pour Strcpy */
/* Déclaration d'une chaîne de caractères de 9 éléments */
char message[10];
main()
{
/* Initialisation correcte d'une chaîne */
strcpy(message,"RENE");
/* Affichage du message */
printf("%s",message);
}

Chargé du cours : MIDOU Moussa Page 24 sur 29

EMIG/LGL/S3/2023 Langage C

Fonctions de manipulation des chaînes

strlen : calculer la longueur d'une chaîne
strlen est une fonction qui calcule la longueur d'une chaîne de caractères (sans
compter le caractère \0 ).
Vous devez lui envoyer un seul paramètre : votre chaîne de caractères. Cette
fonction vous retourne la longueur de la chaîne.
Exemple
int main()
{
char chaine[ ] = "Salut";
int longueurChaine = 0;
// On récupère la longueur de la chaîne dans longueurChaine
longueurChaine = strlen(chaine);
// On affiche la longueur de la chaîne
printf("La chaine %s fait %d caractères de long", chaine, longueurChaine);
return 0 ;
}

strcpy : copier une chaîne dans une autre

La fonction strcpy (comme "string copy") permet de copier une chaîne à l'intérieur
d'une autre.
Son prototype est :
char* strcpy(char* copieDeLaChaine, const char* chaineACopier);
Cette fonction prend 2 paramètres :
copieDeLaChaine : c'est un pointeur vers un char* (tableau de char). C'est dans ce
tableau que la chaîne sera copiée.
chaineACopier : c'est un pointeur vers un autre tableau de char. Cette chaîne sera
copiée dans copieDeLaChaine.
Exemple ;
int main()
{
/* On crée une chaine "chaine" qui contient un peu de texte
et une copie (vide) de taille 100 pour être sûr d'avoir la place
pour la copie */
char chaine[ ] = "Texte", copie[100] = {0};
strcpy(copie, chaine); // On copie "chaine" dans "copie"
// Si tout s'est bien passé, la copie devrait être identique à chaine
printf("chaine vaut : %s\n", chaine);
printf("copie vaut : %s\n", copie);
return 0;
}

Chargé du cours : MIDOU Moussa Page 25 sur 29

EMIG/LGL/S3/2023 Langage C

strcat : concaténer 2 chaînes

Cette fonction ajoute une chaîne à la suite d'une autre. On appelle cela la
concaténation.
Si j'ai :
chaine1 = "Bonjour "
chaine2 = "Comment ça va ?"
Si je concatène chaine2 dans chaine1, alors chaine1 vaudra " Bonjour Comment ça
va ".
chaine2, elle, n'aura pas changé et vaudra donc toujours " Comment ça va ". Seule
chaine1 est modifiée.
C'est exactement ce que fait strcat, dont voici le prototype :
char* strcat(char* chaine1, const char* chaine2);
Chaine2 ne peut pas être modifiée car elle est définie comme constante dans le
prototype de la fonction.
La fonction retourne un pointeur vers chaine1 ce qui, comme pour strcpy, ne sert pas
à grand-chose dans le cas présent, donc on peut ignorer ce que la fonction nous
renvoie.
La fonction ajoute à chaine1 le contenu de chaine2.
Exemple :
int main()
{
/* On crée 2 chaînes. chaine1 doit être assez grande pour accueillir
le contenu de chaine2 en plus, sinon risque de plantage */
char chaine1[100] = "Bonjour ", chaine2[ ] = " Comment ça va ";
strcat(chaine1, chaine2); // On concatène chaine2 dans chaine1
// Si tout s'est bien passé, chaine1 vaut "Bonjour Comment ça va"
printf("chaine1 vaut : %s\n", chaine1);
// chaine2 n'a pas changé :
printf("chaine2 vaut toujours : %s\n", chaine2);
return 0;
}

strcmp : comparer 2 chaînes

strcmp compare 2 chaînes entre elles.
Voici son prototype :
int strcmp(const char* chaine1, const char* chaine2);
Les variables chaine1 et chaine2 sont comparées. Comme vous le voyez, aucune
d'elles n'est modifiée car elles sont indiquées comme constantes.
Il est important de récupérer ce que la fonction renvoie. En effet, strcmp renvoie :
0 si les chaînes sont identiques, une autre valeur (positive ou négative) si les chaînes
sont différentes.

Chargé du cours : MIDOU Moussa Page 26 sur 29

EMIG/LGL/S3/2023 Langage C

Exemple :
int main()
{
char chaine1[] = "Texte à comparer", chaine2[] = " Texte à comparer ";
if (strcmp(chaine1, chaine2) == 0) // Si strcmp renvoie 0 (chaînes
identiques)
{
printf("Les chaines sont identiques\n");
}
else
{
printf("Les chaines sont differentes\n");
}
return 0;
}

strchr : rechercher un caractère

La fonction strchr recherche un caractère dans une chaîne.
Prototype :
char* strchr(const char* chaine, int caractereARechercher);
La fonction prend 2 paramètres :
chaine : la chaîne dans laquelle la recherche doit être faite.
caractereARechercher : le caractère que l'on doit rechercher dans la chaîne.

Exemple :
int main()
{
char chaine[] = "Texte de recherche", *suiteChaine = NULL;
suiteChaine = strchr(chaine, 'd');
if (suiteChaine != NULL) // Si on a trouvé quelque chose
{
printf("Voici la fin de la chaine à partir du premier d : %s", suiteChaine);
}
return 0;
}

strpbrk : premier caractère de la liste

Cette fonction recherche un des caractères dans la liste que vous lui donnez sous
forme de chaîne, contrairement à strchr qui ne peut rechercher qu'un seul caractère
à la fois.

Chargé du cours : MIDOU Moussa Page 27 sur 29

EMIG/LGL/S3/2023 Langage C

Par exemple, si on forme la chaîne "xds" et qu'on en fait une recherche dans "Texte
de test", la fonction renvoie un pointeur vers le premier de ces caractères qu'elle a
trouvé dedans. En l'occurrence, le premier caractère de "xds" qu'elle trouve dans
"Texte de test" est le x, donc strpbrk renverra un pointeur sur 'x'.
Prototype
char* strpbrk(const char* chaine, const char* lettresARechercher);
Test :
Exemple :
int main()
{
char *suiteChaine;
// On cherche la première occurrence de x, d ou s dans "Texte de test"
suiteChaine = strpbrk("Texte de test", "xds");
if (suiteChaine != NULL)
{
printf("Voici la fin de la chaine a partir du premier des caracteres trouves : %s",
suiteChaine);
}
return 0;
}

strstr : rechercher une chaîne dans une autre

Cette fonction recherche la première occurrence d'une chaîne dans une autre
chaîne.
Son prototype est :
char* strstr(const char* chaine, const char* chaineARechercher);
Le prototype est similaire à strpbrk, mais attention à ne pas confondre : strpbrk
recherche UN des caractères, tandis que strstr recherche toute la chaîne.
Exemple :
int main(int argc, char *argv[])
{
char *suiteChaine;
// On cherche la première occurrence de "test" dans "Texte de test"
suiteChaine = strstr("Texte de test", "test");
if (suiteChaine != NULL)
{
printf("Premiere occurence de test dans Texte de test : %s\n", suiteChaine);
}
return 0;
}

sprintf : écrire dans une chaîne

Cette fonction se trouve dans stdio.h contrairement aux autres fonctions que nous
avons vues jusqu'ici, qui étaient dans string.h.

Chargé du cours : MIDOU Moussa Page 28 sur 29

EMIG/LGL/S3/2023 Langage C

Cette fonction ressemble énormément au printf que vous connaissez mais, au lieu
d'écrire à l'écran, sprintf écrit dans une chaîne ! D'où son nom d'ailleurs, qui
commence par le "s" de "string" (chaîne en anglais).
C'est une fonction très pratique pour mettre en forme une chaîne.
Exemple :
#include <stdio.h>
#include <stdlib.h>
int main()
{
char chaine[100];
int age = 15;
// On écrit "Tu as 15 ans" dans chaine
sprintf(chaine, "Tu as %d ans !", age);
// On affiche chaine pour vérifier qu'elle contient bien cela :
printf("%s", chaine);
return 0;
}

Chargé du cours : MIDOU Moussa Page 29 sur 29