Programmation en C

Faculté des sciences et techniques

MPI

Présenté par : Sidi Mohamed Hmade

 Contexte scientifique
❖ Définition 1.1 : informatique
L’informatique est la science du traitement automatique de l’information.

❖ Définition 1.2 : matériel

Le matériel informatique est un ensemble de dispositifs physiques utilisés
pour traiter automatiquement des informations.

❖ Définition 1.3 : logiciel

Le logiciel est un ensemble structuré d’instructions décrivant un traitement
d’informations à faire réaliser par un matériel informatique.

sidimed.ahmed3@[Link] 2
 Algorithme
❖ Vient du mathématicien et astronome Muhammad ibn al-Khawarizmi, le
père de l'algèbre, qui formalisa au IXe siècle la notion d'algorithme
❖ Qu’est-ce qu’un Algorithme ?
Un algorithme est une suite ordonnée d’instructions permettant de résoudre
un problème (ou de répondre à un besoin).
❖ Qu’est ce que veut dire « écrire un algorithme »
❖ Analyser et comprendre le problème : étude des données fournies et
des résultats attendus.
❖ Résoudre le problème : Trouver les structures de données adaptées
ainsi que l’enchaînement des actions à réaliser pour passer des
données aux résultats.
❖ Définition : Algorithmique
L’algorithmique est la science des algorithmes.

sidimed.ahmed3@[Link] 3
 Exécuté un algorithme
❖ Comment exécuter un algorithme sur un ordinateur ?
Il faut traduire cet algorithme à l’aide d’un langage de programmation
connu par l’ordinateur.

❖ Langage de programmation
Ensemble de règle de vocabulaire et de grammaire compréhensible par un
ordinateur.

❖ La programmation
Écriture d’un programme dans un langage de programmation donnée.

sidimed.ahmed3@[Link] 4
 Exécuté un algorithme

Enoncé d’un problème

Analyse, compréhension

Résolution Pseudo code

Algorithme
Langage de
Codification programmation
(code)
Programme

Compilation

Exécution par l’ordinateur

sidimed.ahmed3@[Link] 5
 La programmation en C
❖ Le C a été conçu en 1972 par Dennis Richie et Ken Thompson

❖ Le C devenant de plus en plus populaire dans les années 80

❖ Le C est un langage compilé (par opposition aux langages interprétés)

❖ Cela signifie qu’un programme C est décrit par un fichier texte, appelé
fichier source.

❖ Ce fichier n’étant évidemment pas exécutable par le microprocesseur, il

faut le traduire en langage machine.

❖ Cette opération est effectuée par un programme appelé compilateur.

sidimed.ahmed3@[Link] 6
 Premier programme
❖ Le programme suivant permettant d’afficher (bonjour les étudiants de MPI)

#include <stdio.h>
void main()
{
printf("Bonjour les etudiants de MPI!\n");
}

❖ Notre fonction s'appelle donc main, C'est un nom de fonction particulier

qui signifie "principal".

❖ main est la fonction principale de votre programme, c'est toujours par la

fonction main que le programme commence.

❖ Une fonction a un début et une fin, délimités par des accolades { }.

sidimed.ahmed3@[Link] 7
 Premier programme
#include <stdio.h>
void main()
{
printf("Bonjour les etudiants de MPI!\n");
}

❖ Ce programme utilise la bibliothèque standard en C, <stdio.h>, pour

utiliser la fonction printf qui permet d'afficher du texte à la console.

❖ La fonction main est la fonction principale qui est exécutée lorsque le

programme démarre. Elle affiche "Bonjour les etudiants de MPI!" à
l'écran et renvoie ensuite 0 pour indiquer que le programme s'est terminé
correctement.

❖ Le '\n' à la fin de la chaîne de caractères est un caractère de nouvelle ligne,

ce qui permet de sauter une ligne après l'affichage du message.

sidimed.ahmed3@[Link] 8
 Les composants élémentaires du C
❖ Un programme en langage C est constitué des six groupes de composants
élémentaires suivants :
✓ les identificateurs
✓ les mots-clefs
✓ les constantes
✓ les chaînes de caractères
✓ les operateurs
✓ les signes de ponctuation.
✓ On peut ajouter à ces six groupes les commentaires, qui sont
enlevés par le processeur

sidimed.ahmed3@[Link] 9
 Les identificateurs
❖ Le rôle d’un identificateur est de donner un nom à une entité du
programme.

❖ Plus précisément un identificateur peut designer :

✓ Un nom de variable ou de fonction
✓ Un type défini par typedef

❖ Un identificateur est une suite de caractères parmi :

✓ Les lettres (minuscules ou majuscules, mais non accentuées)
✓ Les chiffres.
✓ Le blanc souligné (_).
❖ Le premier caractère d’un identificateur ne peut pas être un chiffre

sidimed.ahmed3@[Link] 1
0
 Les mots clefs
❖ Un certain nombre de mots, appelés mots-clefs, sont réservés pour le
langage lui-même et ne peuvent pas être utilisés comme identificateurs.
❖ Le C compte 32 mots clefs que l’on peut ranger en catégories
✓ les spécificateurs de stockage :
• auto, register, static, extern, typedef.
✓ les spécificateurs de type :
• Char, double, enum, float, int, long, short, signed, struct
union, unsigned, void.
✓ les qualificateurs de type :
• Const, volatile.
✓ les instructions de contrôle :
• Break, case, continue, default, do, else, for, goto, if,
switch, while.
✓ Divers : return, sizeof.
sidimed.ahmed3@[Link] 11
 Les commentaires en C
❖ Commentaires sur une seule ligne : les commentaires sur une seule ligne
commencent par '//' et s'étendent jusqu'à la fin de la ligne.

❖ Exemple :

#include <stdio.h>
int main() {
// Afficher le message "Hello, World!" à l'écran
printf("Hello, World!\n");

// Retourner 0 pour indiquer que le programme s'est exécuté avec succès

return 0;
}

sidimed.ahmed3@[Link] 12
 Les commentaires en C
❖ Commentaires sur plusieurs lignes : Les commentaires sur plusieurs lignes
sont inclus entre /* et */ et peuvent s'étendre sur plusieurs lignes.
❖ Par exemple :
/* Ceci est un commentaire */
❖ On ne peut pas imbriquer des commentaires. Quand on met en
commentaire un morceau de programme.
#include <stdio.h>
int main() {
// Afficher le message "Hello, World!" à l'écran
printf("Hello, World!\n");

/* Retourner 0 pour indiquer

que le programme s'est exécuté avec succès*/
return 0;
}

sidimed.ahmed3@[Link] 13
 Les types prédéfinis
❖ Le C est un langage typé. Cela signifie en particulier que toute variable,
constante ou fonction est d’un type précis.
❖ Le type d’un objet définit la façon dont il est représenté en mémoire.
❖ La mémoire de l’ordinateur se décompose en une suite continue d’octets.
❖ Les types de base en C concernent les caractères, les entiers et les flottants
(nombres réels) :
✓ Les type caractères : Le mot-clef char désigne un objet de type caractère
✓ Les types entiers : short, int, long
✓ Les types flottants : float, double

sidimed.ahmed3@[Link] 14
 Les types prédéfinis
❖ les différentes précisions possibles :

Type Taille désignation

char 8 bits caractère
Short 16 bits Entier court
int 32 bits Entier
long 64 bits Entier long
float 32 bits flottant
double 64 bits flottant double précision

sidimed.ahmed3@[Link] 15
 L’affectation
❖ En C, l’affectation est un opérateur. Elle est symbolisée par le signe =
✓ Sa syntaxe est la suivante : variable = expression
✓ Exemple
void main()
{
int i, j = 2;
float x = 2.5;
i = j + x;
x = x + i;
printf("\n %f \n",x);
}

sidimed.ahmed3@[Link] 16
 Les operateurs
❖ Les opérateurs arithmétiques :
✓ + addition
✓ - soustraction
✓ * multiplication
✓ ^ puissance
✓ / division
✓ % reste de la division (modulo)
int main() {
int a = 17;
int b = 5;
// Calcul du reste de la division de a par b
int resultat = a % b;
return 0;
}
sidimed.ahmed3@[Link] 17
 Les operateurs
❖ Les opérateurs relationnels :
✓ > strictement supérieur
✓ >= supérieur ou égal
✓ < strictement inférieur
✓ <= inférieur ou égal
✓ == égal
✓ != différent
❖ Leur syntaxe est : expression-1 op expression-2
✓ Les deux expressions sont évaluées puis comparées.
✓ La valeur rendue est de type int (il n’y a pas de type booléen en C)
✓ Elle vaut 1 si la condition est vraie, et 0 sinon.
✓ Attention à ne pas confondre l’opérateur de test d’égalité == avec
l’opérateur d’affection =
sidimed.ahmed3@[Link] 18
 Les operateurs
❖ Les opérateurs logiques booléens :
✓ && et logique
✓ || ou logique
✓! négation logique
❖ Comme pour les opérateurs de comparaison, la valeur retournée par ces
opérateurs est un int qui vaut 1 si la condition est vraie et 0 sinon.
❖ Dans une expression de type :
expression-1 op-1 expression-2 op-2 ...expression-n
l’évaluation se fait de gauche à droite et s’ arrête de que le résultat final
est déterminé.

sidimed.ahmed3@[Link] 19
 Les operateurs
❖ Les opérateurs d’affectation composée sont :
+= -= *= /= %= &= ^=
✓ Pour tout opérateur op, l’expression
expression-1 op= expression-2 est équivalente à
expression-1 = expression-1 op expression-2
✓ Toutefois, avec l’affection composée, expression-1 n’est évaluée
qu’une seule fois
#include <stdio.h>
int main() {
int a = 5;
// Utilisation de l'opérateur +=
a += 3;
return 0;
}
sidimed.ahmed3@[Link] 20
 Les operateurs
❖ Les opérateurs d’incrémentation ++ et de décrémentation -- : s’utilisent
aussi bien en suffixe (i++) qu’en préfixe (++i).
✓ Dans les deux cas la variable i sera incrémentée
✓ toutefois dans la notation suffixe la valeur retournée sera l’ancienne
valeur de i alors que dans la notation préfixe se sera la nouvelle.
✓ Par exemple :
#include <stdio.h>
int main() {
int a = 3, b, c;
b = ++a; /* a et b valent 4 */
c = b++; /* c vaut 4 et b vaut 5 */
return 0;
}

sidimed.ahmed3@[Link] 21
 Les fonctions d’entrées-sorties
❖ Il s’agit des fonctions de la librairie standard stdio.h utilisées avec les
unités classiques d’entrées-sorties, qui sont respectivement le clavier et
l’écran.

✓ La fonction d’écriture printf

✓ La fonction de saisie scanf

sidimed.ahmed3@[Link] 22
 La fonction d’écriture printf
❖ La fonction printf est une fonction d’impression formatée, ce qui signifie
que les données sont converties selon le format particulier choisi.
❖ Sa syntaxe est
printf("chaine de contrôle ",expression-1, ..., expression-n);
#include <stdio.h>
int main() {
// Utilisation de printf pour afficher du texte
printf("Hello, World!\n");

// Utilisation de printf avec des variables

int num = 42;
printf("La valeur de num est : %d\n", num);

// Utilisation de printf avec des formats spécifiques

double pi = 3.14159;
printf("La valeur de pi est : %.2f\n", pi);
return 0;
}

sidimed.ahmed3@[Link] 23
 La fonction d’écriture printf
❖ La chaîne de contrôle contient le texte à afficher et les spécifications de
format correspondant à chaque expression de la liste.
❖ Les spécifications de format ont pour but d’annoncer le format des données
à visualiser.
❖ Elles sont introduites par le caractère %, suivi d’un caractère désignant le
format d’impression.
❖ En plus du caractère donnant le type des données, on peut éventuellement
préciser certains paramètres du format d’impression, qui sont spécifiés
entre le % et le caractère de conversion
// Utilisation de printf avec des formats spécifiques
double pi = 3.14159;
printf("La valeur de pi est : %.2f\n", pi);

sidimed.ahmed3@[Link] 24
 La fonction d’écriture printf
❖ Les formats d’impression en C :
✓ %d int
✓ %f double
✓ %c char
✓ %s char* chaîne de caractères
❖ Exemple :
#include<stdio.h>
void main(){
int a =5;
float b =5/3.;
char A = 'c';
char* ch = "Bonjour";
printf("%f \n %d \n %c \n %s", b,a, A, ch);
}

sidimed.ahmed3@[Link] 25
 La fonction d’écriture printf
❖ précision :
✓ %.12f signifie qu’un flottant sera imprimé avec 12 chiffres après la virgule.
✓ %10.2f signifie que l’on réserve 12 caractères (incluant le caractère .) pour
imprimer le flottant et que 2 d’entre eux sont destines aux chiffres après la
virgule.
✓ Lorsque la précision n’est pas spécifiée, elle correspond par défaut à 6 chiffres
après la virgule.
#include <stdio.h>
int main() {
double nombre = 123.45678;
// Affichage du nombre avec le format %10.2f
printf("Le nombre formaté est : %10.2f\n", nombre);
return 0;
}

sidimed.ahmed3@[Link] 26
 La fonction de saisie scanf
❖ La fonction scanf permet de saisir des données au clavier et de les stocker
aux adresses spécifiées par les arguments de la fonctions.
scanf("chaîne de contrôle", argument-1,...,argument-n)
❖ La chaîne de contrôle indique le format dans lequel les données lues sont
converties. Elle ne contient pas d’autres caractères (notamment pas de \n).
Comme pour printf, les conversions de format sont spécifiées par un
caractère précédé du signe %.
❖ Exemple :
#include<stdio.h>
void main(){
int i;
printf("entrez un entier i = ");
scanf("%d", &i);
printf("i = %d\n", i);
}

sidimed.ahmed3@[Link] 27
Les instructions de branchement conditionnel
❖ On appelle instruction de contrôle toute instruction qui permet de contrôler
le fonctionnement d’un programme.

❖ Parmi les instructions de contrôle, on distingue les instructions de

branchement et les boucles.

❖ Les instructions de branchement permettent de déterminer quelles

instructions seront exécutées et dans quel ordre.

sidimed.ahmed3@[Link] 28
 Branchement conditionnel if---else
❖ La forme la plus générale est celle-ci :
if ( expression-1 )
instruction-1
else if ( expression-2 )
instruction-2
...
else if ( expression-n )
instruction-n
else
instruction-∞

Avec un nombre quelconque de else if ( ... ). Le dernier else est toujours

facultatif.
❖ La forme la plus simple est :
if ( expression )
instruction
❖ Chaque instruction peut être un bloc d’instructions.
sidimed.ahmed3@[Link] 29
 Branchement conditionnel if---else
❖ Exemple :

int time = 22;

if (time < 10) {
printf("Good morning.");
} else if (time < 20) {
printf("Good day.");
} else {
printf("Good evening.");
}

sidimed.ahmed3@[Link] 30
 Branchement multiple switch
❖ Sa forme la plus générale est celle-ci :
switch ( expression )
{
case constante-1:
liste d’instructions 1
break;
case constante-2:
liste d’instructions 2
break;
...
case constante-n:
liste d’instructions n
break;
default:
liste d’instructions ∞
break;
}
sidimed.ahmed3@[Link] 31
 Branchement multiple switch
❖ Si la valeur de expression est égale à l’une des constantes, la liste
d’instructions correspondant est exécutée.
❖ Sinon la liste d’instructions ∞ correspondant a default est exécutée.
L’instruction default est facultative.

sidimed.ahmed3@[Link] 32
 Branchement multiple switch
❖ Exemple :
int day = 4;

switch (day) {
case 6:
printf("Today is Saturday");
break;
case 7:
printf("Today is Sunday");
break;
default:
printf("Looking forward to the Weekend");
}

sidimed.ahmed3@[Link] 33
 Les boucles
❖ Les boucles permettent de répéter une série d’instructions tant qu’une
certaine condition n’est pas vérifiée.
❖ En langage C, il existe plusieurs types de boucles qui permettent d'exécuter
un bloc de code plusieurs fois.
❖ Les trois principaux types de boucles sont la boucle for, la boucle while et la
boucle do-while.

sidimed.ahmed3@[Link] 34
 Boucle while
❖ Boucle while :
✓ La syntaxe de while est la suivante :
while ( expression ) {
instruction
}
✓ Tant que expression est vérifiée , instruction est exécutée.
✓ Si expression est nulle au départ, instruction ne sera jamais exécutée.
✓ instruction peut évidemment être une instruction composée.

sidimed.ahmed3@[Link] 35
 Boucle while
❖ Exemple :

#include <stdio.h>

int main() {
int i = 1;

// Boucle while qui affiche les nombres de 1 à 5

while (i <= 5) {
printf("%d ", i);
i++;
}

return 0;
}

sidimed.ahmed3@[Link] 36
 Boucle do while
❖ Il peut arriver que l’on ne veuille effectuer le test de continuation qu’aprés
avoir exécuté l’instruction.
❖ Dans ce cas, on utilise la boucle do---while
❖ Sa syntaxe est
do
instruction
while ( expression );
✓ Cela signifie donc que instruction est toujours exécutée au moins une
fois.

sidimed.ahmed3@[Link] 37
 Boucle do while
❖ Exemple : saisir au clavier un entier entre 1 et 10 :

#include <stdio.h>

int main() {
int a;

do{
printf("\n Entrez un entier entre 1 et 10 : ");
scanf("%d",&a);
} while ((a <= 0) || (a > 10));

return 0;
}

sidimed.ahmed3@[Link] 38
 Boucle for
❖ La syntaxe de for est :
for ( expr 1 ; expr 2 ; expr 3)
instruction
❖ Une version équivalente plus intuitive est :
expr 1;
while ( expr 2 )
{ instruction
expr 3;
}
❖ Par exemple, pour imprimer tous les entiers de 0 à 9, on écrit :
for (int i = 0; i < 10; i++) {
printf("\n i = %d",i);
}
sidimed.ahmed3@[Link] 39
 Boucle for
❖ Exemple : imprimer tous les entiers de 0 à 9

#include <stdio.h>

int main() {
int i;

for (i = 0; i < 10; i++)

printf("\n i = %d" , i);

return 0;
}

sidimed.ahmed3@[Link] 40
 Branchement non conditionnel break

❖ On a vu le rôle de l’instruction break; au sein d’une instruction de

branchement multiple switch.

❖ L’instruction break peut, plus généralement, être employée à l’intérieur 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.

sidimed.ahmed3@[Link] 41
 Branchement non conditionnel break
❖ Exemple, le programme suivant :

#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;
}

sidimed.ahmed3@[Link] 42
 Branchement non conditionnel break
❖ Le programme imprime à l’ecran
i=0
i=1
i=2
i=3
valeur de i a la sortie de la boucle = 3

sidimed.ahmed3@[Link] 43
 Branchement non conditionnel continue
❖ L'instruction continue ignore l'itération actuelle de la boucle et continue à
l'itération suivante.
❖ le programme

#include <stdio.h>

int main() {
int i;
for (i = 0; i < 5; i++) {
if (i == 3)
continue;
printf("i = %d\n",i);
}
return 0;
}

sidimed.ahmed3@[Link] 44
 Branchement non conditionnel continue
❖ Le programme imprime à l’ecran
i=0
i=1
i=2
i=4
valeur de i a la sortie de la boucle = 5

sidimed.ahmed3@[Link] 45
 Les tableaux

❖ Un tableau est un ensemble fini d’èlements de même type, stockés en

mémoire à des adresses contigües.

❖ La déclaration d’un tableau à une dimension se fait de la façon suivante :

type nom-du-tableau[nombre-elements];
✓ ou nombre-elements est une expression constante entière positive.
✓ Exemple : int tab[10];
• indique que tab est un tableau de 10 éléments de type int.
• Cette déclaration alloue donc en mémoire pour l’objet tab un
espace de 10 × 4 octets consécutifs.

sidimed.ahmed3@[Link] 46
 Les tableaux
❖ Déclaration de tableau :
#include <stdio.h>

int main() {
// Déclaration d'un tableau d'entiers de taille 5
int tableau[5];

// Déclaration et initialisation d'un tableau de flottants

float tableauFlottant[] = {1.2, 3.4, 5.6, 7.8, 9.0};

// Déclaration et initialisation d'un tableau de caractères

char tableauCaractere[] = {'H', 'e', 'l', 'l', 'o'};

return 0;
}

sidimed.ahmed3@[Link] 47
 Les tableaux
❖ Pour plus de clarté, il est recommandé de donner un nom à la constante
nombre-elements par une directive au préprocesseur, par exemple
• #define nombre-elements 10
❖ On accède à un élément du tableau en lui appliquant l’opérateur [].
❖ Les éléments d’un tableau sont toujours numérotés de 0 à nombre-elements -1

#include <stdio.h>
int main() {
int tableau[5] = {10, 20, 30, 40, 50};

// Accès aux éléments du tableau

printf("Premier élément : %d\n", tableau[0]); // Affiche 10
printf("Deuxième élément : %d\n", tableau[1]); // Affiche 20
return 0;
}
sidimed.ahmed3@[Link] 48
 Les tableaux

❖ On peut initialiser un tableau lors de sa d´déclaration par une liste de constantes de

la façon suivante :

• type nom-du-tableau[N] = {constante-1,constante-2,...,constante-N};

• int tab[4] = {1, 2, 3, 4};

• Si le nombre de données dans la liste d’initialisation est inférieur à la

dimension du tableau, seuls les premiers éléments seront initialisés. Les

autres éléments seront mis à zéro.

sidimed.ahmed3@[Link] 49
 Les tableaux

❖ Exemple :

✓ Ecrire un programme C permettant :

• d’initialiser un tableau T de 10 entiers

• d’ afficher le contenu du tableau T.

sidimed.ahmed3@[Link] 50
 Les tableaux
#include<stdio.h>
#define N 10

void main(){

int tab[N];
int a;

for (int i = 0; i < N; i++){

printf("Saisir l'element d'indice %d \n", i);
scanf("%d", &a);
tab[i]= a;
}

for (int i = 0; i < N; i++)

printf("tab[%d] = %d\n",i,tab[i]);

sidimed.ahmed3@[Link] 51
 Les tableaux
❖ Un tableau correspond en fait à un pointeur vers le premier élément du
tableau.
❖ Notamment, un tableau ne peut pas figurer à gauche d’un opérateur
d’affectation.
❖ Par exemple, on ne peut pas écrire:
• tab1 = tab2;
❖ Il faut effectuer l’affectation pour chacun des ´éléments du tableau :

sidimed.ahmed3@[Link] 52
 Les tableaux
❖ Exemple :

✓ Ecrire un programme C permettant :

• De définir le tableau tab1 = {1, 2, 3, 4,5}

• d’ affecter le contenu du tableau tab1 dans un tableau tab2.

sidimed.ahmed3@[Link] 53
 Les tableaux
#include<stdio.h>
#define N 5

void main(){

int tab1[N] = {1, 2, 3, 4,5};

int tab2[N];

for(int i=0;i<N;i++)
tab2[i] = tab1[i];

for(int i = 0; i < N; i++)

printf("tab2[%d] = %d\n",i,tab2[i]);

sidimed.ahmed3@[Link] 54
 Les tableaux
Exercice :
Ecrire un programme C qui calcule le nombre d’occurrences de la valeur val dans un
tableau Tab de N entiers (de taille 20).

sidimed.ahmed3@[Link] 55
 Les tableaux
#include<stdio.h>
#define N 20
void main(){
int tab[N];
int val;
int nboc=0;
for(int i =0; i<N; i++){
printf("Saisir l'element d'indice %d : ", i);
scanf("%d", &tab[i]);
}
for(int i =0; i<N; i++){
printf("l'element d'indicee %d = %d \n",i, tab[i]);
}
printf("Saisir une valeur ");
scanf("%d", &val);

for(int i =0; i<N; i++){

if(tab[i]==val){nboc++;}
}
printf("le nombre d'occurence de %d = %d \n",val, nboc);
}

sidimed.ahmed3@[Link] 56
 Les tableaux à deux dimensions

❖ On peut déclarer un tableau à plusieurs dimensions. Par exemple, pour un tableau à

deux dimensions (une matrice) :
• type nom-du-tableau[nombre-lignes][nombre-colonnes]

❖ En fait, un tableau à deux dimensions est un tableau unidimensionnel dont chaque

élément est lui-même un tableau. On accède à un élément du tableau par
l’expression tableau[i][j].

❖ Pour initialiser un tableau à plusieurs dimensions on utilise une liste dont chaque
élément est une liste de constantes.

sidimed.ahmed3@[Link] 57
 Les tableaux à deux dimensions
❖ Déclaration de tableau à deux dimensions :

#include <stdio.h>

int main() {
// Déclaration d'un tableau à deux dimensions (3x4) d'entiers
int tableau2D[3][4];

// Déclaration et initialisation d'un tableau à deux dimensions

int tableau2DInit[2][3] = { {1, 2, 3}, {4, 5, 6} };

return 0;
}

sidimed.ahmed3@[Link] 58
 Les tableaux à deux dimensions
❖ Accès aux éléments d'un tableau à deux dimensions :

#include <stdio.h>

int main() {
int tableau2D[2][3] = {{1, 2, 3}, {4, 5, 6} };

// Accès aux éléments du tableau à deux dimensions

printf("%d\n", tableau2D[0][0]); // Premier élément : 1
printf("%d\n", tableau2D[1][2]); // Dernier élément de la deuxième ligne : 6

return 0;
}

sidimed.ahmed3@[Link] 59
 Les tableaux à deux dimensions
❖ Boucle pour parcourir un tableau à deux dimensions :
#include <stdio.h>
int main() {
int tableau2D[2][3] = {
{1, 2, 3},
{4, 5, 6}
};

// Parcours et affichage des éléments du tableau à deux dimensions

for (int i = 0; i < 2; i++) {
for (int j = 0; j < 3; j++) {
printf("%d ", tableau2D[i][j]);
}
printf("\n"); // Saut de ligne après chaque ligne
}
return 0;
}

sidimed.ahmed3@[Link] 60
 Les tableaux à deux dimensions
❖ Les accolades imbriquées sont facultatives. L’initialisation suivante est équivalente
à l’exemple précédent :
• int tab[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};
❖ Une matrice carrée d’entiers M(N*N) est un tableau à deux dimensions de Taille de
N*N
❖ Exemple : Ecrire un programme C permettant de
• Initialiser une matrice carrée de 16 entiers.
• Afficher le contenu du tableau
• Calculer et afficher le produit des éléments en diagonal

sidimed.ahmed3@[Link] 61
 Les tableaux de caractères
❖ De la même manière un tableau de caractères peut être initialisé par une liste de
caractères
• Exemple :
#define N 8
char tab[N] = "exemple";

❖ Notons que le compilateur complète toute chaîne de caractères avec un caractère

nul, Il faut donc que le tableau ait au moins un élément de plus que le nombre de
caractères de la chaîne

sidimed.ahmed3@[Link] 62
 Les tableaux de caractères

#include<stdio.h>
#define N 8

void main(){

char tab[N] = "exemple";

for(int i = 0; i < N; i++)

printf("tab[%d] = %c\n",i,tab[i]);

sidimed.ahmed3@[Link] 63
 Strings

❖ Le C n’a pas de type string, on utilise donc des tableaux de char.

❖ Un caractère spécial, le caractère "null", marque la fin du string (à ne pas

confondre avec le pointeur NULL ).

❖ Ce caractère est noté '\0', de code ASCII 0.

❖ Ce caractère est soit ajouté automatiquement par le compilateur, soit à

introduire par le programmeur.

sidimed.ahmed3@[Link] 64
 Strings

#include<stdio.h>

void main(){

char nom [5] = {'A', 'l', 'i', '\0'};

char prenom[8] ="Mohamed";

for(int i=0;i<=sizeof(prenom)-1; i++){

printf("prenom[%d] = %c\n",i,prenom[i]);
}

sidimed.ahmed3@[Link] 65
 Les fonctions des chaines de caractère

❖ void *strcat (char *chaine1, char *chaine2) // Concaténer les 2 chaines

❖ void *strcpy (char *chaine1, char *chaine2) // Copy la chaine2 dans chaine1

❖ void *strncpy (char *chaine1, char *chaine2, NCmax) // cpy limitée à

NCmax caractère.

❖ int strcmp (char *chaine1, char *chaine2) // compare les chaines de

caractères : renvoie 0 si le deux chaine sont identique.

❖ Int strlen(char *chaine) //renvoie la longueur de la chaine

sidimed.ahmed3@[Link] 66
 La taille

#include <stdio.h>
#include <string.h>

int main() {

char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

printf("%d", strlen(alphabet));

return 0;
}

sidimed.ahmed3@[Link] 67
 strcat()

#include <stdio.h>
#include <string.h>

int main() {

char str1[20] = "Hello ";

char str2[] = "World!";

strcat(str1, str2);
printf("%s", str1);

return 0;
}

sidimed.ahmed3@[Link] 68
 strcpy()

#include <stdio.h>
#include <string.h>

int main() {

char str1[20] = "Hello World!";

char str2[20];

strcpy(str2, str1);
printf("%s", str2);

return 0;
}

sidimed.ahmed3@[Link] 69
 strcmp()

#include <stdio.h>
#include <string.h>

int main() {

char str1[] = "Hello";

char str2[] = "Hello";
char str3[] = "Hi";

printf("%d\n", strcmp(str1, str2));

printf("%d\n", strcmp(str1, str3));

return 0;
}

sidimed.ahmed3@[Link] 70
 Les fonctions
❖ Comme dans la plupart des langages, on peut en C découper un programme
en plusieurs fonctions.
❖ Une seule de ces fonctions existe obligatoirement : c’est la fonction
principale appelée main.
❖ Cette fonction principale peut, éventuellement, appeler une ou plusieurs
fonctions secondaires.
❖ De même, chaque fonction secondaire peut appeler d’autres fonctions
secondaires ou s’appeler elle-même (dans ce dernier cas, on dit que la
fonction est récursive).

sidimed.ahmed3@[Link] 71
 Définition d’une fonction
❖ La définition d’une fonction est la donnée du texte de son algorithme, qu’on
appelle corps de la fonction.

❖ Elle est de la forme :

type nom-fonction ( type-1 arg-1,..., type-n arg-n) {
déclarations de variables locales
liste d’instructions
}

sidimed.ahmed3@[Link] 72
 Définition d’une fonction
❖ La première ligne de cette définition est l’ entête de la fonction. Dans cet
entête, type désigne le type de la fonction, c’est-`a-dire le type de la valeur
qu’elle retourne.
❖ Contrairement à d’autres langages, il n’y a pas en C de notion de procédure
ou de sous-programme.
❖ Une fonction qui ne renvoie pas de valeur est une fonction dont le type est
spécifié par le mot clef void.
❖ Une fonction possède un et un seul point d'entrée, mais éventuellement
plusieurs points de sortie (à l'aide du mot return).
❖ L'imbrication de fonctions n'est pas autorisée.

sidimed.ahmed3@[Link] 73
 Déclaration et appel d’une fonction
// Function definition
void myFunction() {
printf("I just got executed!");
}

// The main method

int main() {
myFunction(); // call the function
return 0;
}

sidimed.ahmed3@[Link] 74
 Exemples
❖ La fonction Produit permettant de calculer le produit de deux entiers a et b

int produit (int a, int b) {

return(a*b);
}

sidimed.ahmed3@[Link] 75
 Exemples

❖ Ecrire une fonction qui permet de permuter deux entiers.

❖ Ecrire une fonction qui permet de remplir un tableau.

❖ Ecrire une fonction qui permet d’afficher un tableau.

sidimed.ahmed3@[Link] 76
 Les prototypes
❖ Il y a trois notions :
• Déclaration
• définition
• Prototype
❖ La déclaration d'une fonction, c'est annoncer que tel identificateur
correspond à une fonction, qui renvoie tel type.
❖ La définition d'une fonction est une déclaration où, en plus, on donne le
code de la fonction elle-même.
❖ Le prototype est une déclaration de fonction où le type des arguments est
également donné.

sidimed.ahmed3@[Link] 77
 Les prototypes

❖ Par exemple :
• int f(); /* declaration de f(), renvoyant un int, pas de prototype */

• int f(void);/* declaration de f(), renvoyant un int, prototype (0 arg) */

• int f(void) {return 42;}

/* definition de f() avec declaration avec prototype */

sidimed.ahmed3@[Link] 78
 Les prototypes

❖ Exemple :on va écrire une fonction qui renvoie 1 si un nombre entier passé
en paramètre est impair, 0 sinon :
• Donnez son prototype
• Ecrire le code de la fonction
• Écrire également son programme de test (main).

sidimed.ahmed3@[Link] 79
 Passage des paramètres par valeur

❖ Quand une fonction est appelée, ses paramètres sont copiés (passage par
valeurs).
❖ La fonction travaille donc sur des copies des paramètres et ne peut donc les
modifier.
❖ En C, le passage des paramètres par référence se fait en utilisant des
pointeurs.
❖ La fonction scanf() travaille avec pointeur, c’est pourquoi du &.

sidimed.ahmed3@[Link] 80
 Passage des paramètres par valeur
❖ La fonction changer :
void changer(int n){
n*=2;
printf("La fonction changer n = %d\n",n);
}

❖ La fonction main :
void main(){
int n = 10;
changer(n);
printf("la fonction main n = %d\n",n);
}

sidimed.ahmed3@[Link] 81
 Les Pointeurs en C

❖ Un pointeur est une variable particulière, dont la valeur est l'adresse d'une
autre variable.

❖ Un pointeur est une adresse mémoire. On dit que le pointeur p pointe vers i,
puisque p pointe vers l’emplacement mémoire où i est enregistrée.

❖ En accédant à cette adresse, on peut accéder indirectement à la variable et

donc la modifier.

sidimed.ahmed3@[Link] 82
 Les Pointeurs en C

❖ Les pointeurs sont nécessaires pour :

✓ Effectuer les appels par référence (i.e. écrire des fonctions qui

modifient certains de leurs paramètres)

✓ Manipuler des structures de données dynamiques (liste, pile,

arbre,…)

✓ Allouer dynamiquement de la place mémoire

sidimed.ahmed3@[Link] 83
 Déclaration de Pointeurs
❖ Le symbole * est utilisé entre le type et le nom du pointeur

• Déclaration d’un entier : int i;

• Déclaration d’un pointeur vers un entier : int *p;

❖ Exemple :
void main(){
int i = 8;
printf("VOICI i: %d\n",i);
printf("VOICI SON ADRESSE EN HEXADECIMAL: %p\n",&i);
}

sidimed.ahmed3@[Link] 84
Manipuler les pointeurs : & (adresse de) et *(contenu)

❖ nom_de_Pointeur = &nom_de_variable

❖ Exemple :
void main(){

char c = 'a', d = 'z';

char *p;

p = &c;
printf("%c\n", *p);

p = &d;
printf("%c\n", *p);

sidimed.ahmed3@[Link] 85
 Manipuler les pointeurs : * et ++

❖ *p++ signifie :
• *p++ trouver la valeur pointée
• *p++ passer à l’adresse suivante
❖ (*p)++ signifie :
• (*p)++ trouver la valeur pointée
• (*p)++ incrémenter cette valeur (sans changer le pointeur)
❖ *++p signifie:
• *++p incrémenter d’abord le pointeur
• *++p trouver la valeur pointée

sidimed.ahmed3@[Link] 86
 Exemple
❖ Donnez le résultat d’exécution :
void main(){
int *p, x, y;
p = &x; /* p pointe sur x */
x = 10; /* x vaut 10 */
y = *p - 1;

printf(" y= *p - 1 =? = %d\n" , y);

*p += 1;
printf(" *p += 1 =? *p = x= ? = %d %d\n" , *p, x);
(*p)++;
printf(" (*p)++ =? *p = x= ? = %d %d alors y=%d \n" , *p, x, y);
*p=0;
printf(" *p=0 x=? = %d\n" , x);
*p++;
*p=20;
printf(" *p++ x=? = %d\n" , x);
}

sidimed.ahmed3@[Link] 87
Passage des paramètres par valeur et par adresse
❖ a et b: variables locales à main(). La fonction changer ne peut donc pas
modifier leur valeur. On le fait donc en passant par l'adresse de ces
variables.
❖ PASSAGE DES PARAMETRES PAR VALEUR :
void changer(int x, int y){
int tampon;
tampon = x;
x = y;
y = tampon;
}

void main(){
int a = 5 , b = 8;
changer(a,b);
printf(" a=%d\n ", a);
printf(" b=%d\n ", b);
}

sidimed.ahmed3@[Link] 88
Passage des paramètres par valeur et par adresse
❖ PASSAGE DES PARAMETRES PAR ADRESSE :
void changer(int *x,int *y){
int tampon;
tampon = *x;
*x = *y;
*y = tampon;
}

void main(){
int a = 5 , b = 8 ;
changer(&a,&b);
printf(" a=%d\n ", a) ;
printf(" b=%d\n ", b) ;
}

sidimed.ahmed3@[Link] 89
Passage des paramètres par valeur et par adresse

❖ Quand on veut modifier la valeur d'un paramètre dans une fonction, il faut
passer ce paramètre par référence ou adresse
❖ En C, cela se fait par pointeur :
void changer ( int *a, int *b){
int tmp;
tmp = *a;
*a = *b;
*b = tmp;
}

sidimed.ahmed3@[Link] 90
 Identification des tableaux et pointeurs
❖ En C, le nom d’un tableau représente l’adresse de sa composante 0.
❖ C'est pour cela que les tableaux passés comme paramètres dans une fonction
sont modifiables.
❖ Passer des tableaux aux fonctions
• Pour le compilateur, un tableau comme argument de fonction, c’est
un pointeur vers sa composante 0 (à la réservation mémoire près).
• La fonction peut donc modifier n’importe quel élément (passage par
référence)
• Le paramètre peut soit être déclaré comme tableau, soit comme
pointeur (int ajouter(int a[], int size) ou int ajouter(int *p, int size))

sidimed.ahmed3@[Link] 91
 Identification des tableaux et pointeurs

❖ A[0] est équivalent à *A

❖ A[i] est équivalent à *(A + i)
❖ &A[0] est équivalent à A
❖ Exemple :

short a[8] = { 10, 20, 30, 40, 50, 60, 70, 80 };

short *p = a;
printf("%d\n", a[3]);
printf("%d\n", *(a + 3));
printf("%d\n", *(p + 3));
printf("%d\n", p[3]);

sidimed.ahmed3@[Link] 92
 Structures en C

❖ Une structure est une collection de plusieurs variables (champs) groupées

ensemble pour un traitement commode.

❖ Les variables d’une structure sont appelées membres et peuvent être de

n’importe quel type, par exemple des tableaux, des pointeurs ou d’autres
structures

❖ Exemple :
struct Membre{
char nom[80];
char adresse[200];
int *numero;
float amende[10];
};

sidimed.ahmed3@[Link] 93
 Structures en C

❖ Les étapes sont :

✓ Déclarer le type de la structure

✓ Utiliser ce type pour créer autant d’instances que désirées

✓ Accéder les membres des instances

sidimed.ahmed3@[Link] 94
 Déclarer les structures

❖ Les structures sont définies en utilisant le mot-clé struct

struct Membre {
char nom[80];
struct Date {
char adresse[200];
int jour;
int numero;
int mois;
float amende[10];
int an;
struct Date emprunt;
};
struct Date creation;
};

sidimed.ahmed3@[Link] 95
 Déclarer les structures

❖ Une fois la structure définie, les instances peuvent être déclarées

❖ On appellera structure une instance de structure

struct Date {
int jour;
int mois;
int an;
};
struct Date paques;
struct Date nouvel_an = { 1, 1, 2001 };

sidimed.ahmed3@[Link] 96
 Des structures dans des structures

struct Date {
int jour;
int mois;
int an;
};

struct Membre { struct Membre m = {

char nom[80]; "Med Ali",
char adresse[200]; "rue de Kuds, 9, 7000 Nass",
int numero; 42,
float amende[10]; { 0.0 },
struct Date emprunt; { 0, 0, 0 },
struct Date creation; { 5, 2, 2001 }
}; };

sidimed.ahmed3@[Link] 97
 Accéder aux membres d’une structure

❖ Les membres sont accédés par le nom de l’instance suivi de . suivi du nom
du membre

struct Membre m;
printf("nom = %s\n", [Link]);
printf("numéro de membre = %d\n", [Link]);
printf("amendes: ");
for(int i = 0; (i < 10) && ([Link][i] > 0.0); i++)
printf("%.2f Euros", [Link][i]);
printf("\nDate d’emprunt %d/%d/%d\n",
[Link], [Link], [Link]);

sidimed.ahmed3@[Link] 98
 Assignation des structures

❖ L’opération d’affectation = peut se faire avec des structures

❖ Tous les membres de la structure sont copiés (aussi les tableaux et les sous-
structures)
struct Membre m = {
"Arthur Dupont",
.....
};

struct Membre temp;

temp = m;

sidimed.ahmed3@[Link] 99
Passer des structures comme paramètres de fonction

❖ Une structure peut être passée, comme une autre variable, par valeur ou par
adresse.

void Par_valeur(struct Membre m);

void Par_reference(struct Membre *m);
Par_valeur(m);
Par_reference(&m);

sidimed.ahmed3@[Link] 100
 Quand la structure est un pointeur !

❖ Utiliser p->name

void affiche_membre (struct Membre *p) {

printf("nom = %s\n", p->nom);
printf("adresse = %s\n", p->adresse);
printf("numéro de membre = %d\n", p->numero);

printf("\nDate d’affiliation %d/%d/%d\n", p-

>[Link], p->[Link], p->[Link]); }

sidimed.ahmed3@[Link] 101
 Quand la structure est un pointeur !

❖ Utiliser p->name

void main(){
struct Membre m = {
"Med Ali",
"rue de Kuds, 9, 7000 Nass",
42,
{ 0.0 },
{ 0, 0, 0 },
{ 5, 2, 2001 }
};
affiche_membre(&m);

sidimed.ahmed3@[Link] 102