EXAMEN LANGAGE C ( PROGRAMMATION C ) TEST  14 /XX annee acaDEMIQUE 2024

EXAMEN + CORRIGE EN LANGAGE C

EXERCICE 1 : structure de donnee ( 12 PTS)

A-On suppose que tab est déclaré comme suit : int tab[4][5]

1) Schématiser la déclaration « int tab[4][5]»

2) Quelle est la nature du contenu de tab ?

2) Que désigne tab[i][j], 0<=i<4 et 0<=j<5 ?

3) Que désigne tab[i] ?

4) Que désigne (tab[i]+j), 0<=i<4 et 0<=j<5 ?

5) Que désigne *(tab[i]+j) ?

6) Peut on modifier la valeur de tab[i][j] ?

7) Que désigne &(tab[i][j]) ?

8)  Peut on modifier la valeur de tab[i]  ?

9) Peut on modifier la valeur de tab ?
B- On suppose que tab est déclaré comme suit : int tab[4][5]

10) Donner deux syntaxes pour désigner l'adresse de début de la ligne i (c'est à dire l'adresse de la première case de la ligne i).

11) Donner deux syntaxes différentes pour désigner l'adresse  de la case située à l'intersection de la ligne i et de la colonne j de tab.

12) Donner deux syntaxes différentes pour désigner le contenu  de la case située à l'intersection de la ligne i et de la colonne j de tab.

C-Allocation Dynamique :

1) Ecrire un programme qui lit la valeur d'un entier n au clavier, crée dynamiquement un vecteur de taille n et initialise ses composantes 0. On rappelle que malloc retourne un pointeur (char*) sur un tableau de caractères. Ici, il faut faire un cast pour le convertir en un pointeur (int*) sur  un tableau de int.

2) Donner la routine permettant un espace mémoire obtenu par allocation dynamique.

EXERCICE 2 : 5pts

1) Soit le morceau de programme suivant :
int a;
int *pa;
double x;
int **p;
a=8;
pa=&a;
x=3.14159;
p=&pa;
**p=281;
En supposant que la mémoire soit structurée en octets, que les entiers soient codés sur 4 octets, les pointeurs sur 4 octets et que la zone de mémoire automatique soit située en début dʼexécution à lʼadresse 2004, représentez la mémoire finale de ce programme

2) Trouvez les erreurs dans les suites d'instruction suivantes:

a) int *p,X=34; *p =x;
b) int x = 17, *p= x; *p= 17;

c) double *q; int x = 17, *p; p=&x; q =p;
d) int x, *p; &x =p ;
 

3) Ecrire un programme qui lit deux chaines de caractères CHI et CH2 au clavier et supprime la première occurrence de CH2 dans CHI. Utiliser uniquement des pointeurs, une variable logique TROUVE et la fonction strcpy.

4) Schématiser chaque déclaration suivante : int vect[5] ; int tab[4][5] ; char voyelles[6]={'a', 'e',  'i', 'o', 'u', 'y'} ; int matrice2D[2][2]={1, 2, 3, 4}

.

EXERCICE 4 : 3pts

 Produit matrice-vecteur : Ecrire un programme qui lit les coefficients d'une matrice carrée A d'ordre N=10 et d'un vecteur X de taille N et affiche le résultat du produit matrice-vecteur AX.

 A-1) Schématiser la déclaration « int tab[4][5] » -->
int tab[4][5];

 A-2) Quelle est la nature du contenu de tab ? -->
// C'est un tableau à deux dimensions de type int, avec 4 lignes et 5 colonnes.

 A-3) Que désigne tab[i][j], 0<=i<4 et 0<=j<5 ? -->
// Cela désigne l'élément situé à la ligne i et la colonne j du tableau.

 A-4) Que désigne tab[i] ? -->
// Cela désigne la i-ème ligne du tableau.

 A-5) Que désigne (tab[i]+j), 0<=i<4 et 0<=j<5 ? -->
// Cela désigne l'adresse mémoire de l'élément à la ligne i et la colonne j.

A-6) Que désigne *(tab[i]+j) ? -->
// Cela désigne la valeur de l'élément à la ligne i et la colonne j.

 A-7) Peut-on modifier la valeur de tab[i][j] ? -->
// Oui, on peut modifier la valeur de tab[i][j].

 A-8) Que désigne &(tab[i][j]) ? -->
// Cela désigne l'adresse mémoire de l'élément à la ligne i et la colonne j.

 A-9) Peut-on modifier la valeur de tab[i] ? -->
// Oui, on peut modifier la valeur de tab[i].

 B-10) Donner deux syntaxes pour désigner l'adresse de début de la ligne i -->
int *ptr1 = &tab[i][0];
int *ptr2 = tab[i];


int *ptr3 = &tab[i][j];
int *ptr4 = tab[i] + j;


int val1 = tab[i][j];
int val2 = *(tab[i] + j);

// C-1) Ecrire un programme qui lit la valeur d'un entier n au clavier, crée dynamiquement un vecteur de taille n et initialise ses composantes à 0 -->
#include
#include

int main() {
    int n;
    printf("Entrer la taille du vecteur : ");
    scanf("%d", &n);

    // Allocation dynamique d'un vecteur de taille n et initialisation à 0
    int *vecteur = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; ++i) {
        vecteur[i] = 0;
    }

    // Reste du programme ici...

    // Libération de la mémoire allouée dynamiquement
    free(vecteur);

    return 0;
}

 C-2) Donner la routine permettant un espace mémoire obtenu par allocation dynamique -->
// La routine est la libération de la mémoire avec la fonction free().

 EXERCICE 2 -->

 1) Soit le morceau de programme suivant -->
int a;
int *pa;
double x;
int **p;
a=8;
pa=&a;
x=3.14159;
p=&pa;
**p=281;

 En supposant que la mémoire soit structurée en octets, que les entiers soient codés sur 4 octets, les pointeurs sur 4 octets et que la zone de mémoire automatique soit située en début dʼexécution à lʼadresse 2004, représentez la mémoire finale de ce programme -->
// La représentation détaillée de la mémoire n'est pas possible ici, mais voici une représentation simplifiée :
// Adresse 2000 : [x] (double)
// Adresse 2004 : [a] (int)
// Adresse 2008 : [pa] (int*)
// Adresse 2012 : [p] (int**)
// La valeur de **p (à l'adresse 2012) est modifiée pour être 281.

2) Trouvez les erreurs dans les suites d'instruction suivantes: -->

 a) int *p,X=34; *p =x; -->
// Il manque l'initialisation du pointeur int *p; et X doit être déclaré comme double.

 b) int x = 17, *p= x; *p= 17; -->
// Le pointeur p doit être déclaré comme int *p; et il doit être initialisé avec l'adresse de x (&x).

 c) double *q; int x = 17, *p; p=&x; q =p; -->
// Le pointeur q doit être initialisé avec l'adresse de x (&x).

d) int x, *p; &x =p ; -->
// La syntaxe est incorrecte. &x est une adresse et ne peut pas être utilisé pour assigner une valeur à un pointeur.

 3) Ecrire un programme qui lit deux chaines de caractères CH1 et CH2 au clavier et supprime la première occurrence de CH2 dans CH1. Utiliser uniquement des pointeurs, une variable logique TROUVE et la fonction strcpy. -->
#include
#include

#include 
#include 

int main() {
    /* Déclarations */
    char CH1[101], CH2[101]; /* chaînes données */
    char *P1, *P2; /* pointeurs d'aide dans CH1 et CH2 */
    int TROUVE; /* indicateur logique: vrai, si le caractère */

    /* actuel dans CH1 a été trouvé dans CH2. */

    /* Saisie des données */
    printf("Entrez la chaîne à transformer (max. 100 caractères):\n");
    gets(CH1);

    printf("Entrez la chaîne à supprimer (max. 100 caractères) :\n");
    gets(CH2);

    /* Rechercher CH2 dans CH1: */

    /* L'expression P2-CH2 est utilisée pour déterminer l'indice */

    /* de P2 dans CH2. On pourrait aussi résoudre le problème à */

    /* l'aide d'un troisième pointeur P3 parcourant CH1. */

    TROUVE = 0;

    for (P1 = CH1; *P1 && !TROUVE; P1++) {
        for (P2 = CH2; *P2 == *(P1 + (P2 - CH2)); P2++) {
            if (!*P2)
                TROUVE = 1;
        }
    }

    /* A la fin de la boucle, P1 est incrémenté, donc */
    P1--;

    /* Si CH2 se trouve dans CH1, alors P1 indique la position */

    /* de la première occurrence de CH2 dans CH1 et P2 pointe à */

    /* la fin de CH2. (P2-CH2) est alors la longueur de CH2. */

    if (TROUVE)
        strcpy(P1, P1 + (P2 - CH2));

    /* Affichage du résultat */
    printf("Chaine résultat: \"%s\" \n", CH1);

    return 0;
}

 

 4) Schématiser chaque déclaration suivante : -->
int vect[5];
int tab[4][5];
char voyelles[6]={'a', 'e', 'i', 'o', 'u', 'y'};
int matrice2D[2][2]={1, 2, 3, 4};

exercice 4 :
#include 

#define N 10

void produitMatriceVecteur(int matrice[N][N], int vecteur[N], int resultat[N]) {
    for (int i = 0; i < N; ++i) {
        resultat[i] = 0;
        for (int j = 0; j < N; ++j) {
            resultat[i] += matrice[i][j] * vecteur[j];
        }
    }
}


int main() {
    int matrice[N][N];
    int vecteur[N];
    int resultat[N];

    // Entrée de la matrice A
    printf("Entrer les coefficients de la matrice A (%d x %d):\n", N, N);
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            printf("A[%d][%d] : ", i, j);
            scanf("%d", &matrice[i][j]);
        }
    }

    // Entrée du vecteur X
    printf("Entrer les coefficients du vecteur X (%d éléments):\n", N);
    for (int i = 0; i < N; ++i) {
        printf("X[%d] : ", i);
        scanf("%d", &vecteur[i]);
    }

    // Calcul du produit matrice-vecteur
    produitMatriceVecteur(matrice, vecteur, resultat);

    // Affichage du résultat
    printf("Résultat du produit matrice-vecteur AX :\n");
    for (int i = 0; i < N; ++i) {
        printf("%d\n", resultat[i]);
    }

    return 0;
}