Section : 1ère année Université Tunis Carthage

Algorithmique et Programmation C ----*----

----*---- Ecole Supérieure de la Statistique et
F. CHAKER KHARRAT de l’Analyse de l’Information de
Tunisie (ESSAIT)

Le langage de Programmation C
Généralités
1. Structure d’un programme en langage C
Voici un exemple simple de programme en C

#include<stdio.h>
main()
{
printf(« Bonjour tout le monde \n ») ;
}

Tout programme C comprend :

• des directives du pré processeur (commençant par #)

#include : inclure le fichier déclarant les fonctions standards d’entrées/sorties

(en anglais STanDard Input/Output), qui feront le lien entre le programme et
la console (clavier/écran). Dans cet exemple, il s’agit de printf.

#define : qui permet de définir une constante.

• Une entête de fonction. Une fonction imposée main() qui est exécutée au
lancement du programme. Cette ligne est obligatoire en C, elle définit le
« point d’entrée » du programme, c'est-à-dire l’endroit où débutera l’exécution
du programme.
• Un bloc d’instructions, délimité par des accolades {}. Chaque instruction se
termine par un point virgule « ; ».
• Des commentaires sont placés entre /* et */ (facultatifs)

2. Les fonctions C standards

A chaque bibliothèque est associée un fichier d’extension .h

La bibliothèque standard stdio.h : Gestion des E/S, fichiers ; printf, scanf, fopen, …
La bibliothèque standard stdlib.h : Utilitaires abs( )
valeur absolue,
rand ( )
aléatoire,
atof ( ), atoi ( )
conversion ASCII nombre

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

La bibliothèque standard string.h : Manipulation des chaînes de caractères
• strcmp ( )
comparaison entre deux chaînes
<0 : CH1 < CH2
>0 : CH1 > CH2
= 0 : CH1 = CH2
• strcpy( ), strncy( )
copie de chaînes
• strlen ( )
renvoie la longueur de la chaîne
• strcat ( )
concaténation de chaînes
La bibliothèque standard ctye.h : Fonctions sur les caractères : test et conversion majuscule
minuscule
Toupper( ), tolower( ), isdigit( ), isupper( )
La bibliothèque standard math.h : Fonctions mathématiques : sin(), cos(), tang(), etc.

3. Les données mémoires

3.1 Les types élémentaires
A toute donnée doit correspondre un type, qui autorise la réservation d’une zone mémoire de
taille prédéfinie, la vérification par le compilateur de la validité des opérations, et permet
éventuellement la création de nouveaux types.
Parmi les types élémentaires, on distingue les types entier et réel. Les constantes relatives à ces
types sont référencées dans les bibliothèques limits.h et float.h.
• Entier (int)

shor int1 2 octets (16 bits) -32 768 … 32 767

unsigned short int 2 octets 0…. 65 535
long int 4 octets (32 bits) -2 147 483 647 …
2 147 483 648
unsigned long int 4 octets 0 … 4 264 667 265

On utilise les abréviations short et long pour désigner respectivement un short int et un long int.
Le type int désigne selon les compilateurs soit un short soit un long. On peut également
spécifier explicitement qu’un type est signé en ajoutant signed (unsigned pour dire non signé).

• Constante (const)
Const est un qualificateur de type. On peut initialiser un identificateur const, mais on ne peut rien
lui affecter par la suite. La variable se comporte dès lors comme une constante typée. La variable
est placée en mémoire morte. Ex : cons tint n=29 ;

• Réel (float)
float 4 octets Simple précision 1.18 E+/-38
double 8 octets Double précision 6.46 E -308 …1.8 E 308
long double 10 octets

• Caractère (char)
Un caractère est représenté en machine par un entier, ainsi ‘c’ désigne la valeur entière du
caractère dans la table ASCII.
char 1 octets -128 … 127
unsigned char 1 octets 0 … 255

1
int est facultatif dans ces déclarations

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

Remarque :
- Les caractères imprimables se notent entre ‘ ‘. Ex : ‘a’, ‘r’, ‘+’, …
- Les caractères non imprimables utilisent le caractère ‘\’. Exemple :
‘\t’ caractère tabulation
‘\n’ retour chariot (nouvelle ligne)
‘\\’ le caractère \
• boobéen
Souvent on définit les macros constantes FALSE et TRUE comme suit :
enum bool {FALSE,TRUE} ;
En C, une expression conditionnelle est fausse, quand elle prend la valeur 0 et vraie dans tous les
autres cas.

3.2 La définition de nouveaux types

On peut définir de nouveaux types simplement au moyen de l’instruction typedef, en écrivant :
typedef ancien type nouveautype ;
Exemple :
typedef int entier ; // dorénavant entier est synonyme de int
entier x,y ;

4. Opérateurs et expressions
4.1 Opérateurs d’affectation
En langage C, l’affectation = est un opérateur et on peut l’utiliser dans les expressions.
4.2 Opérateurs arithmétiques
+,-,*,/, % (reste de la division entière)

4.3 Opérateurs relationnels

<, <=, >, >=

== (égalité, Attention = c’est l’affectation)
!= (différence)
&& (et)
|| (ou)
! (non)

4.4 Opérateurs conditionnels ( ? :)

expression ? expression1 : expression 2

Exemple :
min = (a<b) ? a : b ;
Est équivalent à dire :
min =a si a<b
sinon min=b

4.5 Opérateurs d’incrémentation (++) et de décrémentation (--)

Les opérateurs d’incrémentation et de décrémentation peuvent être utilisées sous forme préfixée
(++ variable/ -- variable) ou encore postfixée (variable ++/variable --)

Exemple :

4.6 Autres opérateurs

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 Variable op= expression ⇔ Variable = Variable op expression

+=;-=;*=;/=

Exemple :
i + =2 ; est équivalent à i = i + 2 ;

4.7 Priorité des opérateurs

5. Les fonctions d’entrée/sortie conventionnelles

- scanf : lecture des données (valeurs numériques, caractères)

scanf (« format »,liste d’adresse) ;

Exemple : scanf(« %d %f »,&a,&b) ;

Attention : lorsqu’il d’agit d’une chaîne de caractère il faut enlever l’adresse et
mettre directement la variable chaîne de caractère.

Exemple : scanf(« %s »,chaine) ;

- printf : écriture ou affichage des données en sortie

printf (« texte à éditer avec spécification de formats », liste d’expressions) ;

Exemple : printf(« le produit de code % d coûte %f»,a,b) ;

- getchar( ) : permet de lire un seul caractère

Exemple :

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 c = getchar( ) /* permet de lire un caractère saisi au clavier et de le stocker dans la
variable c. */
Remarque :

c=getchar() joue le même rôle que scanf (« %c »,&c) ;

- putchar( ) : permet l’affichage d’un caractère

Exemple :
putchar(c ) /* permet d’afficher le caractère lu dans la variable c */
Remarque :

putchar(c) joue le même rôle que printf (« %c »,c) ;

- gets( ) : permet de lire une chaîne de caractères.

Exemple :
gets(ch)
Remarque :

gets(ch) joue le même rôle que scanf (« %s »,ch) ;

- puts( ) : affiche une chaîne de caractère sur écran

Exemple :
puts(ch ) /* permet d’afficher la chaîne de caractères stockée dans la variable ch */
Remarque :

puts joue le même rôle que printf (« %s »,ch) ;

voici les principaux formats de conversion de scanf et printf :

%c : caractère
%d : entier décimal
%f, %e et %g : virgule flottante
%s : chaîne de caractères suivie d’un espace
(au bout de laquelle est ajouté automatiquement le caractère null \0)
%u : entier non signé

6. Les structures de contrôles

5.1 Les structures conditionnelles
If (expression)
Instruction2 ;
/* si expression est vraie, alors instruction est exécutée, sinon instruction est ignorée */
If (expression)
Instruction1 ;
else
Instruction2 ;

2
Si instruction est composée d’un bloc d’instructions il faut alors les délimiter par {et }

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 /* si expression est vraie, alors instruction1 est exécutée, sinon instruction2 est exécutée
*/

If (expression1)
Instruction1 ;
else
if (expression 2)
Instruction2 ;
else
if (expression 3)
Instruction3 ;
….
else
if (expression N)
Instruction N ;
else
Instruction N+1 ;

5.2 La structure à choix multiples (switch)

switch (expression)
{
case valeur 1 : { instructions 1;
break ;}
case valeur 2 : { instructions 2;
break ;}
……
case valeur N : { instructions N;
break ;}
default : {instructions ;}
}

Remarques :
- Expression est une variable de type entier ou caractère
- Valeur ne peut en aucun cas être une variable
- L’étiquette « default » est facultative et l’instruction correspondante à elle-ci est
exécutée lorsque aucun branchement n’a été effectué.
- On peut rattacher plusieurs cas à une même instruction comme suit :

switch (expression)
{
case valeur 1 :
case valeur 2 :
case valeur 3 : { instructions1;
break ;}
case valeur 4 :
case valeur 5 :
case valeur 6 : { instructions2;
break ;}
default : {instructions ;}
}

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 5.3 Les structures itératives (boucles)
- While
while (expression)
{instructions ;}

/* instruction est exécutée tant que expression est vraie ( !=0)*/

c=getchar() while (c=getchar() !=’.’)

while (c !=’.’) { if (c==’ ‘)
{ if (c==’ ‘) Peut être remplacée par Blanc++;
Blanc++; Else
Else autre ++;
autre ++; }
c=getchar();
}

- Do … while
do
{ instructions ; }
while (expression) ;

/* instruction est exécutée au moins une fois*/

- For
for (expression1;expression2;expression3)
{ instructions ; }

/* On exécute expression 1 (initialisation de la boucle). Si expression 2 est vraie on exécute

instructions puis expression 3 (incrémentation/ décrémentation) jusqu’à ce que expression 2
devienne fausse */

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 Figure 1 : Organigramme récapitulatif des structures de contrôle

5.4 Rupture de séquence

- break :
Break exécute une sortie d’un bloc d’instructions dépendant de l’une des instructions
suivantes do, for, while ou switch.
- continue :
Instruction forçant le passage à l’itération suivante de la boucle la plus proche.

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 - goto label :

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 label : instruction
L’instruction goto permet de se brancher inconditionnellement à instructions.
Exemple :
{
for (expr1 ; expr2 ; expr3)
{ ….. ;
goto sortie ;
…. ;
}
sortie : ….. ;
}

- return [expression]
Exécute une sortie d’une fonction en rendant le contrôle à la fonction appelante, tout en
retournant la valeur d’une expression si la fonction appelée l’autorise (≠ void).

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 Section : 1ère année Université Tunis Carthage
Algorithmique et Programmation C ----*----
----*---- Ecole Supérieure de la Statistique et
F. CHAKER KHARRAT de l’Analyse de l’Information de
Tunisie (ESSAIT)

Les
Les tableaux (unidimensionnels et bidimensionnels) et les chaînes de
caractères
1. Les tableaux
Un tableau est un type structuré homogène3.
Chaque élément du tableau est repéré par un indice précisant sa position au sein de l’ensemble.
1.1 Les tableaux unidimensionnels :
 Déclaration

Syntaxe : type_elements nom_tableau[nb_cases] ;

Exemple : int Tab[100] ;

Remarques :

- La numérotation des cases s'effectue de 0 à nb_cases-1.

- La taille du tableau doit être une constante (par opposition à variable), donc int t1[n] ;
où n serait une variable déjà déclarée est une mauvaise déclaration. Par contre si on a
défini #define N 100 en directive, on peut déclarer int t1[N] ; car N est alors une
constante.

 Affectation des valeurs dans des cases

Syntaxe : nom_tableau[numero_case] = valeur ;

 Accès à la valeur d'une case d'un tableau

Syntaxe : nom_tableau[numero_case]

 Initialisation
On peut initialiser un tableau lors de sa déclaration :
float tab[5] = { 1, 2, 3, 4, 5} ; /* init. de tous les éléments de tab */
float toto[10] = {2, 4, 6} ; /* equ. à toto[0]=2 ; toto[1]=4 ; toto[2]=6 ; */
/* les autres éléments de toto sont mis à 0. */

1.2 Les tableaux bidimensionnels :

3
Toutes les données sont de même type

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

Un tableau à 2 dimensions est similaire à une matrice. C’est en fait un tableau de tableau à 1
dimension, il se déclare donc de la façon suivante :

- Déclaration

Syntaxe : type_elements nom_tableau[taille_dim1][taille_dim2] ;

On peut imaginer le tableau sous la forme d'un rectangle avec taille_dim1 qui représente le
nombre de lignes et taille_dim2 qui représente le nombre de colonnes.

- Affectation des valeurs dans des cases

Syntaxe : nom_tableau[numero_case_dim1][numero_case_dim2] = valeur ;

Si on représente ce tableau sous la forme de lignes et de colonnes, la numérotation des cases

s'effectue de 0 à numero_ligne-1 pour les lignes et de 0 à numero_colonne-1 pour les colonnes.

Comme il est schématisé, tableau[i][j] fait référence à l’élément de la ligne i et de la colonne i de

tableau. Tout comme un élément d’un tableau à 1 dimension, tableau[i][j] se manipule comme
n’importe quelle variable.

- Accès à la valeur d'une case d'un tableau bidimensionnel

Syntaxe : nom_tableau[numero_case_dim1][numero_case_dim2]

- Initialisation d’un tableau bidimensionnel

syntaxe :
type nom_tableau[N][P] = {val1, val2, ..., valN+P} ;
ou
type nom_tableau[N][P] = { {valN1_1, valN1_2, ..., valN1_P}, {valN2_1, valN2_2, ...,
valN2_P} ..., {valN_1, valN_2, ..., valN_P}} ;

Exemple : Mat[2][3]={{1,2,3},{4,5,6}}.

Ou encore Mat[2][3]={1,2,3,4,5,6}

1.3. Les chaînes de caractères

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

Les chaînes de caractères sont des tableaux particuliers de caractères (char), dont l’élément ‘\0’
code la fin de la chaîne, mais pas nécessairement du tableau.
- Déclaration

Syntaxe : char <nom_tableau>[Dim] ;

Exemple : Char Nom[20] ;

- Initialisation :
Char Nom[20]={‘M’,’O’,’H’,’A’,’M’,’E’,’D’,’\0’} ;
Ou encore :
Char Nom[20]= « Mohamed » ;

- Lecture d’une chaîne à partir du clavier

 scanf :

Syntaxe : scanf(« %s »,nom_chaîne) ;

Ex : scanf(« %s »,Nom) ;
 gets : permet de lire une chaîne de caractères.

Syntaxe : gets(var_chaine) ;

Ex : gets(Nom)
Remarque :

gets(ch) joue le même rôle que scanf (« %s »,ch) ;

- Lecture d’un caractère à partir du clavier : getchar( )

getchar( ) : permet de lire un seul caractère
Exemple :
c = getchar( ) /* permet de lire un caractère saisi au clavier et de le stocker dans la
variable c. */

Remarque :

c=getchar() joue le même rôle que scanf (« %c »,&c) ;

- Affichage d’une chaîne sur écran

 printf :

Syntaxe : printf(«texte %s »,nom_chaîne) ;

Ex : printf(« Le nom lu est : %s\n »,Nom) ;

 puts : permet d’afficher une chaîne de caractères.
Syntaxe : puts(var_chaine) ;

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 Exemple : puts(Nom) /* permet d’afficher la chaîne de caractères
stockée dans la variable Nom */
Remarque :

puts joue le même rôle que printf (« %s »,ch) ;

- Affichage d’un caractère sur écran : putchar( )

Syntaxe : putchar(var_caractère) ;

Exemple : putchar(c ) /* permet d’afficher le caractère lu dans la

variable c */
Remarque :
putchar(c) joue le même rôle que printf (« %c »,c) ;

- Accès aux caractères d’une chaîne :

Syntaxe : Nom_chaine[indice]

Ex : Nom[2] qui vaut H.

- Opérations élémentaires sur les chaînes

La bibliothèque standard string.h : Manipulation des chaînes de caractères
• strcmp ( )
comparaison entre deux chaînes
<0 : CH1 < CH2
>0 : CH1 > CH2
= 0 : CH1 = CH2
• strcpy( ), strncy( )
copie de chaînes
• strlen ( )
renvoie la longueur de la chaîne
• strcat ( )
concaténation de chaînes

Exercice 1:
Ecrire un programme qui lit une ligne de texte (ne dépassant pas 200 caractères), la mémorise
dans une variable TXT et affiche ensuite :
1. la longueur L de la chaîne. Utilisez une boucle FOR. (NB : n’utilisez pas la fonction
prédéfinie strlen.)
2. le nombre de ‘e’ contenus dans le texte
3. toute la phrase à rebours, sans changer le contenu de la variable TXT
4. toute la phrase à rebours, après avoir inversé l’ordre des caractères dans TXT.
Ex : voici une petite phrase !
! esarhp etitep enu iciov

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 #include<stdio.h>
main()
{
/* Déclarations */
char TXT[201] ;
int i,j ;
int L; // longueur de la chaîne
int C; // compteur des lettres ‘e’
int AIDE ; // pour l’échange des caractères
/* Saisie des données */
printf(« Donner un texte (max 200 cc):\n ») ;
gets(TXT) /* L’utilisation de scanf est impossible pour lire une phrase contenant un nombre variable*/
/ * mots */
/* Compter le nombre de caractères de la chaîne */
for (L=0 ;TXT[l] !=’\0’ ;L++)
;
/* Compter le nombre de letter ‘e’ */
C=0 ;
for (I=0 ;TXT[I] !=’\0’ ;I++)
{ if (TXT[I]==’e’)
C++;
printf(“ Le texte contient %d lettre e \n”,C);

/* affichage de la phrase à l’envers */

for (I=L-1 ;I>=0 ; I--)
putchar(TXT[I]) ; // ou encore printf(« %c »,TXT[I]) ;
putchar(‘\n’); // ou encore printf(‘\n’);

/* Inverser l’ordre des caractères */

for (I=0,J=L-1 ;I<J ; I++,J--)

{ AIDE=TXT[I];
TXT[I]=TXT[J];
TXT[J]=AIDE;
}
puts(TXT); // ou encore printf(“%s\n”,TXT);
}

Exercice 2 :
Ecrire un programme C qui lit deux chaînes de caractères CH1 et CH2 et qui copie la
première moitié de CH1 et la première moitié de CH2 dans une troisième chaîne CH3.
Afficher le résultat.
a) Utilisez les fonctions spéciales de <string.h>
b) Utilisez uniquement gets et puts.

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 a)- // utilisation de la bib. String
#include<stdio.h>
#include<string.h>
main()
{
// Déclarations
char CH1[100],CH2[100];
char CH3[100]=” “;

// Saisie des données

printf(« Donnez la première chaîne ») ;
gets(CH1) ;
printf(« Donnez la seconde chaîne ») ;
gets(CH2) ;
// Traitement
strncpy(CH3,CH1,strlen(CH1)/2) ;
strnca(CH3,CH2,strlen(CH2)/2) ;
// Affichage du résultat
printf(« Un demi %s plus un demi %s donne %s \n »,CH1,CH2,CH3) ;
}
b)- // Utilisation de gets et puts
#include<stdio.h>
main()
{
// Déclarations
char CH1[100],CH2[100];
char CH3[100]=” “;
int L1,L2 ; // Longueur de CH1 et CH2
int i ; // indice courant dans CH1 et CH2
int j ; // indice courant dans CH3

// Saisie des données

printf(« Donnez la première chaîne ») ;
gets(CH1) ;
printf(« Donnez la seconde chaîne ») ;
gets(CH2) ;
// détermination des longueurs de CH1 et CH2
for(L1=0 ;CH1[L1] ;L1++) ;
for(L2=0 ;CH2[L2] ;L2++) ;
// Copier la première partie de CH1 vers CH3
for (i=0 ; i<(L1/2) ; i++)
CH3[i]=CH1[i] ;
// Copier la première moitié de CH2 dans CH3
j=i ;
for (i=0 ; i<(L2/2) ; i++)
{
CH3[j]=CH2[i] ;
j++;
}
// Terminer la chaîne de CH3
CH3[j]=’\0’;
// Affichage du résultat
puts(« Chaïne résultat:\n ») ;
puts(CH3) ;
}

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 Section : 1ère année Université Tunis Carthage
Algorithmique et Programmation C ----*----
----*---- Ecole Supérieure de la Statistique et
F. CHAKER KHARRAT de l’Analyse de l’Information de
Tunisie (ESSAIT)

Les pointeurs et les fonctions

1. Les pointeurs
Un pointeur est une variable qui contient l’adresse d’une autre variable plutôt qu’une valeur.

- Déclaration

Syntaxe : <type> *<variable>

Exemple : int *A ; /* A est un pointeur sur un entier */

- Utilisation de base des pointeurs :
L’opérateur unaire & donne l’adresse d’une variable. L’instruction A=&X affecte l’adresse de X à
la variable A. On dit que A pointe sur X.
L’opérateur unaire * représente l’opérateur d’indirection ou de référence. Quand on l’applique à un
pointeur il donne accès à l’objet pointé par ce pointeur. Ainsi A=*X permet au pointeur A
d’accéder à la valeur de X.

int a ;
int *p ;
a=10 ;
p=&a ; // p pointe maintenant sur la variable a
*p=150 ;
printf (« la valeur de a=%d\n » ;a) ; // a=150 ;

Exemple : Donnez les valeurs de a et de p relatives à chaque instruction du programme suivant :

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 #include<stdio.h>
main()
{
int a ;
int *p;
a=150;
p=&a;
printf(“a=%d ; *p=%d\n”;a,*p); // a = 150 ; *p= 150

a+=10;
printf(“a=%d ; *p=%d\n”;a,*p); // a = 160 ; *p= 160

*p+=40;
printf(“a=%d ; *p=%d\n”;a,*p); // a = 200 ; *p= 200

En résumé : Après les instructions P:

int A ; •
int *P ;
P=&A ;
A Désigne le contenu de A A:
&A Désigne l’adresse de A …
P Désigne l’adresse de A
*P Désigne le contenu de A

- Les pointeurs et les tableaux

En langage C, l’identificateur d’un tableau lorsqu’il est employé seul (sans
indice à sa suite) est considéré comme un pointeur sur le début du tableau.
Ainsi, pour un tableau de 10 entiers :
int tab[10] ;
Les notations suivantes sont équivalentes

tab ≅ &tab[0]
tab+1 ≅ &tab[1]
tab+i ≅&tab[i]
par contre :
tab[i] ≅ *(tab+i)

Exemple :
Le programme ci-dessous permet de lire 10 nombres entiers dans un
tableau et de chercher la valeur maximale et minimale. Modifiez ce
programme en utilisant le formalise pointeur.

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 #include<stdio.h>
#define Nbre 10
main()
{
int i, min,max ;
int T[Nbre];
printf(“Donnez les %d valeurs du tableaux »,Nbre) ;
for(i=0 ;i<Nbre ;i++)
scanf(“%d”,&T[i]); // scanf(“%d”, (T+i));
min=max=T[0]; // min=max=*(T+0);

for(i=1;i<Nbre;i++)
{ if (T[i]>max) // if (*(T+i) > max)
max=T[i]; // max = *(T+i);
If (T[i]<min) // if (*(T+i) < min)
min=T[i]; // min = *(T+i);
}
printf (“La valeur maximale est %d\n”,max);
printf (“La valeur minimale est %d\n”,min);

En résumé : P:
int A[10] ; •
int *P ;
ainsi, après l’instruction
P=A ;
Le pointeur P pointe sur A[0], et A: ………..
*(P+1) Désigne le contenu de A[1]
*(P+2) Désigne le contenu de A[2]
….
*(P+i) Désigne le contenu de A[i]

- Opérations élémentaires sur les pointeurs : Soit le programme

suivant :

main()
{
int A = 1;
int B = 2;
int C = 3;
int *P1, *P2;
P1=&A;
P2=&C;
*P1=(*P2)++;
P1=P2;
P2=&B;
*P1-=*P2;
++*P2;
*P1*=*P2;
A=++*P2**P1;

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 P1=&A;
*P2=*P1/=*P2;
}
Copiez le tableau suivant et complétez-le pour chaque instruction du programme ci-dessus.
A B C P1 P2
Init. 1 2 3 / /
P1=&A 1 2 3 &A /
P2=&C 1 2 3 &A &C
*P1=(*P2)++ 3 2 4 &A &C
P1=P2 3 2 4 &C &C
P2=&B 3 2 4 &C &B
*P1-=*P2 3 2 2 &C &B
++*P2 3 3 2 &C &B
*P1*=*P2 3 3 6 &C &B
A=++*P2**P1 24 4 6 &C &B
P1=&A 24 4 6 &A &B
*P2=*P1/=*P2 6 6 6 &A &B

2. Les fonctions

- Définition des fonctions en algorithmique :

Syntaxe :

Fonction Nom_fonction (Nom_param1, Nom_param2, …) : Type_résultat_retour

Déclaration des paramètres
Déclarations locales
Instructions
FinFonction

Exemple :

Fonction Somme(A,B) : Entier

A,B : entier
Début
Resultat  A+B
Retourner (Resultat)
FinFonction

- Définition des fonctions en C :

Une fonction en C possède trois aspects :

• le prototype : c’est la déclaration nécessaire avant tout ;

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 • l’appel : c’est l’utilisation d’une fonction `a l’int´erieur d’une autre fonction
(par exemple le programme principal) ;
• la définition : c’est l’écriture proprement dite de la fonction, en-tête et corps.

- Déclaration

Type_Résultat_Retour NomFonction (TypePar1 NomPar1 , TypePar2 NomPar2 , . . . )

{
Déclarations locales;
Instructions;
}

Ou :
Type_Résultat_Retour NomFonction (NomPar1 , NomPar2 , . . . )
TypePar1 NomPar1 , TypePar2 NomPar2 ,… ;
{
Déclarations locales;
Instructions;
}

Exemple :
Ex 1: Ex 2:
int somme carre (int i ,int j ) int somme carre (i,j)
{ int i , int j ;
int resultat ; // déclaration locale {
resultat = i * i + j* j ; int resultat;
return ( resultat) ; resultat = i * i + j* j ;
} return ( resultat ) ;
}

Remarques :
- Si une fonction ne fournit pas de résultat, il faut indiquer void (vide)
comme type du résultat.
- Si une fonction n’a pas de paramètres, on peut déclarer la liste des
paramètres comme (void) ou simplement comme ().

void fonction1(void) // ou encore void fonction1()

{ //cette fonction ne prend pas de paramètres et ne renvoi rien
printf(« Ceci est la fonction 1 ») ;
}

• Prototype :
Un prototype de fonction permet au compilateur de savoir ce que la fonction attend en
paramètre, et le type de ce qu’elle retournera, même si le code correspondant à la fonction est
écrit ailleurs, ou plus loin dans le fichier source.
Le prototype d’une fonction reprend exactement l’en-tête de la fonction, mais pas son corps, qui
est remplacé par un point-virgule.

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

Type_de_retour Nom_fonction(Type_param1 Nom_Param1, Type_param2 Nom_Param2,
…) ;

Dans l’écriture d’un prototype de fonction, les noms de paramètres sont optionnels :

Type_de_retour Nom_fonction(Type_param1, Type_param2, …) ;

Exemple :

void fonction1(void) ;
void fonction2(int A,int B) ;
int fonction3 (int,int) ;

• Renvoi d’un résultat :

Une fonction peut renvoyer une valeur d’un type simple ou l’adresse d’une variable ou d’un
tableau. Pour fournir un r´esultat en quittant une fonction, nous disposons de la commande
return :

return <expr e s s i on >;

Exemple :

int fonction_carre(int a)
{ // cette fonction calcule le carré du nombre qui lui est passé en paramètre
int resultat = a*a ;
return resultat ;
}

Exemple :
Ecrire un programme C qui permet d’additionner deux nombres a et b et d’afficher le résultat.
Utiliser deux fonctions :
int addition(int a,int b)
void affichage(int c);

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

#include<stdio.h>
int addition(int,int) ;

void affichage(int); // les prototypes

main()
{
int a,b,c ;
scanf(« %d %d »,&a,&b) ;
c=addition(a,b) ;
affichage(c);
}
int addition(x,y)
int x,y ;
{
return(x+y) ;
}
void affichage (int z)
{
printf (« Résultat = %d\n »,z) ;
}

int addition(int x,int y) int addition(x, y)

{ int x,y ;
int S ; {int S ;
S=x+y ; S=x+y ;
return(S) ; return(S) ;
} }

- Passage des paramètres par valeur :

En langage C, les paramètres de fonction sont passés à celle-ci par valeur (passage par valeur), la
fonction appelée n’a aucun moyen de modifier les arguments du programme appelant ; elle ne
traite que des copies.
Exemple : prenons l’exemple d’une fonction qui prend en paramètre deux entiers et essaye
d’échanger leurs valeurs :

#include<stdio.h>
void echange(int a, int b) ;
main()
{int a=10;
int b=20;
printf(“Avant : a = %d ; b = %d\n”,a,b);
echange(a,b);
printf(“Après : a = %d ; b = %d\n”,a,b);
}
void echange(int a, int b)
{
int temp ;
printf(« Début : a = %d ; b = %d\n”,a,b);
temp=a ;
a=b ;
b=temp ;
printf(« Fin : a = %d ; b = %d\n”,a,b);
Crée par : }F. CHAKER KHARRAT Algorithmique et Programmation C
Exécution :
Avant : a = 10 ; b = 20 ;
Début : a = 10 ; b = 20 ;
Fin : a =20 ; b = 10 ;
Après : a = 10 ; b =20 ;

Exemple : donnez les valeurs finales des différentes variables

F1( )
{
Int i,j,a ;
i=1 ;
j=100 ;
a=F2(i,j) ;
printf(« i=%d ; j= %d ; a=%d\n »,i,j,a) ; // i = 1 ;j =100 ;a =1
}
F2( a,b)
int a,b;
{ a=2;
b=-1;
return(a+b);
}

Remarque : Une variable locale est détruite lorsqu’on quitte la fonction dans laquelle elle
est déclarée
- Passage des paramètres par adresse
Le passage des paramètres par valeur empêche la fonction de modifier les variables appartenant à
la portion du code appelante. Les pointeurs permettent de résoudre ce problème en passant en
argument des pointeurs sur les valeurs à modifier : on parle de passage par adresse. En effet, les
arguments de type pointeurs permettent d’accéder aux objets de la fonction appelante et de les
modifier.
Exemple :

#include<stdio.h>
void echange(int *, int *) ; // prototype
main()
{int a=10;
int b=20;
printf(“Avant : a = %d ; b = %d\n”,a,b);
echange(&a,&b);
printf(“Après : a = %d ; b = %d\n”,a,b);
}
void echange(int *pa, int *pb)
{
int temp ;
printf(« Début : *pa = %d ; *pb = %d\n”,*pa,*pb);
temp=*a ;
*a=*b ;
*b=temp ;
printf(« Fin : *pa = %d ; *pb = %d\n”,*pa,*pb);
}

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

Exécution :
Avant : a = 10 ; b = 20 ;
Début : *pa = 10 ; *pb = 20 ;
Fin : *pa =20 ; *pb = 10 ;
Après : a = 10 ; b =20 ;

Exemple : donnez les valeurs finales des différentes variables

F1( )
{
int i,j,a ;
i=1 ;
cfjqgjf
j=100 ;
a=F2(&i,&j) ;
printf(« i=%d ; j= %d ; a=%d\n »,i,j,a) ; // i = 2 ;j =-1 ;a =1
}
F2( a,b)
int *a,*b;
{ *a=2;
*b=-1;
return(*a+*b);
}

Remarques :
 Lors du passage par adresse, la déclaration du prototype de la fonction se fait
comme suit :

<type_de_retour> <nom_fonction>(type_arg1 *, type_arg2 *, ….,type_argn *) ;

Exemple : int F2(int *, int *) ;

 Dans une fonction on ne peut faire passer que les types de base (int, char,
float, short, etc.) même chose pour les valeurs de retour des fonctions. Pour pouvoir manipuler
les tableaux dans les fonctions nous utilisons le passage par adresse.
Exemple :

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 #include<stdio.h>
#define N 5;
int somme (int *, int);
main()
{
int tab[N]={1,2,3,4,5};
int som=0;
som=somme(int &tab[0], int N); // ou encore som=somme(int tab, int N);
printf(« La somme est %d\n »,som) ;
}
// fonction somme
int somme(int *t, int n) // ou encore int somme(int t, int n)
int t[ ] ; { …}
{
int i,som=0 ;
for(i=0 ;i<n ;i=++)
som+=*(t+i) ;
return som;
}

Exercice :

Écrire une fonction int compter_occurrences(char car,int taille,char *mot) qui retourne le
nombre d'occurrences d’un caractère dans un mot de longueur « taille ». Utilisez cette fonction
dans le main afin de compter et d’afficher le nombre d’occurrence de caque lettre composant le
mot lu

Solution:

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

int compter_occurrences(char car, int taille, char *mot)

{
int compteur = 0, indice;

for(indice=0; indice < taille; indice++)

if(mot[indice] == car)
compteur++;

return compteur;
}

int main(void)
{
int taille; // taille du mot
int i;
int nboccur; // nb d'occurrences de la lettre
char texte[125];

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C

 printf("entrez un mot : ");
scanf("%s", texte);

taille = strlen(texte);

for(i = 0; i < taille; i++){

nboccur = compter_occurrences(texte[i], taille, texte);
printf("%c apparait %d fois\n", texte[i], nboccur);
}

return 0;
}

Crée par : F. CHAKER KHARRAT Algorithmique et Programmation C