RAPPEL DU LANGAGE C
1. – BREF APERÇU DU LANGAGE C
C est un langage de haut niveau qui a été initialement développé par Dennis M. Ritchie pour développer
le système d'exploitation UNIX chez Bell Labs en 1972
En 1978, Brian Kernighan et Dennis Ritchie ont produit la première description publique du langage C,
maintenant connu comme la norme K&R.
Le système d'exploitation UNIX, le compilateur C et essentiellement tous les programmes d'application
UNIX ont été écrit en C.
C est devenu un langage professionnel largement utilisé pour diverses raisons:
Langage relativement facile à apprendre
Langage structuré
Il produit des programmes efficaces.
Il peut gérer des activités de bas niveau.
Il peut être compilé sur une variété de plates-formes informatiques.
2.- STRUCTURE DU PROGRAMME
Structure du programme C afin que nous puissions le prendre comme référence dans les prochains
chapitres.
Exemple :
Comment afficher en langage C le message : Hello World
Un programme C se compose essentiellement des parties suivantes :
- Commandes de préprocesseur
- Les fonctions
- Variables
- Déclarations et expressions
- Commentaires
Voici le code C simple qui affiche les mots "Hello World":
#include <stdio.h>
int main()
/* my first program in C */
printf("Hello, World! \n");
return 0;
Voyons de prés les différentes parties du programme ci-dessus:
- La première ligne du programme #include <stdio.h> est une commande de préprocesseur, qui
indique au compilateur d’inclure le fichier stdio.h avant de passer à la compilation réelle.
- La ligne suivante int main() est la fonction principale où commence l'exécution du programme.
- La ligne suivante /*...*/ sera ignorée par le compilateur et elle a été ajoutée pour ajouter des
commentaires dans le programme. Ces lignes sont donc appelées commentaires dans le
programme.
- La ligne suivante printf("Hello, World! \n"); est une autre fonction disponible en C qui provoque
l’affichage du message "Hello, World” à l'écran.
- La ligne suivante return 0; termine la fonction principale et renvoie la valeur 0 (pour indiquer
que le programme s’est exécuté avec succès)
a) Identifiant
- Un identifiant C est un nom utilisé pour identifier une variable, une fonction ou tout autre
élément défini par l'utilisateur. Un l'identifiant commence par une lettre A à Z ou a à z ou un
trait de soulignement _ suivi ou non de zéro ou plusieurs lettres, d’un soulignement (_) et de
chiffres de 0 à 9.
- C n'autorise pas les caractères de ponctuation tels que @, $ et% dans les identificateurs. C est
un sensible à la casse (Majuscule ou Miniscule). Ainsi, Manpower et manpower sont deux
identifiants différents dans en C
Voici quelques exemples d'identifiants acceptables:
mohd zara abc move_ name a_123
myname50 _temp j a23b9 retVal
Les variables
On déclare en C une variable en la précédant de son type.
Exemple :
int a ; int b=20;float x ; char c ;
Char : désigne un objet de caractère
Int, short, long : désigne un entier naturel
Float, double : désigne un réel
Les types char : Une particularité du type char en C est qu’il peut être assimilé à un entier. Par exemple,
si c est de type char, l’expression c+1 est valide. Elle désigne le caractère suivant dans le code ASCII.
Le programme suivant affiche le caractère ‘B’
Exemple :
#include<stdio.h>
int main()
char c = 'A' ;
printf(" %c\n",c+1) ;
return 0;
}Remarque : Il est important de noter qu’en C la déclaration d’une variable n’entraîne pas son
initialisation et le compilateur signalera une erreur si le programmeur la référence sans l’avoir
initialisée. L’initialisation d’une variable peut se faire au moment de sa déclaration de la manière
suivante
Exemple :
int i=1 ;
b) Mots clés
La liste suivante montre les mots réservés en C. Ces mots réservés ne peuvent pas être utilisés comme
constantes ou variables ou tout autre nom d'identifiant.
auto double int struct
break else long switch
case enum register typedef
char extern return union
continue for signed void
do if static while
default goto sizeof volatile
const float short unsigned
Instruction break:
peut être employée à l’intérieure de n’importe quelle boucle. Elle permet d’interrompre le
déroulement de la boucle, et passe à la première instruction qui suit la boucle. En cas de boucles
imbriquées, break fait sortir de la boucle la plus interne.
Exemple :
#include<stdio.h>
int main() {
int i;
for (i = 0; i < 5; i++)
printf("i = %d\n",i);
if (i == 3)
break;
printf("valeur de i a la sortie de la boucle = %d\n",i);
return 0 ;
affiche à l’écran
i=0
i=1
Manipulation de chaînes de caractères
Le fichier de déclarations string.h , contient un certain nombre de fonctions opérant sur des chaînes de
Caractères. Exemple de fonctions :
strlen : retourne le nombre de caractères dans une chaine.
strcpy : Cette fonction strcpy(dest,src) permet de copier la chaîne de caractères src dans le tableau de
caractères dest .
Le tableau de caractères de dest doit avoir une taille suffisante pour pouvoir contenir la chaîne
src sinon il se produit un dépassement de capacité.
Exemple :
#include <stdio.h>
#include <string.h>
int main ()
char chaine1[32], chaine2[32];
int n;
printf("Tapez un mot: ");
scanf("%s",chaine1);
strcpy(chaine2, chaine1);
n=strlen(chaine2);
printf("Vous avez tape: %s\n",chaine2);
printf("la chaine2 comporte: %d caracteres\n",n);
return 0;
Le programme C suivant vérifie si le mot tapé comporte le caractère ‘a’ ou non :
printf("Tapez un mot: ");
scanf("%s",un_mot);
for (i=0; i < strlen(un_mot); i++)
{
if (un_mot[i]=='a')
printf("Il y a au moins un 'a' dans ce mot\n");
{flag=1;
break;
if (flag!=1)
printf("Il n'y a pas de 'a' dans ce mot\n");
return 0;
Exercice à faire
Ecrire un code de programme en C qui permet de trouver le nombre de caractères “b” dans une
chaine de caractères donnée. La solution sera donnée au prochain envoie.
Fonctions :
Ci-dessous un exemple de fonction max qui permet de calculer le max entre 2 nombres réels
#include <stdio.h>
// Fonction max
float max(float num1, float num2)
float result; // results est une variable locale
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
// Programme principal
int main ()
/* Déclaration de variables */
float a = 125.43,b = 207.324,ret;
/* Appel de la fonction max*/
ret = max(a, b);
printf( "Le maximum est : %f\n", ret );
return 0;
Rappel :
- Variables locales
Les variables qui sont déclarées à l’intérieur d’une fonction ou d’un bloc sont appelées variables locales.
Ils peuvent être utilisés uniquement par des déclarations qui sont à l’intérieur de cette fonction ou bloc
de code. Les variables locales ne sont pas connues pour les fonctions en dehors de la leur.
- Variables globales
Les variables globales sont définies en dehors d’une fonction, généralement avant la fonction principale
main(). leurs variables conserveront leur valeur tout au long de la durée de vie de votre programme et
elles peuvent être consultées à l’intérieur de l’une des fonctions définies pour le programme.
Une variable globale peut être accessible par n’importe quelle fonction. Autrement dit, une variable
globale est disponible pour une utilisation tout au long de votre programme après sa déclaration.
Exemple 1:
#include<stdio.h>
int main()
int a = 100;
/*
une variable déclarée dans ce bloc est
complètement différente de la variable
déclaré à l'extérieur.
*/
int a = 10;
printf("Valeur de a interne = %d\n", a);
printf("Valeur de a externe = %d\n", a);
return 0;
Exemple 2 :
#include<stdio.h>
// variables globales
float a=12.45,b=67.90;
int main()
{ //accolade ouvrante
int a=45,b=60;
printf("Valeur de a à l'interieur des accolades ({}=%d\n",a);
printf("Valeur de b à l'interieur des accolades ({}=%d\n",b);
} //accolade fermante
printf("Valeur de a à l'exterieur des accolades ({}=%f\n",a);
printf("Valeur de b à l'exterieur des accolades ({}=%f\n",b);
return 0;
Les Tableaux
Le langage de programmation C fournit une structure de données appelée tableau, qui peut
stocker une taille fixe de collection séquentielle d'éléments du même type. Un tableau est utilisé
pour stocker une collection de données, mais il est souvent plus utile de considérer un tableau
comme une collection de variables du même type. Au lieu de déclarer des variables
individuelles, telles que number0, number1, ... et number99, vous déclarer une variable de
tableau telle que des nombres et utiliser des nombres [0], des nombres [1] et ..., des nombres
[99] pour représenter des variables individuelles. Un élément spécifique d'un tableau est
accessible par un index.
Tous les tableaux sont constitués d'emplacements de mémoire contigus. L'adresse la plus
basse correspond à la première et l'adresse la plus élevée du dernier élément.
Déclaration de tableaux
Pour déclarer un tableau en C, un programmeur spécifie le type des éléments et le nombre de
éléments requis par un tableau comme suit:
type arrayName [arraySize];
C'est ce qu'on appelle un tableau unidimensionnel. ArraySize doit être une constante entière
supérieure à zéro et type peuvent être n'importe quel type de données C valide.
Par exemple, pour déclarer un tableau à 10 éléments appelé solde de type double, utilisez cette
déclaration:
double balance [10];
Maintenant, balance est un tableau variable qui est suffisant pour contenir jusqu'à 10 nombres
doubles.
Initialisation des tableaux
Vous pouvez initialiser un tableau en C soit un par un, soit en utilisant une seule instruction
comme suit:
double balance [5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
Le nombre de valeurs entre accolades {} ne peut pas être supérieur au nombre d'éléments que
nous déclarer pour le tableau entre crochets [].
Voici un exemple pour attribuer un seul élément du tableau :
balance [4] = 50.0;
L'instruction ci-dessus attribue à l'élément numéro 5e du tableau une valeur de 50,0.
Si vous omettez la taille du tableau, un tableau juste assez grand pour contenir l'initialisation est
créé. Par conséquent, si vous écrivez :
double balance [] = {1000.0, 2.0, 3.4, 7.0, 50.0};
Vous allez créer exactement le même tableau que vous l'avez fait dans l'exemple précédent.
Tous les tableaux ont 0 comme index de leur premier élément qui est également appelé indice
de base. Voici la représentation imagée du même tableau que nous avons discuté au-dessus :
Accès aux éléments du tableau :
Un élément est accessible en indexant le nom du tableau. Cela se fait en plaçant l’index du
élément entre crochets après le nom du tableau. Par exemple:
double salaire = balance[9];
L'instruction ci-dessus prendra le 10e élément du tableau et l’affectera la valeur à la variable
salaire.
Voici un exemple qui utilisera tous les trois concepts mentionnés ci-dessus, à savoir.
déclaration, affectation et accès aux tableaux:
Taille d’un tableau : Afin de calculer le nombre d’éléments dans un tableau (sa taille), on utilise
l(expression suivante :
Sizeof(T)/sizeof(T[0])
Où T est le nom du tableau. L’instruction sizeof donne la taille en octets d’un élément du
tableau
#include <stdio.h>
int main ()
{
int T[ 10 ]; /* T est un tableau à 10 éléments */
int i,j,n;
/* Initialisation des éléments du tableau*/
for ( i = 0; i < 10; i++ )
{
T[ i ] = i + 100;
}
n=sizeof(T)/sizeof(T[0]);
/* Résultat */
for (j = 0; j < 10; j++ )
{
printf("Element[%d] = %d\n", j, T[j] );
}
printf("\nn=%d",n);
return 0;
}
Exercice à faire:
Soit la liste suivantes : L=(12,56,13,7,9,124,3). Ecrire un code de programme en C qui permet
de trouver le max et min de L. La solution sera donnée au prochain envoie.
Initialisation d'un tableau à l'aide d'une boucle
Un tableau peut également être initialisé à l'aide d'une boucle. La boucle itère de 0 à (taille - 1)
pour accéder à tous les indices du tableau à partir de 0. La syntaxe suivante utilise une «
boucle for » pour initialiser les éléments du tableau. C'est la manière la plus courante d'initialiser
un tableau en C.
Exemple :
# include<stdio.h>
int main()
{
// déclare un tableau.
int arr[5] ;
// initialise le tableau en utilisant une boucle "for".
int i ;
for (i = 0; i < 5; i++)
{
arr[i] = 2 * i ;
}
// arr = {0, 2, 4, 6, 8}
printf("arr[3]=%d",arr[3]);
return 0;}
Déclaration de tableau 2-D en C
Syntaxe pour déclarer un tableau à 2 dimensions en C :
// déclaration d'un tableau 2-d
dataType arrayName[no_of_rows][no_of_columns] ;
Description de la syntaxe :
dataType : il s'agit du type de données qui spécifie le type d'éléments à stocker dans le tableau.
Cela peut être int, float, double, char.
arrayName : il s'agit du nom du tableau. Pour spécifier le nom d'un tableau, vous devez suivre
les mêmes règles qui s'appliquent lors de la déclaration d'une variable habituelle en C.
no_of_rows : il s'agit de la première dimension du tableau. C'est un entier spécifiant le nombre
de lignes que doit contenir le tableau.
no_of_columns : il s'agit de la deuxième dimension du tableau. C'est une valeur entière
représentant le nombre de colonnes du tableau.
Exemples:
// Matrice 5 x 10.
int my_array1[5][10] ;
// Matrice carrée 3 x 3.
float my_array2[3][3] ;
// Matrice 2 x 1.
char my_array3[2][1] ;
Remarque : Le nombre total d'éléments que le tableau peut contenir est (no_of_rows *
no_of_columns). Par exemple, un tableau arr[2][4] peut avoir au plus 8 éléments.
Initialisation d'un tableau 2-D en C
Dans les tableaux 1-D, lorsqu'un tableau est initialisé au moment de sa déclaration, vous
pouvez ignorer la spécification de sa taille. Cependant, ce scénario est différent avec les
tableaux 2D. Seule la première dimension peut être ignorée et la deuxième dimension est
obligatoire au moment de l'initialisation
Exemple :
Int arr[3][2] = {
{11, 12},
{21, 22},
{31, 32}
};
Dans l'exemple ci-dessus, 3 tableaux 1-D (3 = nombre de lignes) sont là avec 2 éléments
chacun (2 = nombre de colonnes).
La méthode compacte : dans cette méthode, tous les éléments du tableau sont écrits sur la
même ligne, séparés par des virgules. Cela ressemble à une initialisation de tableau 1-D. Cette
méthode n'est pas recommandée car le tableau initialisé a moins de lisibilité.
Exemple
int arr[3][2] = {11, 12, 21, 22, 31, 32} ;
Dans l'exemple ci-dessus, tous les éléments du tableau sont écrits à l'intérieur d'une seule paire
d'accolades "{}". Ce type d'initialisation est moins lisible.
Utilisation d'une boucle : comme les tableaux 1-D, les tableaux 2-D peuvent également être
initialisés à l'aide d'une boucle. La boucle la plus couramment utilisée est la « boucle for ».
Deux boucles imbriquées sont nécessaires pour initialiser le tableau.
Exemple
# include<stdio.h>
int main() {
int arr[2][3];
int i, j;
// The first loop runs till the number of rows.
for(i = 0; i < 2; i++)
{
// second loop runs till number of columns.
for (j = 0; j < 3; j++)
{
arr[i][j] = i+j;
}
}
/* my_array = {
{0, 1, 2},
{1, 2, 3}
} */
printf("arr[0][2]=%d",arr[0][2]);
return 0 ;
}Dans l'exemple ci-dessus, deux "boucles for" sont utilisées pour initialiser un tableau 2-D. La
première boucle va de 0 au nombre de lignes. Et la deuxième boucle va de 0 au nombre de
colonnes.
Les Chaines de caractères :
La chaîne dans le langage de programmation C est en fait un tableau unidimensionnel
de caractères qui est terminé par un caractère nul «\ 0».
Ainsi, une chaîne terminée par un caractère nul contient les caractères comprend la
chaîne suivie d'un nul. La déclaration et l'initialisation suivantes créent une chaîne
composée du mot "Bonjour". Avec le caractère nul à la fin du tableau, la taille du
tableau de caractères contenant la chaîne est un de plus que le nombre de caractères
du mot "bonjour".
char bonjour [6] = {'H', 'e', 'l', 'l', 'o', '\ 0'};
Si vous suivez la règle d'initialisation du tableau, vous pouvez écrire l'instruction ci-
dessus comme suit:
char bonjour[] = "Hello";
Voici la présentation en mémoire de la chaîne définie ci-dessus en C / C ++:
En fait, vous ne placez pas le caractère nul à la fin d'une constante de chaîne. Le
compilateur C place automatiquement le '\ 0' à la fin de la chaîne lors de l'initialisation
du tableau.
Exemple :
#include <stdio.h>
int main ()
{
char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
printf("Message d'accueil %s\n", greeting );
return 0;
}
Remarques :
C prend comprend un large éventail de fonctions qui manipulent des chaînes terminées
par null:
Fonction et but
1. strcpy s1, s2; Copie la chaîne s2 dans la chaîne s1.
2. strncpy(s1, s2,n) : Compare les les n premiers caractères de s1 et s2
3. strcats 1, s2; Concatène (ajout) la chaîne s2 à la fin de la chaîne s1.
4. strlen s1; Renvoie la longueur de la chaîne s1.
5. strcmp s1, s2; Renvoie 0 si s1 et s2 sont identiques; moins de 0 si s1 <s2; supérieur
à 0 si s1> s2.
Exemple 1 :
// Ce code compare 2 chaines
#include <stdio.h>
#include <string.h>
int main()
{
char s1[20] = "Polytechnic";
char s2[20] = "Polytechnique";
if (strcmp(s1, s2) ==0)
{
printf("string 1 and string 2 semblables\n");
}else
{
printf("string 1 and 2 sont differents\n");
}
return 0;
}
Exemple 2 :
// Ce code compare les n premiers caractères des chaines s1 et s2
#include <stdio.h>
#include <string.h>
int main()
{
char s1[20] = "Polytechnic";
char s2[20] = "Polytechnique";
int n=10;
if (strncmp(s1, s2, n) ==0)
printf("Les chaines s1 et s2 sont egaux au %d premiers caracteres pres\n",n);
else
printf("Les chaines s1 et s2 sont differentes au %d premiers caracteres pres\
n",n);
return 0;
}
Exemple 3:
/ Ce code permet de concatener (ajouter) 2 chaines s1 et s2 pour former une
seule chaine
#include <stdio.h>
#include <string.h>
int main()
{
char s1[10] = "Hello";
char s2[10] = " World";
strcat(s1,s2);
printf("Resultat apres concatenation: %s\n", s1);
return 0;
}
Exercices à faire :
1. Ecrire un code en langage C qui permet de remplacer tous les lettres ‘a’ d’un mot
donné par la lettre ‘w’
2. Ecrire un code en C qui permet d’inverser les caractères d’un mot.
3. Ecrire un code en C qui permet de trouver le Max d’une fonction donnée dans un
intervalle [a,b] donné.
La notion de Structure en langage C (struct)
En programmation C, une structure est une collection de variables (pouvant être de
différents types) sous un seul nom.
Comment créer une variable structure ?
Avant de pouvoir créer des variables de structure, vous devez définir son type de
données. Pour définir une structure, le mot-clé struct est utilisé.
Syntaxe de struct :
structstructureName {
dataType member1;
dataType member2;
...
};
Exemple
structEtudiant {
char name[50];
intWilaya;
intage;
float moyenne ;
};
Création des variables struct
Lorsqu’un type de struct est déclaré, aucun stockage ou mémoire n’est alloué. Pour
allouer de la mémoire d’un type de structure donné et travailler avec elle, nous devons
créer des variables.
Voici comment nous créons des variables de structure :
structEtudiant {
// code
};
intmain(){
structEtudiantEtudiant1, Etudiant2,
Etud[20];
return0;
}
Il y’a aussi une autre façon de créer une variable struct :
structEtudiant {
// code
} Etudiant1, Etudiant2, Etud[20];
Dans les deux cas,
- Etudian1 et Etudiant2 sont des variables struct Etudiant
- Etud[] est un tableau struct Etudiant de taille 20.
Exemple de Structure :
#include <stdio.h>
#include <string.h>
// create struct with etudiant1 variable
struct Etudent {
char name[50];
int wilaya;
float note;
} etudiant1;
int main() {
// assign value to name of etudiant1
strcpy([Link], "ALI Ahmed");
// assign values to other etudiant1 variables
[Link] = 31;
etudiant1. note = 12;
// print struct variables
printf(" Name: %s\n", [Link]);
printf(" Wilaya.: %d\n", [Link]);
printf(" note: %.2f", [Link]);
return 0;
}
Traitement des Fichiers en C (File handling)
La gestion des fichiers est le stockage de données dans un fichier à l’aide d’un
programme. Dans le langage de programmation C, les programmes stockent les
résultats et d’autres données du programme dans un fichier à l’aide de la gestion
de fichiers en C. En outre, nous pouvons extraire / récupérer des données d’un
fichier.
Les opérations que vous pouvez effectuer sur un fichier en C sont :
Création d’un nouveau fichier
Ouverture d’un fichier existant
Lecture de données à partir d’un fichier existant
Écriture de données dans un fichier
Déplacement des données vers un emplacement spécifique dans le fichier
Fermeture du fichier
1. Création ou ouverture d’un fichier à l’aide defopen()
La fonction fopen() permet de créer un nouveau fichier ou d’ouvrir un fichier existant en
C. La fonction fopen est définie dans le fichier librarystdio.h.
Syntaxe pour la création d’un nouveau fichier ou l’ouverture d’un fichier :
file = fopen(“file_name”, “mode”)
C’est une syntaxe pour ouvrir et créer un fichier en C.
File_name : c’est une chaîne qui spécifie le nom du fichier à ouvrir ou à créer à l’aide
de la méthode fopen.
mode : est une chaîne (généralement un seul caractère) qui spécifie le mode dans
lequel le fichier doit être ouvert. Il existe différents modes disponibles pour ouvrir un
fichier en C
N.B. :La fonction fopen crée un nouveau fichier lorsqu’elle ne trouve aucun fichier du
nom spécifié à l’emplacement spécifié. Sinon, si le fichier est trouvé, il sera ouvert avec
le mode spécifié.
Exemple :
Supposons que nous ouvrions un fichier nommé [Link] à l’aide de la fonction fopen.
file = fopen(“[Link]”, “w”)
Cette déclaration cherche un fichier nommé [Link] dans le répertoire actuel. Si le
fichier existe, il ouvre le fichier sinon il créera un nouveau fichier nommé « [Link] » et
l’ouvrira avec le mode écriture (spécifié en utilisant « w » ou Write).
Voyons tous les types de modes disponibles pour lire ou écrire un fichier en C.
Mode = « r » - ouvert pour la lecture, ce mode ouvrira le fichier à des fins de lecture
uniquement, c’est-à-dire que le contenu peut seulement être visualisé. On ne peut
apporter des modifications au fichier.
N.B. :Ce mode ne peut pas créer un nouveau fichier et open() renvoie NULL, si nous
essayons de créer un nouveau fichier en utilisant ce mode.
Exemple
#include<stdio.h>
int main(){
FILE * file;
if(file = fopen("[Link]","r")){
printf("File opened successfully in read mode");
}
else
printf("The file is not present! cannot create a new file using
r mode");
fclose(file);
return0;
}
Résultat :
- Si le fichier « [Link] » existe dans notre répertoire actuel, alors le programme
affiche :
- File opened successfully in read mode
- Mais si nous essayons d’accéder à un autre fichier, nous obtiendrons
The file is not present! cannot create a new file using r mode
Mode = « w » ouvert pour l’écriture uniquement, ce mode ouvre le fichier s’il est présent
dans le répertoire actuel pour l’écriture uniquement, c’est-à-dire que l’opération de
lecture ne peut pas être effectuée. Si le fichier n’est pas présent dans le répertoire
actuel, le programme créera un nouveau fichier et l’ouvrira pour écriture.
N.B. :Si nous ouvrons un fichier contenant du texte, le contenu sera écrasé.
Exemple
#include<stdio.h>
int main(){
FILE * file;
if(file = fopen("[Link]","w")){
printf("File opened successfully in write mode or a new file
is created");
}
else
printf("Error!");
fclose(file);
return0;
}
Résultat
File opened successfully in write mode or a new file is created
Vous pouvez voir ici, nous avons essayé d’ouvrir le fichier « [Link] » qui n’est pas
présent dans le répertoire, toujours la fonction a renvoyé le message de réussite car
elle a créé un fichier nommé « [Link] ».
