ENSA-FES

Pr.Said Hraoui
TP: Structure de données en langage C
* Séances en présentielles
* Séances à distance
Plateforme utilisée pour l’enseignement à distance:
* Zoom;
* Google Classroom

said.hraoui@usmba.ac.ma Année Universitaire : 2020/2021

 Série N°1:
Rappel du langage C : Tableaux
Structure de base du programme C // Commentaire d'une ligne
/* Commentaire sur
• Section de document. plusieurs lignes */
// Utilisation de bibliothèques
• Section préprocesseur / définition des #include <stdlib.h>
#include <stdio.h>
constantes. // Définition d'une fonction
• Section de définition. // Valeur de retour, nom, argument, corps
float f(float x, int n) {
• Section de déclaration variables globales. // Déclaration de variable
int j;
• Section de déclaration de fonction. // Déclaration de variable avec initialisation
• Fonction principale main. float r = 1;
// Structure de contrôle : boucle
• Section de fonction définie par l'utilisateur. for(j = 0; j < abs(n); j++) {
r = r * x;
}
// Structure de contrôle : branchement conditionnel if(n < 0)
{
// Valeur de retour de la fonction return (1.0 / r); } else { return r; } } // Fonction
principale, où commence l'exécution.
int main() {
// appel des fonctions printf et f
printf("%f\n",f(2,-5));
}

S.Hraoui
 Série N°1: Exercice 1
Rappel du langage C : Tableaux

S.Hraoui
Les tableaux sont une suite de variables de même type, situées dans un espace contigu en mémoire.
Tableau de taille 6
Tab[0] Tab[1] Tab[2] Tab[3] Tab[4] Tab[5]

Indices 0 1 2 3 4 5

L'accès aux éléments d'un tableau se fait par indice (compris entre 0 et n-1).

Déclaration d’un tableau:

TypeDonnées nomTableau[tailleTableau];
Exemple
int tab[100];

On accède aux éléments d'un tableau par leurs indices.

 Série N°1: Exercice 1
Rappel du langage C : Tableaux
La recherche linéaire ou séquentielle en langage est un algorithme qui permet de trouver une
valeur dans une liste, en l'occurrence un tableau. Les tableaux sont une suite de variables de
même type, situées dans un espace contigu en mémoire.
Le programme permet de savoir si un nombre est présent dans un tableau. S'il est présent, alors
à quel endroit on le retrouve.

S.Hraoui
 Série N°1: Exercice 1_Question1
Rappel du langage C : Tableaux
#include <stdio.h>
#include <stdlib.h>
int main()
{
int tab[]={12,15,13,10,8,9,13,14}, n, i, x=0;
printf("donner un entier \n");
scanf("%d", &n);
for (i = 0; i<8; i++)
{
if (n == tab[i])
{
x++;
}
}
if (x == 0){
printf("non");
}
else{
printf("oui");
}
return 0;
}
 Série N°1: Exercice 1
Rappel du langage C : Tableaux
#include <stdio.h>
#include <stdlib.h>
int main()
{
int array[100], V_chercher, c, n;
printf("Entrez le nombre d'elements dans le tableau\n");
scanf("%d", &n);
printf("Entrer %d entier(s)\n", n);
for (c = 0; c < n; c++)
scanf("%d", &array[c]);
printf("Entrez le nombre recherche\n");
scanf("%d", & V_chercher);
for (c = 0; c < n; c++)
{
if (array[c] == V_chercher) /* si l’element est trouve */
{
printf("%d est present a la position %d.\n", V_chercher, c+1);
break;
}
}
if (c == n)
printf("%d n'est present dans le tableau'.\n", V_chercher);
return 0;
} S.Hraoui
 Série N°1: Exercice 2
Rappel du langage C : Tableaux

1. Saisir un tableau;
2. Vous allez ajouter un élément dans ce tableau à une position avec vérification de la validité de
la valeur de l’indice (valeur entre 0 et n-1 ou n est la taille de tableau) ;
3. Afficher le tableau initial;
4. Afficher le tableau après insertion de l’élément ajouté.

S.Hraoui
 Série N°1: Exercice 2
Rappel du langage C : Tableaux
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i;
int nombre;
int indice;
int N=8;
int tab[]={12, 15, 13, 10, 8, 9, 13, 14}; /* declaration et initialisation du tableau */
printf("Saisir le nombre a inserer\n");
scanf("%d",&nombre);
printf("Saisir un indice\n");
scanf("%d",&indice);
if(indice>=0 && indice<N)
{
printf("tableau avant insersion\n");
for(i=0;i<N;i++)
{
printf("%d \t",tab[i]);
}
tab[indice]=nombre;
printf("\n tableau apres insersion");
for(i=0;i<N;i++)
{
printf("%d \t",tab[i]);
}
}
else
{
printf("indice non valide\n");
}
return 0;
}
 Série N°1: Exercice 3
Rappel du langage C : Tableaux

1. Saisir les éléments d’un tableau de dimension N ayant des valeurs nuls;
2. Afficher les éléments de ce tableau;
3. Supprimer les éléments ayant la valeur égale à 0;
4. Afficher le tableau modifier.

S.Hraoui
#include <stdio.h>
int main()
{
/* Déclarations */
int T[50]; /* tableau de données */
int N; /* dimension du tableau */
int k,j; /* indices */
/* Saisie des données */
printf("Tableau de dimension inferieur à MAX: ");
scanf("%d", &N );
for (k=0; k<N; k++)
{
printf("Elément %d : ", k);
scanf("%d", &T[k]);
}
/* Affichage du tableau */
printf("Tableau donné :\n");
for (k=0; k<N; k++)
printf("%d \t", T[k]);
// printf("\n");
/* Effacer les zéros et comprimer : */
/* Copier tous les éléments de k vers j et augmenter j pour les éléments non nuls. */
for (k=0, j=0 ; k<N ; k++) { T[j] = T[k]; if (T[k]) j++; }
/* Nouvelle dimension du tableau */
N = j;
/* Edition des résultats */ printf("\n Tableau résultat :\n");
for (k=0; k<N; k++)
printf("%d \t", T[k]);
//printf("\n");
return 0;
}
 Série N°1: Exercice 4
Rappel du langage C : Tableaux

1. Définir le nombre de ligne et le nombre de colonne d’un tableau à 2 dimensions;

2. Saisir les éléments de ce tableau;
3. Afficher les éléments de ce tableau;
4. Calculer la somme de tout ces éléments;
5. Afficher cette somme.

S.Hraoui
 Série N°1: Exercice 4
Rappel du langage C : Tableaux

Un tableau d'entiers positifs à deux dimensions (3 lignes, 4 colonnes) se définira avec la syntaxe suivante :
int Tableau [3][4]
On peut représenter un tel tableau de la manière suivante :

S.Hraoui
#include <stdio.h>
int main()
{
/* Déclarations */
int T[50][50]; /* tableau donné */
int L, C; /* dimensions */
int I, J; /* indices courants */
long SOM; /* somme des éléments - type long à cause */
/* de la grandeur prévisible du résultat. */

/* Saisie des données */

printf("Nombre de lignes (max.50) : ");
scanf("%d", &L );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &C );
for (I=0; I<L; I++)
for (J=0; J<C; J++)
{
printf("Elément[%d][%d] : ",I,J);
scanf("%d", &T[I][J]);
}
/* Affichage du tableau */
printf("Tableau donné :\n");
for (I=0; I<L; I++)
{
for (J=0; J<C; J++)
printf("%7d", T[I][J]);
/*%7d indique que la chaîne doit comporter au minimum 7 caractères.
Des espaces sont insérés à gauche si nécessaire*/
printf("\n");
}
/* Calcul de la somme */
for (SOM=0, I=0; I<L; I++)
for (J=0; J<C; J++)
SOM += T[I][J];
/* Edition du résultat */
printf("Somme des éléments : %ld\n", SOM);
return 0;
}
 Série N°2: Exercice 1
Rappel du langage C : Pointeur

On appelle une Lvalue (Left Value) tout objet pouvant être

place à gauche d’un operateur d’affectation.
Une Lvalue est caractérisée par:
• Son adresse mémoire à partir de laquelle l’objet est stocké
• Sa valeur: ce qui est stockée à cette adresse.

Remarque : Deux variables différentes ont des adresses

différentes. L’affectation i=j, n’opère que sur les valeurs des
variables.
Un pointeur est une variable spéciale qui stocke l'adresse
d'une autre variable. Chaque pointeur est limité à un type de
données c.à. qu’un pointeur est toujours typé.

On déclare un pointeur par l'instruction :

type *nom-du-pointeur;//* astérisque(opérateur unaire
d’indirection
int a = 10;
int *p;
p = &a;//& :permet d’obtenir l’adresse d’un objet
 Série N°2: Exercice 1
Rappel du langage C : Pointeur
• L’initialisation d’un pointeur peut être réalisée de 3 façons:
1. Avec la valeur NULL(Pointeur NULL):
int *ptr=NULL;
2. Avec l’adresse d’une des variables déclarées :
int var;
int *ptr=&var;
3. par allocation dynamique:
int *ptr =malloc(sizeof(int));

• Un pointeur pointe sur un emplacement en mémoire et

sert donc à stocker l'adresse des variables. Donc, quand
on définit un pointeur de pointeur. Le premier
pointeur est utilisé pour stocker l'adresse de la variable.
Et le deuxième pointeur est utilisé pour stocker l'adresse
du premier pointeur. C'est pourquoi ils sont également
connus comme des doubles pointeurs.
 Série N°2: Exercice 2 et 3
Rappel du langage C : Pointeur
 Série N°2: Exercice 4 et 5
Rappel du langage C : Pointeur

L' allocation de mémoire dynamique en C peut être définie

comme une procédure dans laquelle la taille d'une structure de
données (par exemple un tableau) est modifiée pendant
l'exécution. Pour cela C utilise 4 fonctions définies sous
le fichier d'en-tête <stdlib.h> .
1. malloc ()
2. calloc ()
3. libre()
4. réallouer ()
La méthode «malloc» est utilisée pour allouer dynamiquement
un seul grand bloc de mémoire avec la taille spécifiée
Exemple:
ptr = (int *) malloc (100 * sizeof (int));
La taille de int étant de 4 octets, cette instruction allouera
400 octets de mémoire. Et, le pointeur ptr contient l'adresse
du premier octet dans la mémoire allouée.
NB: La méthode free () est utilisée chaque fois que l'allocation
de mémoire dynamique a lieu,
 Série N°3:
Rappel du langage C : Listes chaînées simples

Définition :
En langage C, une structure est un type de données défini par l'utilisateur
qui nous permet de combiner un ensemble de données de différents types.
Chaque composant de la structure est appelé champ (ou encore attribut) et
est accessible par un nom (identificateur). Dans la structure, les données
sont stockées sous forme d' enregistrements .
L'ensemble est accessible par le nom de la structure.
Struct :Le mot-clé est utilisé pour définir une structure.

Déclaration d’une structure se fait par:

struct Nom_Structure { struct Etudiant {

type_champ1 Nom_Champ1; int Age;
type_champ2 Nom_Champ2; char Sexe;
type_champ3 Nom_Champ3; char Nom[12];
struct addresse float MoyenneScolaire;
{ type_champ4 Nom_Champ4; struct AutreStructure StructBis;
char nom[50]; type_champ5 Nom_Champ5; /* en considérant que la structure
char route[100]; AutreStructure est définie */
...
char ville[50]; };
char pays[20]; };
int pin;
};
 Série N°3: Solution
Rappel du langage C : Listes chaînées simples

https://classroom.google.com/c/NzMwNzAxMTg1MDBa/m/NzMxMDAzNzc0NDFa/details