TP ALGO 2
USTHB
_______________________________________________________________________________________________
Les chaines de caractères
Le type char :
Permet de stocker UN caractère. Nous pouvons utiliser « scanf et printf » pour lire et écrire un caractère en
utilisant le format « %c ». Cependant, les fonctions « getchar et putchar » sont spécifiques aux caractères.
Elles s’utilisent sans formatage.
Exemple 1:
#include <stdio.h>
main()
{
char x = ’A’ , y, z ;
printf("Donner les valeurs de y et de z:\n") ; scanf("%c", &y) ;
z = getchar() ; z = getchar() ;
printf("x = %c, y = %c et z = ",x,y) ; putchar(z);
system("pause");
}
Déclaration de chaine de caractères :
En langage C, une chaîne de caractères est un tableau de char, dont le dernier élément est ‘\0’.
char Nom_de_la_chaine[Nombre_d_elements] ;
Le nombre maximum de caractères que peut comporter la chaîne est égal au nombre d'éléments du tableau
moins un, car un élément est réservé au ‘\0’.
Le format utilisé pour lire et écrire une chaine de caractère avec « scanf et printf » est « %s ». Des fonctions
conçues pour les chaines de caractères existent (comme pour les caractères) : gets(chaine) et puts(chaine).
Exemple 2:
#include<stdio.h>
#include<stdlib.h>
main()
{
char nom[20], prenom[20], ville[25] ;
printf ("quelle est votre ville : ") ;
gets(ville);
printf ("donnez votre nom et votre prénom : ") ;
scanf ("%s %s", nom, prenom) ;
printf ("bonjour cher %s %s\n", prenom, nom);
printf("vous habitez au ");
puts(ville) ;
system("pause");
}
Le caractère de fin de chaîne ‘\0’ est généré automatiquement par toutes les fonctions de lecture.
A.Dahmane
1
TP ALGO 2
USTHB
_______________________________________________________________________________________________
Initialisation :
Nous pouvons initialiser une chaine de caractères de plusieurs manières,
char ch[20] = "bonjour" ;
char ch[20] = { 'b','o','n','j','o','u','r','\0'};
char ch[] = "bonjour" ;
Quelques fonctions de manipulation de chaînes :
La bibliothèque string.h contient plusieurs fonctions de manipulation de chaines de caractères. Parmi elles :
- La fonction strlen(ch) fournit en résultat la longueur d’une chaîne.
- La fonction strcat(ch1,ch2) recopie la seconde chaîne ch2 à la suite de la première ch1.
- La fonction strcmp(ch1, ch2) compare deux chaînes et fournit une valeur entière positive si
ch1>ch2, nulle si ch1=ch2 et négative si ch1<ch2.
- La fonction strcpy(destin, source) recopie la chaîne source dans l’emplacement d’adresse destin.
Exercices :
1) écrivez un programme qui lit au clavier un mot (d'au plus 30 caractères) et qui compte et affiche le
nombre de lettres du mot.
#include<stdio.h>
#include<stdlib.h>
main()
{
int i=0;
char mot[31];
printf("Entrez un mot : ") ;
scanf("%s",mot);
while(mot[i]!= '\0')
i++;
printf("%d",i);
system("pause");
}
2) Ecrire un programme qui lit au clavier un mot (d'au plus 30 caractères) et qui l'affiche à l'envers.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
main()
{
int i=0,t; char mot[31] ;
printf("Entrez un mot : ") ;
scanf("%s",mot);
t=strlen(mot);
for(i=t-1;i>=0;i--)
printf("%c",mot[i]);
system("pause");
}
A.Dahmane
2
TP ALGO 2
USTHB
_______________________________________________________________________________________________
3) Ecrire un programme qui prend une chaîne en majuscules et qui la convertit en minuscules.
Remarque :
le code ASCII des caractères alphabétiques en minuscules est compris entre 97 (a) et 122 (z).
le code ASCII des caractères alphabétiques en majuscules est compris entre 65 (A) et 90 (Z).
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
main()
{
int i=0,t;
char chaine[255];
gets(chaine);
t=strlen(chaine);
for(i=0;i<t;i++)
{
if((chaine[i]<=90) && (chaine[i]>=65))
chaine[i]=chaine[i]+32;
}
puts(chaine);
system("pause");
}
A.Dahmane
3
TP ALGO 2
USTHB
_______________________________________________________________________________________________
Les structures
Les structures (appelées enregistrements en algorithmique) permettent de rassembler des éléments de type
différent. Les objets contenus dans la structure sont appelés champs de la structure.
Déclaration :
struct Nom_Structure
{
type_champ1 Nom_Champ1; type_champ2 Nom_Champ2; type_champ3 Nom_Champ3; ...
};
Définition des variables structurées
struct Nom_Structure Var1, Var2, Var3, ...;
Nom_Structure est le nom d’une structure préalablement déclarée. Il est possible, aussi, de déclarer un
tableau de structure :
struct Nom_Structure Nom_Tableau[Nb_Elements];
Accès aux champs d'une variable structurée
Pour accéder aux champs d'une structure on utilise l'opérateur de champ (un simple point) placé entre le nom
de la variable structurée que l'on a défini et le nom du champ :
Var.Nom_Champ;
Exemple
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
main()
{
struct Personne{
int age;
char nom[25];
char prenom[25];
};
struct Personne UnePersonne, UnGroupe[10] ;
UnePersonne.age =18 ;
strcpy(UnGroupe[0].nom,"Ali");
puts(UnGroupe[0].nom);
printf("age:%d",UnePersonne.age);
system("pause");
}
A.Dahmane
4
TP ALGO 2
USTHB
_______________________________________________________________________________________________
Exercice :
- Définir la structure etudiant (nom, prenom, age, moyenne) et écrire un programme pour saisir les
informations d’un étudiant.
- Ecrire un programme pour saisir un ensemble d’étudiants (80 au maximum) en demandant à l’utilisateur
s’il veut continuer la saisie.
#include<stdio.h>
main()
{
struct Etudiant{ char nom[25];
char prenom[25];
int age;
float moyenne; };
struct Etudiant UnEtudiant, Classe[80] ;
int i = 0; char reponse;
printf("Voulez vous saisir un étudiant ? (O/N)");
scanf("%c",&reponse);
while(((reponse == 'O') || (reponse == 'o')) && (i < 80))
{
printf("Age :");
scanf("%d",&Classe[i].age);
printf("Nom :");
scanf("%s",&Classe[i].nom);
printf("Prénom :");
scanf("%s",&Classe[i].prenom);
printf("Moyenne :");
scanf("%f",&Classe[i].moyenne);
i++;
printf("Voulez vous saisir un étudiant ? (O/N)");
scanf("%c",&reponse); // prend le dernier caractère saisi (entrée)
scanf("%c",&reponse);
//prend la réponse de l’utilisateur
}
}
A.Dahmane
5
TP ALGO 2
USTHB
_______________________________________________________________________________________________
Les fichiers
Un fichier désigne un ensemble d'informations situé sur une ''mémoire de masse'' telle que le disque ou la
disquette. Il est possible d’y sauvegarder des données même après l’arrêt du programme.
Déclaration d’un fichier :
FILE *VarFichier ;
VarFichier est un pointeur vers la variable FILE (fichier).
Ouverture d’un fichier :
VarFichier = fopen(char *NomFichier, char *mode) ;
Le premier argument est le nom du fichier. Ce nom pourra comporter les informations chemin, répertoire,...
permettant de préciser l'endroit où se trouve le fichier. Le deuxième argument est le mode d’ouverture du
fichier :
w = écriture, (si le fichier n’existe pas il est créé, sinon son contenu est effacé)
r = lecture, (le fichier doit exister)
a = ajout en fin de fichier (si le fichier n’existe pas il est créé)
Fermeture d’un fichier :
fclose(VarFichier) ;
Lire à partir d’un fichier:
Deux fonctions peuvent être utilisées :
fgets(char *chaine, int max, FILE *fic)
Lit une chaîne de caractères sur le fichier fic et la stocke dans la chaîne chaine. Elle lit au maximum max - 1
caractères, elle s'arrête dès qu'elle rencontre un caractère de passage à la ligne et place un \0 à la fin de la
chaîne. Lorsqu'elle rencontre la fin de fichier, elle retourne la chaîne NULL.
fscanf(FILE *fic, char *format, adr_var_1, adr_var_2, ...)
Lit les données à partir de fic et les stocke selon le format défini par la chaîne format dans les variables
adr_var_ passées par adresse.
Exemple
#include<stdio.h>
#include<stdlib.h>
main()
{
FILE * f;
int A=0;
char B[50];
f = fopen("fich.txt","r");
A.Dahmane
6
TP ALGO 2
USTHB
_______________________________________________________________________________________________
if(f = = NULL)
{
printf("Impossible d'ouvrir le fichier \n");
}
else
{
printf("ouvert\n");
while(!feof(f)) // Tant que !fin de fichier
{
fscanf(f,"%d",&A);
printf("A= %d \n",A);
}
}
system("pause");
}
Ecrire sur un fichier:
fputs(char *chaine, FILE *fic)
écrit la chaîne de caractères chaine sur le fichier fic.
fprintf(FILE *fic, char *format, var_1, var_2, ...)
écrit les données var_ dans le fichier fic en respectant le format spécifié par la chaîne format.
Exemple
#include<stdio.h>
#include<stdlib.h>
main()
{
FILE * f;
char B[50]="ABCD";
f = fopen("fich.txt","a");
if(f = = NULL){ printf("Impossible d'ouvrir le fichier \n"); }
else
{
fprintf(f,"%d %s \n",1,"XYZ");
fputs(B,f);
}
}
A.Dahmane
7
TP ALGO 2
USTHB
_______________________________________________________________________________________________
Les structures chainées
Déclaration:
struct nom_element
{
// données
…
// chainage
struct nom_element *pointeur_suivant;
};
Nous pouvons déclarer la liste de deux manières:
struct nom_element *nom_tete ;
ou bien en remplaçant struct nom_element * par un type en utilisant typedef :
typedef struct nom_element * nom_type ;
nom_type nom_tete ;
Ajout d’un élément :
struct nom_element* nom_pointeur ;
nom_pointeur = malloc(sizeof(struct nom_element));
Exemple :
#include<stdio.h>
#include<stdlib.h>
void main()
{
int val;
char reponse;
struct element
{
int x;
struct element *suivant;
};
struct element * tete, *p;
// remplir la liste
printf("Donnez la première valeur de la liste : ");
scanf("%d",&val);
p = malloc(sizeof(struct element));
p->x =val;
p->suivant = NULL;
tete = p;
A.Dahmane
8
TP ALGO 2
USTHB
_______________________________________________________________________________________________
printf("Voulez vous ajouter un élément à la liste ? o/n : ");
scanf("%c",&reponse);
scanf("%c",&reponse);
while(reponse = = 'o')
{
p->suivant = malloc(sizeof(struct element));
p=p->suivant;
printf("Donnez la valeur de la liste: ");
scanf("%d",&val);
p->x =val;
p->suivant = NULL;
printf("Voulez vous ajouter un élément à la liste ? o/n: ");
scanf("%c",&reponse);
scanf("%c",&reponse);
}
// parcourir la liste et afficher ses éléments
p=tete;
while (p != NULL)
{
printf("%d\n",p->x);
p = p->suivant;
}
system("pause");
}
Suppression d’un élément :
Supprimer l’élément pCourant, sachant que nous avons l’élément précédent pPrecedent,
pPrecedent-> suivant = pCourant -> suivant ;
free(pCourant) ;
Insertion d’un élément :
Insérer un élément entre pCourant et pPrecedent,
pNew = malloc(sizeof(liste)) ;
pPrecedent->suivant = pNew;
pNew->suivant = pCourant;
Exercice:
Soit une liste d’entiers L, écrire un programme qui demande à l’utilisateur de créer la liste, puis écrire les
fonctions suivantes :
a) La recherche d’une valeur val donnée et retourne son adresse.
b) La suppression de l’élément qui se trouve à une position donnée k.
c) L’insertion d’une valeur val donnée à une position donnée k.
A.Dahmane
9
