EXAMEN LANGAGE C ( PROGRAMMATION C ) TEST  09 /XX 2023

EXAMEN + CORRIGE EN LANGAGE C

Examinateur : Mr Joël Yk

Exercice 01 : Question de Cours (7pts)

1. On considère que les déclarations suivantes ont été faites :
   int a;
   char tab[10];

Une expression avec pointeurs (resp. sans pointeurs) vous est donnée, vous devez la réécrire sans (resp. avec) l’usage explicite des pointeurs. (0,25*7)pt
*(&a) ;  *tab ;  *(tab + 0) ; (*tab) + 1 ; &(tab[0]) ; &(tab[i]) ;  ++tab[i] ;

2. Considerons : 1pts

char *p;
p = tab + 1;

• Quelle sera la différence en octets entre les deux adresses tab et p ?
• Même question si tab et p sont déclarés pointer sur des int.

2. Quel est L'opérateur utilisé pour obtenir la valeur à l'adresse stockée dans une variable pointeur ? 0,5pt
3. Quelle sera la sortie du programme ? int main() { int i=3, *j, k ; j = &i ; printf("%d\n", i* (*j)*i+(*j)) ; return 0 ; } 0,5pt
4. Quel est le rôle de exit(0), continue, break, void dans un programme C. (0,25*4)pt

Exercice 02 : Occupation de la memoire (5pts)

Il est demandé dans cet exercice de représenter en mémoire les données déclarées dans un
programme, ainsi que leurs différentes valeurs, à un moment donné de l’exécution. Pour cela,
vous représenterez l’occupation des données en mémoire dans un tableau à 3 colonnes comme
montré ci-dessous :

Pour déterminer les adresses, on fera les approximations suivantes :
– les données sont réservées en mémoire dans l’ordre de leur déclaration
– la première adresse démarre à 10001
– l’architecture est 32 bits
Le programme est donné ci-dessous. Notez que le programme fait une utilisation abusive des
pointeurs, l’objectif étant simplement de vous familiariser avec la syntaxe et la sémantique des
instructions manipulant des pointeurs.
#include <stdlib.h>
#include <stdio.h>
int main()
{
int a = 10;
int b = 5;
int tab[3] = {1,2,3};
int *p_int;
 

Problème :  9pts(3+3+3)

Nous voulons écrire un programme qui, étant donné un tableau d’entiers déjà initialisé, demande à l’utilisateur quel entier chercher et affiche ensuite le nombre d’occurrences de cet entier dans le tableau.
1. Écrire le programme en utilisant l’opérateur [].

2. Écrire le programme en utilisant explicitement les pointeurs pour accéder aux éléments du tableau, c’est-à-dire sans utiliser une variable d’indice.

3. Faire la trace de cette deuxième version. Une ligne sera ajoutée au tableau de trace pour noter l’adresse des variables. Les adresses seront choisies en respectant la même convention que pour l’exercice précédent.

Exercice 01 :

1) ---

(&a) : a, *tab : tab[0], *(tab + 0) : tab[0], (*tab) + 1 : tab[0] + 1, &(tab[0]) : tab,  &(tab[i]) : (tab + i), ++tab[i] : ++(*(tab + i))

2)----

1. Quelle sera la différence en octets entre les deux adresses tab et p ?
Correction. sizeof(char) = 1 octet en C (standard, dépend pas de l’archi)
2. Même question si tab et p sont déclarés pointer sur des int ?
Correction. sizeof(int) = 4 octet sur PC 32 bits, Leur dire que l’on peut faire la diffe-
rence entre pointeurs. Pas dit en cours. L’exo s’y prete bien.

3)

Exercice 2 :

/* représenter l’occupation mémoire */

---------------------------------------------------------------------------

--------------------------------------------------------------------

Probleme : 

1) 

1. Écrire le programme en utilisant l’opérateur [].
Correction.
#include <stdlib.h> /* EXIT_SUCCESS */
#include <stdio.h> /* printf */
#define TAILLE 4 /* taille du tableau utilisateur */
/* declaration de fonctions utilisateurs */
int main()
{
int tab[TAILLE] = {-1,3,3,2}; /* tableau a initialiser par l’utilisateur */
int elt; /* l’elt a chercher */
int nb_occ = 0; /* le nombre d’occurrences de elt dans tab */
int i; /* var. de boucle */
/* saisie de l’entier à chercher */
printf("Compte le nombre d’occurrences de quel entier ?\n");
scanf("%d",&elt);
/* compte le nombre d’occurrences */
for(i = 0;i < TAILLE;i = i + 1) /* chaque case du tableau */
{
if(tab[i] == elt) /* trouvé */
{
/* un de plus */
nb_occ = nb_occ + 1;
}
}
/* i >= TAILLE */
/* affiche résultats */
printf("Il y a %d occurrences de %d dans le tableau.\n",nb_occ,elt);
return EXIT_SUCCESS;
}

2)

#include <stdlib.h> /* EXIT_SUCCESS */
2 #include <stdio.h> /* printf */
3
4 #define TAILLE 4 /* taille du tableau utilisateur */
5
6 int main()
7 {
8 int tab[TAILLE] = {-1,3,3,2}; /* tableau a initialiser par l’utilisateur *
9 int elt; /* l’elt a chercher */
10 int nb_occ = 0; /* le nombre d’occurrences de elt dans tab */
11 int *p_int; /* var. de boucle */
12
13 /* représentation de l’occupation mémoire */
14
15 /* saisie de l’entier à chercher */
16 printf("Compte le nombre d’occurrences de quel entier ?\n");
17 scanf("%d",&elt);
18
19 /* compte le nombre d’occurrences */
20 for(p_int = tab;p_int < (tab + TAILLE);p_int = p_int + 1) /* chaque case d
21 {
22 if(*p_int == elt) /* trouvé */
23 {
24 /* un de plus */
25 nb_occ = nb_occ + 1;
26 }
27 }
28 /* p_int >= tab + TAILLE */
29
30 /* affiche résultats */
31 printf("Il y a %d occurrences de %d dans le tableau.\n",nb_occ,elt);
32
33 return EXIT_SUCCESS;
34 }

3)----------