objectif général : acquerir les fondamentaux d'un langage procédural objectifs opérationnels : Mémoriser des données à l’aide des variables Traiter des données à l’aide des opérateurs Communiquer avec le programme à travers le clavier et l’écran Contrôler le flux d’exécution des instructions Se servir des tableaux, des pointeurs et des structures Gérer la mémoire d’une manière dynamique Définir et utiliser des fonctions

1. Langage C
les fondamentaux
M. DIENG Abdoulaye

2. Les objectifs du module
• Mémoriser des données à l’aide des variables
• Traiter des données à l’aide des opérateurs
• Communiquer avec le programme à travers le clavier
et l’écran
• Contrôler le flux d’exécution des instructions
• Se servir des tableaux, des pointeurs et des
structures
• Gérer la mémoire d’une manière dynamique
• Définir et utiliser des fonctions

3. Sommaire
1. Notion de variable
2. Les types élémentaires
3. Notion de constante
4. Les opérateurs
5. Entrée/sortie de données
6. Les structures de contrôle
7. Les Tableaux
8. Les Pointeurs
9. Les Fonctions
10. Les Structures

4. Notion de variable
• Une variable permet de désigner un emplacement mémoire et possède :
 une valeur ou contenu « provisoire » ;
 un type décrivant un ensemble de valeurs et un ensemble
d'opérateurs sur ces valeurs ;
 un identificateur ou nom permettant l’accès au contenu.
• Déclaration de variables:
Type identificateur1[,identificateur2, …];

5. Types de base
entiers
• Types entiers
DDééffiinniittiioonn MMiinn MMaaxx OOcctteettss
sshhoorrtt iinntt --3322776688 3322776677 22
iinntt --22114477448833664488 22114477448833664477 44
lloonngg iinntt --22114477448833664488 22114477448833664477 44
uunnssiiggnneedd iinntt 00 44229944996677229955 44
uunnssiiggnneedd lloonngg 00 44229944996677229955 44

6. Types de base
caractères et réels
• Type caractère
• Désigné par char ou unsigned char, un caractère (lettre, chiffre ou
symbole, visible ou non) est codé en mémoire sur 1 octet.
• La valeur stockée est le code (un entier) du caractère dans le codage de
la machine utilisée (en général le code ASCII).
• Ces valeurs vont de -128 à 127 dans le cas des char et de 0 à 255 dans
le cas des unsigned char.
• Type réel
DDééffiinniittiioonn MMaannttiissssee MMiinn >> 00 MMaaxx OOcctteettss
ffllooaatt 66 11..117755**ee--3388 33..44022**ee3388 44
ddoouubbllee 1155 22..222255**ee--33088 11..779977**ee33088 88
lloonngg ddoouubbllee 1199 33..336622**ee--44993322 11..118899**ee44993322 110

7. Notion de constante
• Une constante est désignée par un identificateur et une valeur, qui sont
fixés en début de programme
• La valeur ne peut pas être modifiée
• Syntaxes de déclaration :
#define identificateur valeur_constante
const type identificateur = valeur_constante;
• Il est fortement recommandé d’écrire l’identificateur d’une constante en
majuscule.
• La 1ère forme définit une constante de préprocesseur qui permet d'associer
une valeur à un mot
• La 2nde forme déclare une constante qui occupe de l’espace mémoire.
• Dans la première forme, le type est sous-entendu (si il y a un point, c'est
un réel, sinon un entier ; si il y a des quotes, c'est un caractère).

8. Les opérateurs
• Opérateurs arithmétiques
+, -, *, /, % (modulo), ++(incrément), --(décrément)
• Opérateurs d’assignation
= (affectation), += (ajouter à), *=, /=, -=, %=
• Opérateurs de comparaison
== (égalité), <, <=, >, >=, != (différent)
• Opérateurs logiques
&& (et), || (ou), ! (non)

9. Entrée/sortie de données
• printf("format"[,listeValeurs]) affiche la liste de valeurs (variables ou
expressions) dans le format choisi. La partie "format" est une chaîne de
caractères qui peut contenir du texte (à afficher tel quel) et des
spécificateurs de format (préfixés du symbole %).
• scanf("%format1 [%format2 …]", adr1[, adr2, … ]) lecture au clavier
d’une (ou de +sieurs) valeur(s), dans le(s) format(s) spécifié(s).
• Principaux spécificateurs de format
c (caractère), d ou i (entier), u (entier non signé),
f ou e (rationnel en notation décimale ou scientifique),
s (chaîne de caractères), hd (short int), p (adresse), %(afficher %).
Les types longs sont : ld ou li et Le ou Lf .

10. Structures de contrôle
structure conditionnelle strict
• Cette structure est utilisée si on veut exécuter un traitement (instruction
simple ou composée) seulement si une condition est vraie et ne rien
faire si la condition est fausse.
• Sa syntaxe : if (condition) {
traitement
}
• Que le traitement soit exécuté ou non, le programme continue
normalement son exécution après le bloc {…}.

11. Structures de contrôle
structure conditionnelle alternative
• Elle permet d'exécuter deux traitements différents en fonction de la
valeur booléenne d’une condition.
• Sa syntaxe :
if (condition)
{traitement_1}
else
{traitement_2}
• Après l’exécution du traitement 1 ou bien du traitement 2, le
programme continue normalement son exécution juste après le bloc.

12. Structures de contrôle
structure conditionnelle multiple
• Elle permet d'exécuter plusieurs traitements différents en fonction de
valeurs booléennes de plusieurs conditions.
• Sa syntaxe :
if (condition_1)
{traitement_1}
else if (condition_2)
{traitement_2}
…
else //Si aucune des n-1 conditions n’est
vraie
{traitement_n}

13. Structures de contrôle
structure conditionnelle de choix
• La structure Switch permet de choisir le traitement à effectuer en
fonction de la valeur d'une variable ou d'une expression.
• Sa syntaxe :
switch (expression entière)
{
case valeur 1 : traitement 1; break;
case valeur 2 : traitement 2; break;
…
[default : traitement par défaut ]
}
NB: break permet de sortir du bloc

14. Structures de contrôle
structure itérative « while »
• La boucle while permet de répéter un traitement tant qu'une expression
conditionnelle est vraie.
• Sa syntaxe :
while (condition)
{traitement}
• La condition est testée avant la première exécution du traitement.
• Ce traitement peut ne jamais s’exécuter
• Il est nécessaire d’initialiser la variable qui subit la condition pour le premier
passage.
• Il faut s’assurer que le traitement fait évoluer la variable qui subit la
condition pour que la terminaison de la boucle soit assurée.
• Lorsque la condition devient fausse le programme continue normalement
son exécution après le bloc.

15. Structures de contrôle
structure itérative « do … while »
• La boucle do … while permet de répéter un traitement tant qu'une
expression conditionnelle est vraie.
• Sa syntaxe
do {
traitement
}while(condition);
• Le traitement s’exécute au moins une fois.
• L’initialisation de la variable qui subit la condition pourra se faire lors de
la première exécution du traitement
• Il faut s’assurer que le traitement fait évoluer la variable qui subit la
condition pour que la terminaison de la boucle soit assurée.
• Lorsque la condition devient fausse, la boucle se termine et le
programme continue normalement son exécution après le bloc.

16. Structures de contrôle
structure itérative « for »
• La boucle for permet de répéter un traitement un nombre connu de fois.
• Elle aide aussi à garder le contrôle de la boucle à un seul endroit
• Syntaxe :
for (exp_1 ; condition; exp_2 ) {
traitement
}
• exp_1 permet d’initialiser la variable qui subit la condition
• exp_2 permet de modifier la variable qui subit la condition
• Lorsque la condition devient fausse, le programme sort de la boucle et
continue normalement son exécution.
• Dans toute structure itérative, la commande continue permet de sauter
l’itération courante pour passer à la l’itération suivante.

17. Les tableaux
• Un tableau permet de désigner sous un seul nom un regroupement de
données de même type.
• Chaque donnée est repérée par un indice (entier naturel)
• Déclaration d’un tableau unidimensionnel :
type_des_données nom_tab[dim];
• Notation d’une donnée ou variable indicée : nom_tab[indice];
• L’indice varie de 0 à dim – 1.
• On peut initialiser un tableau au moment de sa déclaration
• Exemples: char voyelles[6]={'a', 'e', 'i', 'o', 'u', 'y'};
données 'a' 'e' 'i' 'o' 'u' 'y'
indices 0 1 2 3 4 5
Dans ce cas la donnée 'e' est notée par voyelles[1]

18. Les pointeurs
présentation
• Un pointeur est une variable spéciale qui peut contenir l'adresse d'une
autre variable.
• Lorsque la variable pointée fait plus d'un seul octet, ce qui est
évidemment très souvent le cas, c'est l'octet de début (le premier de la
suite d'octets qui stockent la variable) qui est pointé.
• Une variable pointeur occupe toujours sizeof(int) (4 octets en général)
• Les principaux intérêts des pointeurs résident dans la possibilité :
– d’allouer de la mémoire au moment de l’exécution, ce qui permet la
gestion des tableaux de tailles variables ainsi que des structures
de données récursives (listes et arbres);
– de permettre le passage par adresse pour des paramètres de
fonctions.

19. Les pointeurs
présentation (suite et fin)
• L’opérateur & ('adresse de') permet d’affecter l'adresse d'une variable à
un pointeur.
• L'opérateur * ('contenu pointée par') permet d’accéder au contenu pointé
par le pointeur.
• Il faut toujours initialiser (à défaut à NULL ie « une zone mémoire vide »)
un pointeur pour éviter qu’il pointe n’importe où.
• Déclaration d’un pointeur: Type_pointé * NomPointeur
• Exemple :
<<-- iiddeennttiiffiiccaatteeuurrss
int A;
<<-- vvaalleeuurrss
int *P=NULL;
<<-- aaddrreesssseess
A = 10;
P = &A; // P pointe sur A
*P = 20; // modification de la valeur de A à partir de P
printf("la variable pointee contient %d", A)

20. Les pointeurs
ajout d’un entier naturel
• En ajoutant un entier naturel à un pointeur, un décalage d’adresses
se fait par rapport à la taille (sizeof) en octet de l'objet pointé.
• On pourra ainsi accéder aux cases mémoires consécutives à celle
qui est pointée.
• Exemple :
float * adr;
adr + 1 ; /* représente l'adresse du réel qui suit l'adresse du réel
contenue dans adr */
• On peut aussi
– incrémenter : adr++;
– ajouter : adr+= 12

21. Les pointeurs
gestion mémoire
• La fonction malloc([nbr*] sizeof(type_pointé)) demande au système
d'exploitation un bloc de mémoire et renvoie l'adresse du bloc alloué
• La fonction free(pointeur) libère un bloc mémoire précédemment alloué
via malloc()
• Exemple : ( à tester)
#include <stdlib.h>
float * p_reel=NULL; p_ reel= (float *) malloc ( sizeof(float) );
if( p_ reel == NULL ) printf("Allocation impossible");
else {
printf("Allocation de mémoire à l’adresse %pn", p_ reel);
*p_ reel = 3.14; printf("remplissage avec la valeur %fn",*p_ reel);
free(p_ reel); printf("libération de mémoire à l’adresse %pn", p_
reel);
p_ reel = NULL; /* car free() ne le fait pas */
}

22. Les fonctions
présentation
• Une fonction peut être vue comme un bloc d'instructions avec un nom
• Les fonctions permettent de découper un programme pour le rendre plus
lisible et plus facile à déboguer ainsi que de réutiliser du code qui revient
souvent.
• Une fonction (non principale) n’est exécutée que lorsqu’elle est appelée.
• La communication entre fonction appelée et fonction appelante peut se
faire par l'intermédiaire de variables locales à la fonction appelée qu'on
nomme paramètres (ou arguments) formels.
• Syntaxe de la définition d’une fonction :
TypeRslt NomFonct ([TypeArg1 NomArg1 [, TypeArg2 NomArg2 , ...] ] ) {
déclarations locales;
instructions;
[return rslt;]
}
• L’instruction return permet à une fonction de renvoyer une valeur
• Une fonction de TypeRslt void ne retourne aucune valeur.

23. Les fonctions
passage de paramètre
• Le passage de paramètre en C est toujours réalisé par valeur.
• La valeur d’un argument effectif n’est modifiée par la fonction que s’il
est passé par adresse à l’aide d’un pointeur comme paramètre
formel associé
• Un tableau est toujours passé par adresse : l’identificateur d’un
tableau est un pointeur constant sur son 1er élément

24. Les structures
présentation
• Une structure est un type qui permet de désigner sous un seul nom un
regroupement de données de types différents ou non.
• Ce type permet ainsi de structurer très proprement des informations qui
vont ensemble
• Définitions d’une structure:
struct nomStructure{
typeDonnee1 nomDonnee1;
typeDonnee2 nomDonnee2;
};
ou
typedef struct{
typeDonnee1 nomDonnee1;
typeDonnee2 nomDonnee2;
} nomStructure;

25. Les structures
utilisation
• Déclaration d’une variable de type structure:
struct nomStructure nomVariable;
• Déclaration simplifiée de cette variable avec typedef
nomStructure nomVariable;
• Accès à un champ d’une variable de type structure:
nomVariable.nomDonnee;
• Accès à un membre d’une variable pointeur sur une structure :
nomVariable->nomDonnee;
• Structures et fonctions
– On peut utiliser les structures comme valeur de retour ;
– Par défaut, les structures sont passées par valeur