Part 2

§2 : LE LANGAGE C
CSI3 NANTES
BENOIT.LARDEUX@ISEN-OUEST.YNCREA.FR
D’après les notes de cours

de Jean-Benoît Pierrot,
Pierre-Jean Bouvet et
Leandro Montero 2
Cours algorithmique | 2022-2023

Avant-propos
Plan du chapitre
• Introduction
• Généralités
• Syntaxe de base
• Structures de contrôle
• Les fonctions
• Les tableaux
• Compléments
• Du programme à l'exécutable

Avant-propos
Sources
• J.-P. GERVAL, Cours d’Algorithmique non-numérique, ISEN 3ème année
• B. W. Kernighan et D. M. Ritchie, The C Programming Language,
Masson
• B. CASSAGNE, Introduction au langage C, Université Joseph Fourier,
Grenoble
• C. BAC, Support de cours de langage C, INT Evry
• P. TRAU, Langage C, Université de Strasbourg (UdS)

LE LANGAGE C
INTRODUCTION

Introduction
Historique du langage C
• Apparu au cours de l'année 1972 dans les Bell Labs
• Développé par D. Ritchie et K. Thompson
• Inspiré des langages BCPL et B
• Lié à la conception du système d’exploitation UNIX
• UNIX est écrit à 95% en Langage C
• Normalisé en 1989 par l’ANSI
• ANSI C99
• Approuvé par l’ISO en 1990
• ISO C
• Evolution en 1999
• ISO C99

Introduction
Intérêts
• Basé sur un standard ouvert
• Compilateurs et bibliothèques disponibles sur la plupart des architectures
• Langage destiné au départ à simplifier les opérations de

programmation et de compilation (à la place d’un programme en
assembleur)
• Des opérations très proches des éléments matériels
• Manipulation des registres du processeur
• Opérations jusqu’au niveau des bits d’un mot mémoire
• Chaque instruction du langage est conçue pour être compilée en un
nombre d'instructions machine assez prévisible en termes d'occupation
mémoire et de charge de calcul.
• Son usage s’est largement répandu

• Unix est écrit à 95% en langage C
• A influencé de nombreux langages : C++, java, PHP, Python
7

Introduction
Intérêts

Introduction
Intérêts
• Met en œuvre un nombre restreint de concepts
• Simplifie la maitrise et écriture des compilateurs simplifiées
• Langage facile à apprendre
• Langage efficace
• Rapidité d’exécution,
• Faible encombrement des exécutables
• Il permet l’écriture de nombreux logiciels tels que

• Les noyaux de système d’exploitation
• Systèmes embarqués

Introduction
Inconvénients
• Peu de vérifications lors de la compilation et aucune vérification
pendant l'exécution (la réussite de la compilation n’assure pas que le
programme fonctionne)
• Exemple : Une allocation mémoire qui passe une compilation mais qui est
trop petite pour le nombre de données allouées
• Pas de support direct aux concepts informatiques modernes

• Programmation orientée objet
• Programmes portables. Le comportement exact des exécutables dépend
de l'ordinateur cible.
10

LE LANGAGE C
GÉNÉRALITÉS
11

Généralités
Organisation des fichiers de votre programmation

• Il existe 2 types de fichiers
• Les fichiers sources (*.c)
• Contient les programmes et sous-programmes utilisés par votre algorithme
• Contient la description des étapes successives à réaliser
• Les fichiers en-tête ou header(*.h)
• Rappel comment sont définis vos programmes (comment sont définis les
entrées et les sorties)
main.c toto.c toto.h
… … …
… … …
main(){ fonction1(){ fonction1();

... ...
} }
Programme principal
Fichier sources
Fichier en-tête
12

Généralités
Programme principal
• Il s’agit du seul fichier qui contient la fonction main
• C’est le point de démarrage de l’exécutable
test_pi.c
#include <stdio.h> Header de la bibliothèque standard (in/out)
pour la fonction printf
#define PI 3.14 Equivalence, le pre-processeur remplace
tous les PI par 3.14
main(){ /* debut de la fonction main */
float valeur; Déclaration d'un variable valeur de type float
valeur = PI; Affectation de la valeur PI à la variable valeur

Impression sur la sortie standard
printf("PI vaut %f \n ",valeur); de la variable valeur sous un
format réel
} /* fin de la fonction main */
13

Généralités
Compilation simple
• Produire un exécutable
>> ls Liste les fichiers présents dans le répertoire

test_pi.c
>> gcc test_pi.c Compile le fichier test_pi.c
>> ls
a.out test_pi.c
• Lancer l'exécutable
>> a.out : command not found !
>> ./a.out Execute a.out
PI vaut 3.14 Résultat du programme
14

Généralités
Compilation simple (suite)

• Nommer un exécutable
• Si on compile plusieurs programmes, le a.out sera celui du dernier
programme compilé,
• Le nom a.out n'est pas forcément explicite…
• L'option -o de gcc permet de nommer l'exécutable. Le o signifiant output
(sortie).
>> ls Liste les fichiers présents dans le repertoire

test_pi.c
>> gcc test_pi.c –o test_pi.x Compile le fichier test1.c
>> ls
test_pi.c test_pi.x
15

Généralités
test_carre.c
Créer des sous - fonctions
#include <stdio.h> Header de la bibliothèque standard (in/out) pour la fonction printf
#define PI 3.14
Equivalence, le pre-processeur remplace tous les PI par 3.14
float carre( float x ); Déclaration d'une fonction carre prenant comme argument d'entrée
un variable de type float et renvoie en sortie un variable de type float
main(){ /* debut de la fonction main */
Déclaration de la variable locale pi2
float pi2;
Utilisation du sous-programme carré avec comme argument
pi2 = carre( PI );
d'entrée PI. Affectation du résultat à la variable pi2
printf("PI^2 vaut %f", pi2);
Affichage de la variable pi2 à
} /* fin de la fonction main */ l'écran
Définition de la
float carre( float x){ /* début de la fonction carre */ fonction carre
Déclaration d’une variable x2 de type float
float x2;
x2 = x*x; On affecte a x2 le résultat de l'opération x*x
return( x2); On renvoie en sortie de fonction la valeur de la
variable x2
} /* fin de la fonction carré */
16

Généralités
Créer des sous-fonctions (suite)

• Compilation
>> ls Liste les fichiers présents dans le répertoire

test_carre.c
>> gcc test_carre.c –o test_carre.x Compile le fichier
>> ls test_carre.c
test_carre.c test_carre.x
• Lancer l'exécutable
>> ./test_carre.x Exécute test_carre.x

PI^2 vaut 9.8596 Résultat du programme
17

LE LANGAGE C
SYNTAXE DE BASE
18

Syntaxe de base
Les commentaires
• Les commentaires débutent par /* et se terminent par */
/* This is a comment */
• Niveaux de commentaire recommandés

• Niveau compilation
• Niveau Procédure (fonction)
• Niveau groupe d'instructions
• Niveau déclaration et instruction
• La langue anglaise est conseillée
19

Syntaxe de base
Les commentaires (2)

• Niveau compilation
• Raison d'être du fichier, nom de l'auteur, copyright, date de création, …
/*! ***************************************************************
File: test_algo.c
Author: BL
Version: v1.2 18/12/21 (BL) : correct bogs

v1.1 18/12/21 (AG) : update parameters
v1.0 16/12/22 (BL) : initial version
Brief: test bench for the algorithm
Compilator : gcc version 8.3.0
Copyright(c) 2022, Benoit LARDEUX ISEN NANTES
*******************************************************************/
20

Syntaxe de base

• Niveau fonction
• Les paramètres et la raison d'être de la procédure
/*! --------------------------------------------------------------
Function: carre
Brief: Perform square value of a real number
Interface:
Input
x : input value (float)
Output
NA
Input/Output
NA
Return value : square value of x (float)
-----------------------------------------------------------------*/
21

Syntaxe de base

• Niveau déclaration et expression
• Expliquer la déclaration d'une variable (à quoi sert-elle)
• Commenter une instruction spécifique
• Exprimer ce que réalise une fraction significative d'une procédure
float x,y,z; /* input value */

float x2,y2,z2; /* square values */
float var; /* variance */
/*-------------------------------------------------------------
Compute the variance by performing
the average of square values
--------------------------------------------------------------*/
x2 = x*x; /* compute square of x */
y2 = y*y; /* compute square of y */
z2 = z*z; /* compute square of z */
var = ( x2 + y2 +z2 )/3; /* compute average of square values*/
22

Syntaxe de base
Les types de données (1)

• Le type caractère : char
• Doit pouvoir contenir le code de n'importe quel caractère
• Le code ASCII est plus majoritairement utilisé
• Le type entier : int
• Attributs de précision : short ou long
• Attribut de représentation : unsigned
• Le type flottant
• Il en existe 3 types correspondant à 3 précisions possibles
• float
• double
• long double
23

Syntaxe de base
Les types de données (2)

Type de donnée Signification Taille Plage
(octets)
char Caractère 1 -128 à 127
unsigned char Caractère non signé 1 0 à 255
short int Entier court 2 -32768 à 32767
unsigned short int Entier court non signé 2 0 à 65535
int Entier 2/4 cf short int et long int
unsigned int Entier non signé 2/4 cf unsigned short et long int
long int Entier long 4 -2174483648 à 2147486647
unsigned long int Entier long non signé 4 0 à 4294967295
float Flottant (réel) 4 ± 3.4*10-38 à 3.4*1038
double Flottant double 8 ± 1.7*10-308 à 1.7*10308
long double Flottant double long 10 ± 3.4*10-4932 à 3.4*104932
24

Syntaxe de base
Déclaration d'une variable
Pseudo-langage
Langage C
variable
a,b,c : Entier int a,b,c;
tab : tableau de 100 Entier int tab[100];
c : Caractère char c;
pa : Entier* int* pa;
texte : Chaine de taille max 100 char texte[100];
25

Syntaxe de base
Affectation d'une variable

• L'affectation se fait avec l'opérateur "="
Pseudo-langage Langage C
a 2 a = 2;
c'x' c = 'x';
tab[4]  8 tab[4] = 8;
pa  0x204b pa = 0x204b;
• L'affectation peut être englobée dans la déclaration
Déclaration
a : Entier int a = 2;
a 2
26

Syntaxe de base
Opérateurs usuels
• Addition
1 : Evaluation de a et b
c = a + b; 2 : Addition de a et b
3 : Affectation du résultat dans c

• Soustraction
c = a - b;
• Multiplication
L'opérateur '/' désigne à la fois la division
c = a * b; entière et là division flottante. Si a et b
sont entiers alors division entière sinon
division flottante
• Division
c = a / b;
• Modulo
c = a % b;
27

Syntaxe de base
Opérateurs de comparaison
• Strictement supérieur
1 : Evaluation de a et b
res = ( a > b );
2 : Comparaison de a e t b, 1 si vrai , 0 sinon
3 : Affectation du résultat dans res
• Supérieur ou égal
res = (a >= b );
• Strictement inférieur
res = ( a < b );
• Inférieur ou égal
res = ( a <= b );
• Egal
res = ( a == b );
Ne pas confondre l'opérateur de
• Différent comparaison '==' et l'opérateur
res = ( a != b ); d'affectation '="
28

Syntaxe de base
Opérateurs spéciaux
Evalue i puis incrémentation à la

différence de ++i (qui sera plus
Syntaxe Description rapide)
++ Incrémentation i++;
-- Décrémentation i--;
& Obtention d'adresse int* pa = &a;
* Obtention de contenu int a = *pa;
&& Et logique (( a < b)&&(c < d));
|| OU logique (( a < b)||(c < d));
! Négation (!( a < b));
== Egalité (( a < b)==(c < d));
= Affectation a = b;
29

Syntaxe de base
Opérateurs spéciaux (suite)
Syntaxe Description
+= Addition puis affectation i += 1;
-= Soustraction puis affectation i -= 1;
/= Division puis affectation x /= 2;
*= Multiplication puis affectation x *= 2;
30

Syntaxe de base
Opérateurs sur les bits
Syntaxe Description
& AND c = a & b;
| OR c = a | b;
^ XOR c = a ^ b;
~ NOT b = ~a;
<< Décalage à gauche b = a << 5;
>> Décalage à droite b = a >> 5;
31

Syntaxe de base
Ecriture formatée (la fonction afficher du C)
#include <stdio.h> #include <stdio.h>

int main(){ int main(){
printf("Bonjour \n"); printf("x=%d",2);
return 0; return 0;
} }
Caractère spécial Signification Caractère spécial Format

\n Saut à la ligne %d Décimal
\t tabulation %f Flottant
\\ Antislash %e Scientifique
%% Pourcentage %c Caractère
%x Hexadécimal
Attention, un même contenu de
variable a plusieurs représentations %s Chaine de caractères
différentes %g Meilleur de %e et %f
32

Syntaxe de base
Lecture formatée (simple)
#include <stdio.h>
int main(){
int x;
printf("Donnez votre taille :");

scanf("%d", &x);
printf("Vous mesurez %d cms\n", x);
return 0;
}
Attention, il est préférable de ne

lire qu’une seule variable à la fois
Attention à ne pas oublier le & sinon le programme

plantera quand vous le lancerez (tentative d’accès à
une adresse mémoire inexistante ! )
33

Syntaxe de base
Inclusion de sources
#include "nom_de_fichier" ou #include <nom_de_fichier>
• Lors de la compilation, le pré-processeur remplace la ligne d'inclusion

par le contenu du fichier
• Dans le système UNIX :
• <nom_de_fichier> représente un fichier système
• Le fichier sera recherché dans les répertoires système connus du compilateur
• "nom_de_fichier" représente un fichier utilisateur
• Le fichier sera recherché dans le répertoire courant
34

Syntaxe de base
Quelques bibliothèques standards…
Fichier Contenu
<stdio.h> Fonctions puts() gets(), printf(), scanf(),…
<limits.h> Indique les limites des types
<string.h> Traitement des chaines, copie, concaténation,
recherche de sous-chaines
<math.h> Fonctions mathématiques
<stdlib.h> Allocation dynamique de mémoire (malloc),
conversion nombre vers ascii,…
<time.h> Fonctions liées à l'heure et la génération des
nombres aléatoires
35

Syntaxe de base
Exemple de nommage….
• Variables locales Renseigne sur le type
int maVariable_i int* maVariable_pi

float maVariable_f float* maVariable_pf
double maVariable_d double* maVariable_pd
char maVariable_c char* maVariable_pc
• Variables Globales
int MA_VARIABLE_GLOBALE Majuscules !
• Fonctions
float maFonction( float input_f){
36

Syntaxe de base
Exercice 1
Ecrire un programme en langage C qui fait saisir à l’utilisateur 2 entiers et
qui calcule puis affiche la somme des 2 valeurs entrées.
37

Syntaxe de base
Exercice 2
Qu’affiche le programme suivant ?
#include <stdio.h>
#include <stdlib.h>
int main(){
int a = 8;
int b = 14;
int c,d;
a++;
b-=2;
c = a|b;
d = (a<<2) & (b>>1);
printf("c=%x et d=%d",c,d);
return 0;
}
38

LE LANGAGE C
STRUCTURES DE CONTRÔLE
39

Structure de contrôle
Séquence
Pseudo-langage
Langage C
Faire
ab a = b;
c d c = d;
Fait
40

Alternative : if
Pseudo-langage
Langage C
si (a = b) alors if( a == b){
... …
sinon }else{
... …
finsi }
int i=2;
if( i == 2){ >> ./a.out
printf("Branche 1"); Branche 1
}else{ Fin
printf("Branche 2"); >>
}
printf("Fin");
41

Répétition (1) : while
Pseudo-langage
Langage C
Tant que (a=b) faire while( a == b){
... …
Fin tant que }
int i=2; >> ./a.out

while( i > 0){ 2
printf("%d\n", i); 1
i--;
}
Fin
printf("Fin"); >>
42

Répétition (2) : while
Pseudo-langage
Langage C
Répéter do{
... …
Jusqu'à (a=b) }while(a == b);
int i=2; >> ./a.out

do { 2
i--;
} while( i > 0);
Fin
printf("Fin"); >>
43

Répétition (3) : for
Pseudo-langage
Langage C
pour (i 0 à N par pas de 1) faire for(i=0;i<=N;i++){
... …
finpour }
int i=0; >> ./a.out

for(i=0;i<=2;i++){ 0
}
printf("Fin");
2
Fin
>>
44

Choix multiple
Pseudo-langage Langage C
Selon switch(a){
(a=1) faire case 1 :
… …
fait break;
(a=2) faire case 2 :
… …
fait break;
Sinon faire default :
… …
fait break;
Finselon }
L’instruction break permet d’interrompre la structure

de contrôle en cours et de remonter à la structure de
contrôle englobant
45

Exercice : du pseudo langage au langage C ..
Traduire en langage C le programme suivant, quels sont les résultats affichés ?
Programme test TantQue (div>0) Faire

Declaration x, y, div, q, mul : Entier q  x/div
Debut x  x%div
x  123456 y  y+mul*q
y 0 div  div/10
div  1000000 Si q>0
q 1 mul  mul*10
mul  1 FinSi
FinTantQue
Afficher(x)
Afficher(y)
Fin Test
46

LE LANGAGE C
LES FONCTIONS
47

Les fonctions
Rappel : Programme et Fonctions

• Le C n’utilise que des fonctions
• Les fonctions sont des programmes admettant des paramètres formels
et retournant un seul résultat
• comme les fonctions mathématiques y=f(x,y,. . . ))
• Le passage de paramètre est (presque) toujours en entrée : c’est pour
cela qu’il n’est pas toujours précisé
• La valeur de retour est spéciﬁée par l’instruction retourner
Programme addition ( E a, b : Entier, S s : Entier )
Déclaration somme : Entier
début
s  a+b
fin addition
En C :
fonction addition ( E a, b : Entier) : Entier int addition(int a, int b){
Déclaration s : Entier int s;
Début
s  a+b s = a+b;
retourner (s) return( s );
fin addition } 48

Procédures et fonctions
Particularités du langage C
• Une fonction ne renvoie pas forcément une donnée en sortie
• Le mot clef void est utilisé pour exprimer l'idée "d'aucune valeur"
• Il n'existe qu'un seul passage de paramètre : le passage par valeur (ou

passage de paramètre en entrée)
• Les autres types de passages de paramètres (en sortie ou en entrée/sortie)
sont exprimés au moyen des pointeurs
49

Créer une fonction en langage C

Méthode 1 Méthode 2
main.c func.h
int maFonction(int a,int b);
int maFonction(int a,int b);
func.c
void main(){
int c; #include "func.h"
… int maFonction(int a,int b){
c = maFonction ( a, b); …
… }
}
main.c
int maFonction(int a,int b){
… #include "func.h"
} void main(){
int c;
…
c = maFonction ( a, b);
}
50

Syntaxe des fonctions

Définition
int monAddition( int a, int b ){

int res; Paramètres d'entrée
res = a + b;
return( res );
} Paramètres de retour
Utilisation
void main(){
int c;
…
c = monAddition( 1, 2)
…
}
51

Procédure et passage de paramètres en sortie (1)

Définition
void monAddition2( int a , int b , int* pc ){

int c = 0;
c = a + b; Paramètres
*pc = c; de sortie
} Paramètres
d'entrée
Utilisation
void main(){
int c = 0;
monAddition2( 1, 2, &c)
}
52

Définition mémoire
void monAddition2( int a , int b , int* pc ){ 0xD0 -
int c = 0;
0xD4 -
c = a + b;
*pc = c; 0xD8 -
}
0xDC -
0xE0 -
Utilisation 0xE4 -
void main(){ 0xE8 -
int c = 0;
monAddition2( 1, 2, &c) 0xEC -
} 0xF0 -
0xF4 -
0xF8 -
53

int c = 0;
0xD4 -
c = a + b;
*pc = c; 0xD8 0
}
0xDC -
0xE0 -
Utilisation 0xE4 -
&c = 0xD8
void main(){ 0xE8 -
int c = 0;
} 0xF0 -
0xF4 -
0xF8 -
54

int c = 0;
0xD4 -
c = a + b;
*pc = c; 0xD8 0
}
0xDC -
0xE0 -
Utilisation 0xE4 -
void main(){ 0xE8 -
int c = 0;
} 0xF0 -
0xD8
0xF4 -
0xF8 -
55

&a = 0xEC &b = 0xF0 &pc = 0xF4

int c = 0;
0xD4 -
c = a + b;
*pc = c; 0xD8 0
}
0xDC -
0xE0 -
Utilisation 0xE4 -
void main(){ 0xE8 -
int c = 0;
monAddition2( 1, 2, &c) 0xEC 1
} 0xF0 2
0xF4 0xD8
0xF8 -
56

int c = 0;
&c_i = 0xF8 0xD4 -
c = a + b;
*pc = c; 0xD8 0
}
0xDC -
0xE0 -
Utilisation 0xE4 -
void main(){ 0xE8 -
int c = 0;
} 0xF0 2
0xF4 0xD8
0xF8 0
57

int c = 0;
0xD4 -
c = a + b;
*pc = c; 0xD8 0
}
0xDC -
0xE0 -
Utilisation 0xE4 -
void main(){ 0xE8 -
int c = 0;
} 0xF0 2
0xF4 0xD8
0xF8 3
58

int c = 0;
0xD4 -
c = a + b;
*pc = c; 0xD8 3
}
0xDC -
0xE0 -
Utilisation 0xE4 -
void main(){ 0xE8 -
int c = 0;
} 0xF0 2
0xF4 0xD8
0xF8 3
59

int c = 0;
0xD4 -
c = a + b;
*pc = c; 0xD8 3
}
0xDC -
0xE0 -
Utilisation 0xE4 -
void main(){ 0xE8 -
int c = 0;
} 0xF0 -
0xF4 -
0xF8 -
60

Procédure et passage de paramètres en entrée et

sortie
Définition
void monEchange( int* pa , int* pb){
int temp1,temp2;
temp1 = *pa;
temp2 = *pb;
*pa = temp2;
*pb = temp1;
}
Utilisation
void main(){
int a,b;
a = 2;
b = 3;
monEchange(&a,&b);
}
61

Commentaires
• Les fonctions permettent de sortir la valeur d'une seule variable
• L'instruction return(a,b)n'existe pas!!!!
• Si l'on désire plusieurs valeurs de variable en sortie de la

fonction/procédure, on a le choix :
• Utiliser le passage de paramètres en sortie (ou entrée/sortie)
• Nécessité d'utiliser les pointeurs
• Utiliser comme type de sortie de la fonction une structure pouvant
contenir plusieurs variables
• voir fin du chapitre
62

Exercice 1
Ecrire une fonction en langage C nommée max qui renvoie la valeur max
de 2 entiers. Tester votre fonction dans un programme principale qui
affiche le résultat avec les valeurs 2 et 3
63

Exercice 2
Ecrire une fonction en langage C nommée cube qui prend en entrée un

entier et qui le remplace par sa valeur cubique. Tester votre fonction dans
un programme principale avec la valeur 3.
64

Exercice 3 : Quelle heure sera t-il dans 1 minute ?
Créer un programme qui à partir d'une heure hh:mm:sec rentrée par

l'utilisateur calcule et affiche l'heure qu'il sera dans 1 minute… On vous
demande d'utiliser une sous-fonction nommée calculHoraire()
>> Entrez un horaire
Heure : 17
Minute : 36
Seconde : 49
Il est 17 h 36 min 49 sec
Dans 1 minute il sera 17 h 37 min 49 sec
Généralisez ensuite la sous-fonction pour donner l’heure qui sera dans X

heures, Y minutes et Z secondes …
65

LE LANGAGE C
LES TABLEAUX
66

Les tableaux
Tableaux statiques
• Déclaration
float tab1[10];
unsigned int tab2[20], tab3[15];
• Initialisation
float tab1[10] = {1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0};
unsigned int tab2[20] = {1,4,5};
• Remarques
• Les indexes de tableau vont de 0 à N-1
• La taille du tableau doit être connue lors de la compilation
• ex
float tab3[n];
67

Les tableaux
Cas des chaînes de caractères
char chaine1[7] = {'b','o','n','j','o','u','r'};
char chaine2[8] = "bonjour"; Comme le compilateur complète toute chaine

littérale par le caractère null, il est
nécessaire de prévoir un caractère de plus…
char chaine3[] = "bonjour";
On peut aussi ne pas indiquer la taille de la chaine,

le compilateur fixera la taille adéquate!
68

Les tableaux
Référence à un élément du tableau

• Accès en lecture
int tab[4] = {1,2,3,4}

int a;
Accès au 3ème élément de tab
a = tab[2];
• Accès en écriture Attention : Les tableaux en C

commencent à l'indice 0…
int tab[4];
tab[0] = 1;
tab[1] = 2;
tab[2] = 3;
tab[3] = 4;
69

Les tableaux
Lien entre tableau et pointeurs

• Tout identificateur de type « tableau de x » apparaissant dans une
expression est converti en une valeur constante dont :
• le type est pointeur vers x
• la valeur est l'adresse du premier élément du tableau
• Il en découle l'équivalence suivante :

a = tab_pi[i]; a = *(tab_pi+i);
adresse mémoire
tab tab[0]
tab+1 tab[1]
tab+2 tab[2]
tab+3 tab[3]
70

Les tableaux
Tableaux et allocation dynamique de mémoire

• On peut déclarer un tableau de taille inconnue lors de la compilation en
utilisant les fonctions malloc et free
int *tab; On déclare un pointeur pour le tableau
tab = malloc( N * sizeof(int) ); On alloue la mémoire pour un

tableau de N entiers
tab[0] = 1;
tab[1] = 2; La fonction sizeof renvoie la
tab[2] = 3; taille en octets d'un type
tab[3] = 4;
free( tab ); On libère la mémoire allouée
71

Les tableaux
Allocation de mémoire
• Lors d'une allocation statique de mémoire
• La taille de la mémoire doit être une constante (connue lors de la
compilation)
• la mémoire est libérée implicitement en fin de fonction
• Lors d'une allocation dynamique de mémoire

• La taille de la mémoire peut être une variable
• La mémoire est libérée explicitement avec la fonction free
• Si la mémoire n'est pas libérée convenablement, on peut obtenir des erreurs
de segmentation ("segmentation fault") lors de l’exécution du programme
72

Les tableaux
Passage de tableau en paramètres d'entrée (1)
Définition
float maMoyenne( float* tab, int n ){
int i = 0;
float acc = 0.0;
for(i = 0 ; i < n ; i++){
acc += tab[i];
}
return(acc/n);
}
Utilisation
void main(){
float moy = 0.0;
float tab[2] = {3.5 , 10.8}; Tableau statique
moy = maMoyenne( tab, 2);
}
73

Les tableaux
Passage de tableau en paramètres d'entrée (2)

Définition
float maMoyenne( float* tab, int n ){
int i = 0;
float acc = 0.0;
for(i = 0 ; i < n ; i++){
acc += tab[i];
}
return(acc/n);
}
Utilisation
void main(){
int n = 2; Tableau dynamique
float moy = 0.0;
float *tab = malloc( n * sizeof(float));
tab [0] = 3.5;
tab[1] = 10.8;
moy = maMoyenne( tab, n);
free( tab );
} Libération de la mémoire
74

Les tableaux
Passage de tableau en paramètres de sortie (1)

Comme tab est un pointeur, le tableau peut être
utilisé comme argument de sortie!
Définition
void maSuite( int* tab, int n ){
int i = 0;
for( i=0 ; i<n ; i++){
tab[i] = i;
}
}
Utilisation
void main(){
int n = 10; Tableau statique
int tab[10];
maSuite( tab, n);
}
75

Les tableaux
Passage de tableau en paramètres de sortie (2)

Définition On alloue la mémoire pour
int* maSuite( int n ){ le tableau
int i = 0;
int* tab = malloc( n * sizeof(int));
for( i=0 ; i<n ; i++){
tab [i] = i;
}
return( tab );
}
Utilisation
void main(){ On déclare un pointeur pour le

int n = 10; tableau sans mémoire allouée
int* tab;
tab = maSuite( n );
free( tab );
} On libère la mémoire
76

Les tableaux
Exercice
Ecrire une fonction en langage C nommée afficheTab qui affiche les
valeurs d’un tableau de taille arbitraire. Ecrire ensuite une fonction
nommée shiftTab qui décale les valeurs d’un tableau de taille arbitraire
vers la gauche et qui remplace la dernière valeur du tableau par 0.
Tester vos fonctions avec le tableau [1 2 3].
77

LE LANGAGE C
COMPLÉMENTS
78

Compléments
Equivalences
• Directive #define
• Les équivalences sont remplacées par leur valeur par le pré-processeur
• Exemple :
#define identificateur reste-de-la-ligne
#define PI 3.14 Les mots définis par équivalence sont

généralement mis en majuscule car
ils sont globaux et constants
79

Compléments
Opérateur conditionnel
• Opérateur ?:
• Opérateur ternaire permettant de remplacer la structure if else
condition_phrase ? phrase1 : phrase 2
• Exemple :
int a, b, c;
...
c = a > b ? a : b; // if a>b "execute" a, else b
• Association avec une directive de pré-compilation
#define MAX(x,y) ((x) > (y)) ? (x) : (y)
80

Compléments
Enumération
• Mot clef enum
• Permet de créer un type dénombrable personnalisé
enum nom_e {liste d'identificateurs };
• Exemple :
/*déclaration de l'enumérateur*/
enum couleur_e {BLEU=0,BLANC=1, ROUGE=2};
/* déclaration et initialisation d'une variable de

type couleur */
enum couleur_e maCouleur_e = BLEU;
81

Compléments
Structures
• Déclaration de la structure
struct personne_s {
char prenom[20];
int age;
};
• Déclaration d'une variable de type structure
struct personne_s p1_s;

struct personne_s *p2_ps;
• Exemples d'utilisation
p1_s.age = 30;
p2_ps->age = 31;
82

Compléments
Type personnalisé
• Le mot clef typedef permet de définir un nouveau type de donnée
typedef char monChar_t;

typedef int* monPointeurSurEntier_pt;
typedef struct {char prenom[20];int age;} personne_t;
• Exemples d'utilisation
monChar_t prenom [20];

monPointeurSurEntier_pt age;
personne_t p1;
83

Compléments
Portée des variables

• Variables globales
• Déclarées en dehors d'une fonction
int MA_VARIABLE;
void fonction(){
…
}
• Variables locales
• Déclarées dans une fonction
void fonction(){
int maVariable;
}
84

Compléments
Qualifications des variables locales

• Classe dynamique (défaut)
• La variable est stockée dans une pile LIFO automatique
• La variable est perdue à la fin de la fonction
int maVariable_i;
• Classe statique
• La variable est stockée à une adresse fixe
static int maVariable_i;
• Classe "register"
• Spécifie au compilateur que la variable est utilisée souvent
• L'accès à cette variable est optimisée
register int maVariable_i;
85

Compléments
Conversion de type (cast)
Dans le langage C il est possible de forcer le type d'une variable ou

d'une expression en utilisant l'opérateur de conversion
float x = 3.14;
int a = (int)x
void *malloc (size_t size)
float* tab = (float*) malloc(N*sizeof(float));
86

LE LANGAGE C
DU PROGRAMME À
L'EXÉCUTABLE
87

Du programme à l'exécutable
Les étapes de la compilation
Pre- Linking
Compiling Assembling
processing
bonjour.c bonjour.i bonjour.s bonjour.o a.out
Compilation Edition de liens
88

Code source
• Contient l'ensemble du code C du programme
• Comprend au minimum un fichier C avec une fonction main
#include <stdio.h>
int main(){
/* ecriture du mot bonjour et saute une ligne */

printf("bonjour!!\n");
return 0;
}
89

Etape 1 : Pre-processing
Pre- # 1 "bonjour.c"
processing # 1 "<interne>"
# 1 "<ligne de commande>"
# 1 "bonjour.c"
# 1 "/usr/include/stdio.h" 1 3 4
# 28 "/usr/include/stdio.h" 3 4
bonjour.c bonjour.i # 1 "/usr/include/features.h" 1 3 4
# 329 "/usr/include/features.h" 3 4
• Operations de # 1 "/usr/include/sys/cdefs.h" 1 3 4
substitution dans le code …
extern int printf(__const char* __restrict
• #include, #if, _format,…);
#define ,/* */ …
• Contrôle de syntaxe # 2 "bonjour.c" 2
int main(){
>> gcc –E bonjour.c > bonjour.i printf("bonjour!!\n");

>> ls return 0;
bonjour.c bonjour.i }
90

Etape 2 : Compilation
.file "bonjour.c"
.section .rodata
Compiling .LC0:
.string "bonjour!!"
.text
.globl main
.type main, @function
main:
leal 4(%esp), %ecx
bonjour.i bonjour.s andl $-16, %esp
pushl -4(%ecx)
pushl %ebp
movl %esp, %ebp
• Le code C est transformé pushl %ecx
subl $4, %esp
en code assembleur movl $.LC0, (%esp)
call puts
movl $0, %eax
>> gcc –s bonjour.i addl $4, %esp
popl %ecx
>> ls popl %ebp
bonjour.c bonjour.i bonjour.s leal -4(%ecx), %esp
ret
.size main, .-main
.ident "GCC: (GNU) 4.1.2 20071124 (Red
Hat 4.1.2-42)"
.section .note.GNU-stack,"",@progbits
91

Etape 3 : Assembling
0000000 457f 464c 0101 0001 0000 0000 0000 0000
0000020 0001 0003 0001 0000 0000 0000 0000 0000
0000040 00ec 0000 0000 0000 0034 0000 0000 0028
Assembling 0000060 000b 0008 4c8d 0424 e483 fff0 fc71 8955
0000100 51e5 ec83 c704 2404 0000 0000 fce8 ffff
0000120 b8ff 0000 0000 c483 5904 8d5d fc61 00c3
0000140 6f62 6a6e 756f 2172 0021 4700 4343 203a
0000160 4728 554e 2029 2e34 2e31 2032 3032 3730
0000200 3131 3432 2820 6552 2064 6148 2074 2e34
bonjour.s bonjour.o 0000220 2e31 2d32 3234 0029 2e00 7973 746d 6261
0000240 2e00 7473 7472 6261 2e00 6873 7473 7472
0000260 6261 2e00 6572 2e6c 6574 7478 2e00 6164
0000300 6174 2e00 7362 0073 722e 646f 7461 0061
• Le code assembleur est 0000320 632e 6d6f 656d 746e 2e00 6f6e 6574 472e
transformé en code 0000340
0000360
554e
0000
732d
0000
6174
0000
6b63
0000
0000
0000
0000
0000
0000
0000
0000
0000
machine *
0000420 0000 0000 001f 0000 0001 0000 0006 0000
0000440 0000 0000 0034 0000 002b 0000 0000 0000
0000460 0000 0000 0004 0000 0000 0000 001b 0000
0000500 0009 0000 0000 0000 0000 0000 035c 0000
>> gcc –c bonjour.s 0000520 0010 0000 0009 0000 0001 0000 0004 0000
>> ls 0001340 0003 0003 0000 0000 0000 0000 0000 0000
bonjour.c bonjour.i bonjour.s 0001520 6961 006e 7570 7374 0000 0000 0014 0000
bonjour.o 0001540 0501 0000 0019 0000 0902 0000
0001554
92

Etape 4 : Linking
Linking
>> gcc –o bonjour.o

>> ls
bonjour.c bonjour.i bonjour.s
bonjour.o a.out bonjour.o a.out
• bonjour.o est incomplet car il ne contient pas le code de la fonction

printf()
• Ce code est contenu dans la bibliothèque <stdio.h>
• Pour la compilation, seul le prototype était inclus
• L'édition des liens va réunir le fichier objet et les fonctions contenues

dans les bibliothèques, pour produire le programme complet
93

Compilation séparée
main.c func.c
#include "func.h" func.h #include "func.h"
main(){ int maFonction1(..); int maFonction1(..){
int x,y; float maFonction2(..); …
y = maFonction1(x); }
… float maFonction2(..){
} …
}
>> gcc –c main.c
>> gcc –c func.c
10110001
10011001 Preprocessing 10110001
01100011
main.o 10010100 + compiling + 10011001
01100011
10101010
01101010 assembling 10010100 func.o
10101010
0
01101010
0
Edition de liens >> gcc main.o func.o –o main.x

(linking)
main.x
94

Utilisation de bibliothèques
main.c
#include <math.h>
#include "func.h"
main(){
int x,y; Bibliothèques Bibliothèques
y = maFonction1(x); standard utilisateur
…
}
>> gcc –c main.c maths func
Preprocessing
10110001
+ compiling + func.a (statique)
10011001
main.o
01100011
10010100 assembling func.so (dynamique)
10101010
01101010
0
>> gcc main.o -lm –lfunc –o main.x

Edition de liens
(linking)
main.x
95

Part 2

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Part 2

Transféré par

Droits d'auteur :

Formats disponibles

§2 : LE LANGAGE C

D’après les notes de cours

Cours algorithmique | 2022-2023

Cours algorithmique | 2022-2023

Cours algorithmique | 2022-2023

Cours algorithmique | 2022-2023

Cours algorithmique | 2022-2023

• Langage destiné au départ à simplifier les opérations de

• Son usage s’est largement répandu

Cours algorithmique | 2022-2023

Cours algorithmique | 2022-2023

• Il permet l’écriture de nombreux logiciels tels que

Cours algorithmique | 2022-2023

• Pas de support direct aux concepts informatiques modernes

Cours algorithmique | 2022-2023

Cours algorithmique | 2022-2023

Organisation des fichiers de votre programmation

main(){ fonction1(){ fonction1();

Cours algorithmique | 2022-2023

float valeur; Déclaration d'un variable valeur de type float

valeur = PI; Affectation de la valeur PI à la variable valeur

Cours algorithmique | 2022-2023

>> ls Liste les fichiers présents dans le répertoire

Cours algorithmique | 2022-2023

Compilation simple (suite)

>> ls Liste les fichiers présents dans le repertoire

Cours algorithmique | 2022-2023

Cours algorithmique | 2022-2023

Créer des sous-fonctions (suite)

>> ls Liste les fichiers présents dans le répertoire

>> ./test_carre.x Exécute test_carre.x

Cours algorithmique | 2022-2023

Cours algorithmique | 2022-2023

• Niveaux de commentaire recommandés

Cours algorithmique | 2022-2023

Les commentaires (2)

Version: v1.2 18/12/21 (BL) : correct bogs

Brief: test bench for the algorithm

Compilator : gcc version 8.3.0

Copyright(c) 2022, Benoit LARDEUX ISEN NANTES

Cours algorithmique | 2022-2023

Les commentaires (3)

Brief: Perform square value of a real number

Return value : square value of x (float)

Cours algorithmique | 2022-2023

Les commentaires (4)

float x,y,z; /* input value */

var = ( x2 + y2 +z2 )/3; /* compute average of square values*/

Cours algorithmique | 2022-2023

Les types de données (1)

Cours algorithmique | 2022-2023

Les types de données (2)

Cours algorithmique | 2022-2023

Déclaration d'une variable

tab : tableau de 100 Entier int tab[100];

pa : Entier* int* pa;

texte : Chaine de taille max 100 char texte[100];

Cours algorithmique | 2022-2023

Affectation d'une variable

• L'affectation peut être englobée dans la déclaration

Cours algorithmique | 2022-2023

3 : Affectation du résultat dans c

Cours algorithmique | 2022-2023