Les Pointeurs

Variables locales et globales

Exemple de localisation d’une personne:

Chapitre 4: Quelle est la meilleur manière de localiser une

personne?

Par Nom?

Les Pointeurs Par prénom?

Par adresse?

en

101 102

1
 Les Pointeurs Les Pointeurs

Définition Exemple
Un pointeur est une variable spéciale qui contient Un pointeur est une variable particulière, dont la valeur est
l’adresse d’une autre variable. l'adresse d'une autre variable dans la mémoire.
Exemple :
A est une variable qui contient la valeur 10.
P est un pointeur qui contient l'adresse de A
(P pointe sur A).

Remarques :
Le nom d’une variable permet d'accéder directement à sa
valeur (adressage direct).
Un pointeur qui contient l'adresse de la variable, permet
d'accéder indirectement à sa valeur (adressage indirect).
Le nom d'une variable est lié à la même adresse, alors qu’un
pointeur peut pointer sur différentes adresses.
103 104

2
 Les Pointeurs Les Pointeurs

Exemple Intérêts des pointeurs

int val=17;
char rep=’a’; Ils sont indispensables pour permettre le passage par
int *ptr1; /* déclaration d’un pointeur sur entier */ référence pour les paramètres des fonctions (pour
char *ptr2; /* déclaration d’un pointeur sur caractère */ qu’une fonction puisse modifier une variable extérieure
ptr1=&val; /* ptr1 contiendra l’adresse de val */ à cette fonction).
ptr2=&rep; /* ptr2 contiendra l’adresse de rep*/:
Ils permettent de créer des structures de données
5AF3
ptr1
(listes et arbres) dont le nombre d’éléments peut
évoluer de façon dynamique (comme un tableau
Adresse de rep
Adresse de val redimensionnable).
val
17
5AF3
2FF3
Ils permettent d'écrire des programmes plus
a
rep compacts et efficaces.
2FF3
ptr2

Mémoire 105 106

3
 Les Pointeurs Les Pointeurs

Déclaration Opérateurs de manipulation des pointeurs

Syntaxe : type *nom-du-pointeur ; Lors du travail avec des pointeurs, nous utilisons :
L’opérateur & : 'adresse de' : pour obtenir l'adresse d'une
type : c’est le type de la variable pointée. variable.
* : c’est l’opérateur qui indique au compilateur que c’est L’opérateur * : 'contenu de' : pour accéder au contenu
un pointeur. d'une adresse.

Exemple :
int *pi; //pi est un pointeur vers une variable de type int.
float *pf; //pf est un pointeur vers une variable de type float.
Remarque :
La valeur d’un pointeur donne l’adresse du premier octet
parmi les n octets où la variable est stockée.
Exemples :
int * p; //on déclare un pointeur vers une variable de type int
int i=10, j=30; // deux variables de type int
p=&i; // on met dans p, l’adresse de i (p pointe sur i)
printf("*p = %d \n",*p); //affiche : *p = 10
*p=20; // met 20 dans la case pointée par p (i vaut 20 après l’instruction)
p=&j; // p pointe sur j
i=*p; // affecte le contenu de p à i (i vaut 30 après cette instruction)

107 108

4
 Les Pointeurs
Initialisation d’un pointeur Pointeurs et Tableaux
A la déclaration d’un pointeur p (int *p; ), on ne sait pas sur quel zone
mémoire il pointe. Ceci peut générer des problèmes.
Conseil :
Toute utilisation d’un pointeur doit être précédée par une initialisation. On
peut initialiser un pointeur en lui affectant :
l’adresse d’une variable : Exemple : int a, *p1; p1=&a;
un autre pointeur déjà initialisé : Exemple : int *p2; p2=p1;
la valeur 0 désignée par le symbole NULL. Exemple : int *p; p=0;
ou p=NULL; (on dit que p pointe ‘nulle part’: aucune adresse).
109
Les Pointeurs
Le nom d'un tableau représente l'adresse de son premier élément.
Si on déclare un tableau T, alors : T=&T[0].
On peut dire que T est un pointeur constant sur le 1er élément du
tableau.
En déclarant un tableau T et un pointeur P du même type, l’instruction
P=T fait pointer P sur le premier élément de T : P=&T[0].
110
5
 Les Pointeurs Les Pointeurs

Pointeurs et Tableaux
A partir de là, on peut manipuler le tableau T en utilisant P, en Langage C :
effet :
P pointe sur T[0] et *P désigne T[0]
P+1 pointe sur T[1] et *(P+1) désigne T[1]
Les Pointeurs
….
P+i pointe sur T[i] et *(P+i) désigne T[i]

Exemple :
Allocation dynamique
de la mémoire

111 112

6
 Les Pointeurs Les Pointeurs

Allocation dynamique de mémoire Allocation dynamique de mémoire

La déclaration dune variable permet de réserver
implicitement un certain nombre d’octets en mémoire. Ce
nombre est connu avant l’exécution du programme.
int n = 18; char c = "18";
Il arrive souvent qu’on ne connaît pas la taille des données
au moment de la programmation.
On réserve alors l'espace maximal prévisible.
Exemple :
On considère un tableau de int : int tableau[100];
Le tableau occupera alors en réalité 4 * 100 = 400 octets en mémoire.
Même si le tableau est vide, il prend 400 octets ?
La place en mémoire est réservée, aucun autre programme n'a le droit
d'y toucher.

Gaspillage de la mémoire

113 114

7
 Les Pointeurs Les Pointeurs

Allocation dynamique de mémoire Allocation dynamique de mémoire

Pour éviter le problème de gaspillage de la mémoire, il serait Allocation dynamique:
souhaitable d’allouer la mémoire en fonction des données à saisir
(par exemple la dimension d’un tableau). malloc (nombre_octets)
Il faut donc un moyen pour allouer la mémoire lors de l'exécution ⇒ Alloue une zone de taille nombre_octets octets
du programme : c’est l’allocation dynamique de mémoire. en mémoire et retourne un pointeur .

En langage C, la bibliothèque <stdlib.h> contient des fonctions pour allouer Exemple :

ou libérer de la mémoire :
malloc (Memory ALLOCation) : demande au système char* p;
FEE01
d'exploitation la permission d'utiliser de la mémoire. p = (char*)malloc(2*sizeof(char));
calloc(nb-éléments, taille-élément) : La fonction calloc fournie
dans l’en-tête stdlib.h à le même rôle que le malloc mais initialise en plus
*p à zéro. FEE01
free (Libérer) : permet d'indiquer à l'OS que l'on n'a plus besoin
de la mémoire qu'on avait demandée (un autre programme peut
p
Mémoire
s'en servir).
115 116

8
 Les Pointeurs Les Pointeurs

Allocation dynamique de mémoire: Fonction malloc() Allocation dynamique de mémoire: Fonction malloc()
Syntaxe : malloc(N); //N : nombre d’octets Exemple 2:
La fonction malloc retourne : #include<stdio.h>
#include<stdlib.h>
un pointeur de type char * pointant vers le premier octet. main()
le pointeur NULL s’il n’y a pas assez de mémoire libre à allouer. {
int i = 3;
Qu’affiche ce
int j = 6; programme???
int *p;
Exemple: réserver la mémoire pour un texte de 100 caractères: p = (int*)malloc(2*sizeof(int));
*p = i;
T = malloc(100); *(p+1) = j;
printf("p = %ld \t *p = %d \t p+1 = %ld \t *(P+1) = %d\n“, p,*p,p+1,*(p+1));
Cette instruction fournit l'adresse d'un bloc de 100 octets libres et }
l'affecte à T.
S'il n'y a pas assez de mémoire, T obtient la valeur zéro (NULL).

117 118

9
 Les Pointeurs Les Pointeurs

Allocation dynamique de mémoire: Fonction malloc() Allocation dynamique de mémoire: Fonction malloc()
Exemple 2: Exemple 3:
Un programme qui stocke l'âge de tous les amis de l'utilisateur
dans un tableau, puis affiche ces âges.
Le problème est que : on connait pas le nombre d’amis de
l’utilisateur ==> Donc on connait pas la taille à donner au
Qu’affiche ce tableau.
programme???

L'intérêt de l'allocation dynamique est là : on va demander le

nombre d'amis à l'utilisateur, puis on fera une allocation
dynamique pour créer un tableau ayant exactement la taille
nécessaire (ni trop petit, ni trop grand).

119 120

10
 Les Pointeurs Les Pointeurs

Allocation dynamique de mémoire: Fonction malloc()
Exemple 3:
Un programme qui stocke l'âge de tous les amis de l'utilisateur
dans un tableau, puis affiche l’âge de tous ces amis.
Allocation dynamique de mémoire: La fonction calloc
La fonction calloc fournie dans l’en-tête stdlib.h à le même rôle
que le malloc mais initialise en plus *p à zéro :
calloc(nb-éléments, taille-élément)

121 122

11
 Les Pointeurs
Allocation dynamique de mémoire:
Différence entre calloc et malloc en C
Il existe deux différences majeures entre malloc (size_t n) et
calloc(nb-éléments, taille-élément) en programmation C:
1. premièrement en nombre d’arguments. malloc() prend un
seul argument, alors que calloc() prend deux arguments.
2. Deuxièmement, malloc() n’initialise pas la mémoire allouée,
alors que calloc() initialise la mémoire allouée à ZERO.
123
Allocation dynamique de mémoire:
Différence entre calloc et malloc en C
Table de comparaison
malloc
Le nom malloc signifie allocation de
mémoire.
void * malloc (size_t n)
renvoie un pointeur sur n octets de
mémoire non initialisée, ou NULL si la
demande ne peut être satisfaite. Si
l’espace affecté par malloc() est saturé,
les résultats ne sont pas définis.
malloc() prend un argument, à savoir le
nombre d’octets.
syntaxe de malloc ():
void * malloc (size_t n);
Alloue n octets de mémoire. Si l’allocation
réussit, un pointeur vide sur la mémoire
allouée est renvoyé. Sinon, NULL est
renvoyé.
malloc est plus rapide que calloc.
Les Pointeurs
calloc
Le nom calloc est synonyme d’allocation
contiguë.
void * calloc (size_t n, size_t size)
renvoie un pointeur sur un espace libre
suffisant pour un tableau de n objets de la
taille spécifiée, ou NULL si la demande ne
peut être satisfaite. Le stockage est
initialisé à zéro.
calloc() prend deux arguments: le nombre
de blocs et la taille de chaque bloc.
syntaxe de calloc ():
void * calloc (size_t n, size_t size);
Alloue un bloc de mémoire contigu
suffisamment grand pour contenir n
éléments. La zone allouée est initialisée à
zéro.
calloc prend un peu de temps que malloc 124
en raison de l’initialisation du mémoire
12
 Les Pointeurs Les Pointeurs

Libération de l’espace alloué Libération de l’espace alloué

Il faut libérer chaque espace alloué Exemple :
dynamiquement lorsqu'il n’est plus utilisé dans le
programme
int *p1 = (int*)malloc(sizeof(int));
La libération est effectuée à l’aide de la fonction free()
int *p2 = (int*)calloc(3,sizeof(int));
de l’en-tête stdlib.h : if (p1 == p2)
free(p1);
Syntaxe : free(pointeur); Else
{
Remarques : free(p1);
Si on ne le fait pas, on s'expose à des fuites de mémoire (le free(p2);
programme risque au final de prendre beaucoup de mémoire alors }
qu'il n'a en réalité plus besoin de tout cet espace).
Si on ne libère pas explicitement la mémoire à l'aide de free, alors
elle est libérée automatiquement à la fin du programme.

125 126

13
 Les Pointeurs Les Pointeurs

Tableau et pointeur Exercices:

1. Ecrire le programme qui range les éléments d’un tableau d’entiers
On peut accéder aux éléments par pointeurs en faisant des calculs T dans l’ordre inverse.
d’adresses (addition ou soustraction) Utiliser 2 pointeurs et une variable de permutation.

2. Ecrire le programme qui lit un entier X et un tableau des entiers

p += 4 et élimine toutes les occurrences de X dans T en tassant les
p+
int tab[6] = { 1,2,3,4,5,6 }; + éléments restants.
int *p; Utiliser 2 pointeurs pour parcourir le tableau T.
p
p = tab; // p= &tab[0];
printf("%d\n", *p); 1000 1 2 3 4 5 6
tab
p++; 1000 1008 1016
1004 1012 1020
printf("%d\n", *p);
p += 4;
printf("%d\n", *p); 1
2
6
Qu’affiche ce
programme?

127 128

14
 Les Pointeurs Les Pointeurs

/************** Exemple d’affichage inverse d’un tableau***************/

/********* Exemple de calcul de somme*****************/ #include <stdio.h>
#define Max 20
int main()
#include <stdio.h> {
int main() int taille, i , T[Max];
{ int *ptr;
ptr=&T[0];
int nbr1,nbr2, *p,*q, som; printf("\n Saisir la taille du Tableau T :");
printf(" Entrer 2 deux entiers:\n"); scanf("%d ",&taille);
scanf(" %d%d",&nbr1,&nbr2); printf(" Saisir les %d entiers du Tableau T:",taille);
for(i=0;i<taille; i++)
p=&nbr1; {
q=&nbr2; scanf("%d ",ptr);
som=*p+*q; ptr++;
}
printf(" la somme des deux nombres vaut: %d\n", som); ptr=&T[taille-1];
return 0; printf("\n Elements du tableau en ordre inverse:");
} for(i=taille-1;i>=0;i--)
{
printf(" Element %d est %d:",i,*ptr);
ptr--;
}
return 0 ;
129 } 130

15
 Les Pointeurs Les Pointeurs

/******************* Exemple de calcul de la somme des éléments d’un tableau***************/

#include < stdio.h >
Allocation dynamique de mémoire
void main() Passage de paramètres à une fonction
{
int Tab[10]; Il existe deux modes de transmission de paramètres :
int i, SOM = 0; Transmission par valeur :
int *ptr; Dans ce mode, le paramètre effectif ne subit aucune modification.
printf("\n Saisir 5 entiers du Tableau : ");
for (i = 0; i < 5; i++) Exemple:
scanf("%d", &Tab[i]);

ptr = Tab;

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

SOM = SOM + *ptr;
ptr++;
}
printf(" La somme des éléments du tableau vaut : %d", SOM);
}
131 132

16
 Les Pointeurs Les Pointeurs

Allocation dynamique de mémoire Allocation dynamique de mémoire

Passage de paramètres à une fonction
Passage de paramètres à une fonction
En C, la transmission des paramètres se fait toujours par valeur.
Il existe deux modes de transmission de paramètres :
Pour effectuer une transmission par adresse, on :
Transmission par adresse (par référence) :
lors de l'appel de la fonction, les adresses des paramètres effectifs sont on déclare le paramètre formel de type pointeur.
affectées aux paramètres formels. on envoie l'adresse (&) et non la valeur du paramètre effectif lors de
Dans ce mode, le paramètre effectif subit les mêmes modifications que le l’appel de la fonction.
paramètre formel.

Exemple:
Exemple:
Dans cet exemple, l’appel de la fonction
ValeurAbsolue provoque :
Le calcul de la valeur absolue de -5.7 et n=3 et
m= 4
son stockage dans y
Mais aussi la modification de la variable
x (paramètre effectif) qui va changer de valeur.

133 134

17
 Chapitre 5:
Les chaînes de
Programmation en
langage C caractères
2ère Année du Troc Commun MIPC II
en
Section A

136

18
 Les chaînes de caractères Les chaînes de caractères

Introduction Les chaînes de caractères (Déclaration)

En langage C, une chaîne de caractères (appelée Les chaînes de caractères sont des tableaux de caractères.
string en anglais) est un tableau, comportant Leur manipulation est donc analogue à celle d'un tableau à une
plusieurs données de type char, dont le dernier dimension:
élément est le caractère nul '\0’, ceci permet de
détecter la fin de la chaîne. Déclaration (Syntaxe) :
Il existe plusieurs fonctions prédéfinies pour le
traitement des chaînes de caractères (ou tableaux de char NomVariable [Longueur];
caractères ).
Exemple :On peut par exemple représenter la chaîne ou bien
« Bonjour » de la manière suivante : "Bonjour"
char *nom;
B o n j o u r \0 nom = (char*)malloc(dim);
Remarque: En langage C, il n'existe pas de type spécial
chaîne de caractères ou string. 137 138

19
 Les chaînes de caractères Les chaînes de caractères

Les chaînes de caractères (Déclaration) Les chaînes de caractères (Affichage)

Exemples:
char texte[10];
ou bien
char *texte; On peut utiliser la fonction printf et le format %s:

AFFICHAGE
texte = (char*)malloc(10); char texte[10] = ‘’BONJOUR’’;
printf("VOICI LE TEXTE: %s\n",texte);
char NOM[15];
On utilisera aussi la fonction puts non formatée:
Remarques : puts(texte); est équivalent à
1. Pour une chaîne de N caractères, on a besoin de N+1 octets en printf("%s\n",texte);
mémoire (le dernier octet est réservé pour le caractère ‘\0’).
2. Le nom d’une chaîne de caractères est le représentant de
l’adresse du 1er caractère de la chaîne.
3. On peut manipuler les chaînes de caractères en utilisant des
pointeurs.
139 140

20
 Les chaînes de caractères Les chaînes de caractères

Les chaînes de caractères (Lecture) Initialisation

On peut initialiser une chaîne de caractères à la définition
par l’une des trois méthodes suivantes :
On peut utiliser la fonction scanf et le format %s:
1. comme un tableau.
char texte[10] ;
LECTURE

scanf(" %s ",texte); Exemple : char ch[] = {‘e’, ’c’, ’o’, ’l’, ’e’, ’\0’};
2. par une chaîne constante.

On utilisera aussi la fonction gets non formatée: Exemple : char ch[] = "ecole";
gets(texte); est équivalent à 3. en attribuant l'adresse d'une chaîne de caractères constante
scanf(" %s",texte); à un pointeur de type char.
Exemple : char *ch = "ecole" ;

141 142

21
 Les chaînes de caractères Les chaînes de caractères

Fonctions de Traitement des chaînes de caractères Fonctions de Traitement des chaînes de caractères
Fonctions de la bibliothèque <stdio.h>
Le langage C dispose de plusieurs bibliothèques contenant des
fonctions pour le traitement de chaînes de caractères. Fonction Rôle
Les principales bibliothèques de traitement des chaînes de permet d’afficher une chaîne en
caractères sont : printf( )
utilisant le spécificateur de format %s.
La bibliothèque <stdio.h>
affiche la chaîne désignée par Chaîne
puts(chaine)
La bibliothèque <string.h> et provoque un retour à la ligne.
permet de saisir une chaîne de
La bibliothèque <stdlib.h>
scanf( ) caractères en utilisant le spécificateur
de format %s
lit la chaîne de caractères désignée par
gets( chaine) Chaîne.
143 144

22
 Les chaînes de caractères Les chaînes de caractères

Fonctions de Traitement des chaînes de caractères Fonctions de Traitement des chaînes de caractères
Fonctions de la bibliothèque <stdio.h> Fonctions de la bibliothèque <string.h>
Fonction Rôle
Fonction Exemple
fournit la longueur de la chaîne sans compter
char ch[ ]= " Bonsoir " ; strlen(<s>)
printf( ) le '\0‘ final
printf(" %s ", ch);
strcpy(<s>, <t>) copie <t> vers <s>
char *ch= " Bonsoir " ;
puts(chaine)
puts(ch);
strcat(<s>, <t>) ajoute <t> à la fin de <s>
char Nom[15];
scanf( ) printf("entrez votre nom"); renvoie un nombre:
scanf(" %s ", Nom); - positif si la chaîne1 est supérieure à la
chaine2 (au sens de l'ordre alphabétique)
char phrase[100]; strcmp(<s>, <t>)
- négatif si la chaîne1 est inférieure à la
gets( chaine) printf("entrez une phrase"); chaîne2
gets(phrase); - nul si les chaînes sont identiques.
strncpy(<s>, <t>, <n>) copie au plus <n> caractères de <t> vers <s>
145 ajoute au plus <n> caractères de <t> à la fin146
strncat(<s>, <t>, <n>)
de <s>

23
 Les chaînes de caractères Les chaînes de caractères

Fonctions de Traitement des chaînes de caractères /*************** Exemple d’affichage d’une chaîne***************/
#include <stdio.h>
Fonctions de la bibliothèque <string.h> int main()
{
Fonction Exemple char texte[100];
printf(" saisir un texte (Max 100 lettres):\n");
char ch[ ]= " Test"; scanf("%s", texte);
strlen(ch) printf(“%d”,strlen(ch)); //4 printf(" Le texte saisi est: %s",texte);
}
/*************** Longueur d’une chaîne***************/
char ch1[20]=" Bonne", ch2=" chance "; #include <stdio.h>
strcat(ch1, ch2) ; #include <string.h>
strcat(ch1, ch2) int main()
printf(" %s", ch1); // Bonne chance {
char texte[100];
int longueur;
retourne une valeur : nul si ch1 et ch2 sont
printf(" saisir un texte (Max 100 lettres):\n");
strcmp(ch1, ch2) identiques, négative si ch1 précède ch2, scanf("%s", texte);
positive si ch1 suit ch2. longueur=strlen(texte);
printf(" Le texte saisi est; %s",texte);
char ch[10]; printf(" Le texte saisi est de longueur %d",longueur);
strcpy(ch1, ch2) strcpy(ch, " Bonjour "); }
puts(ch); // affiche Bonjour
147 148

24
 Les chaînes de caractères Les chaînes de caractères

/*************** Comparaison de 2 chaînes***************/ /*************** Concatener de 2 chaînes***************/

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

int main() int main()

{ {
char CH1[100], CH2[100]; char CH1[100], CH2[100];

printf("Saisir chaîne 1\n"); printf(" saisir chaîne 1\n");

gets(CH1); gets(CH1);

printf(" Saisir chaîne 2\n "); printf(" saisir chaîne 2\n");

gets(CH2); gets(CH2);

/*strcmp(string, string) : returns 0 Si CH1 et CH2 Sont égaux */ strcat(CH1,CH2);

if( strcmp(CH1,CH2) == 0 )
printf(" Les 2 chaînes sont égaux.\n"); printf( " Résultat de concatenation: %s\n",a);
else
printf(" Les 2 chaînes sont différentes.\n"); return 0;
}
return 0;
}
149 150

25
 Les chaînes de caractères Les chaînes de caractères

Les chaînes de caractères (Conversion) Les chaînes de caractères (Conversion)

La bibliothèque <stdlib.h> contient des déclarations de fonctions pour la Fonction atoi

conversion de nombres en chaînes de caractères et vice-versa. int atoi( const char * theString );
• Cette fonction permet de transformer une chaîne de caractères,
Chaîne Nombre représentant une valeur entière, en une valeur numérique de type
int.
atoi(<s>) retourne la valeur numérique représentée par <s> comme int • Le terme d'atoi est un acronyme signifiant : ASCII to integer.

atol(<s>) retourne la valeur numérique représentée par <s> comme long #include <stdlib.h>
#include <stdio.h>
atof(<s>) retourne la valeur numérique représentée par <s> comme double
int main(void)
{
Nombre Chaîne int i;
char *s;
convertit son premier argument en une chaîne de caractères qui sera
itoa (<n_int>, <s>, <b>)
ensuite attribuée à <s>. La conversion se fait dans la base <b>.
s = "-505";
i = atoi(s);
printf("i = %d\n",i);
151 } 152

26
 Les chaînes de caractères Les chaînes de caractères

Les chaînes de caractères (Conversion) Les chaînes de caractères (Conversion)

Fonction atol char *ltoa (long VAL, char *CH, int B)
long atol( const char * theString ); ltoa convertit VAL dans une chaîne de caractères terminée par '\0' et attribue
Cette fonction permet de transformer une chaîne de caractères, représentant le résultat à CH;
une valeur entière longue, en une valeur numérique de type long. ltoa retourne CH comme résultat.
Le terme d'atol est un acronyme signifiant : ASCII to long. B est la base utilisée pour la conversion de VAL. B doit être compris entre 2
et 36 (inclus).
Cette fonction convertit un entier en une chaîne de caractères à terminaison
#include <stdio.h> nulle. Elle peut également convertir un nombre négatif.
#include <stdlib.h> #include <stdio.h>
#include <stdlib.h>
int main() #include <string.h>
{ int main(void)
printf("atol('120')=%i\n",atol("120")); { int number, l;
return 0; char string[20];
printf("Enter a number: ");
}
scanf("%d", &number);
itoa(number, string, 10);
printf("String value = %s\n", string);
return 0;
}
153 154

27
 Les chaînes de caractères Les chaînes de caractères

1. Écrire un programme qui lit 5 mots, séparés par des espaces et qui Exercice 1: Ecrire un programme en C qui permet de renverser une chaine
les affiche ensuite dans une ligne, mais dans l'ordre inverse. Les de caractères.
mots sont mémorisés dans 5 variables M1, ... ,M5.
Exemple Exercice 2: Ecrire un programme en C qui permet de saisir un mot et de
Math Info Physique Chimie !
vérifier s’il est un palindrome.
! Chimie Physique Info Math
Exercice 3: Ecrire un programme en C qui permet d’échanger deux chaine
2. Ecrire un programme qui demande l'introduction du nom et du de caractères Chaine1 et Chanie2.
prénom de l'utilisateur et qui affiche alors la longueur totale du
nom sans compter les espaces. Employer la fonction strlen.
Exemple:
Introduisez votre nom et votre
prénom: Ahmed Jalali
Bonjour Ahmed Jalali !
Votre nom est composé de 11 lettres

3. Ecrire un programme 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) Utiliser les fonctions spéciales de <string.h>.
b) Utiliser uniquement les fonctions gets et puts.
155 156

28
 Les chaînes de caractères Les chaînes de caractères

/*************** Exercice 1***************/ /*************** Exercice 2***************/

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

int main() int main()

{ {
char Chaine[100]; char mot[100], copie[100];

printf("Saisir une chaine à renverser"); printf(" Saisir le mot à vérifier si palindrome:\n");

gets(Chaine); gets(mot);

strrev(Chaine); strcpy(copie,mot);
strrev(copie);
printf(" La chaine renversée est \n %s \n", Chaine);
if( strcmp (mot, copie) == 0 )
return 0; printf("Le mot saisi est un palindrome.\n");
} else
printf("Le mot saisi n’est pas un palindrome..\n");

return 0;
157 } 158

29
 Les chaînes de caractères

/*************** Exercice 3***************/

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

int main() strcpy(temp,Chaine1);

{ strcpy(Chaine1,Chaine2);
char Chaine1[100], Chaine2[100], *temp; strcpy(Chaine2,temp);

printf(" Saisir Chaine1\n");

gets(Chaine1);
printf(" Saisir chaine2\n");
gets(Chaine2);
printf("\n Avant Echange\n");
printf(" Chaine1: %s\n",Chaine1);
printf(" Chaine2: %s\n\n",Chaine2);
printf(" Après Echange\n");
printf(" Chaine1: %s\n",Chaine1);
printf(" Chaine2: %s\n\n",Chaine2);
return 0;
}

temp = (char*)malloc(100);

159

30