Langage C Avancé. Solutions des Travaux Pratiques : Préparé par : Abdelmajid Dargham 1. Version : Mai 2014

Transcription

1 Solutions des Travaux Pratiques : Langage C Avancé Préparé par : Abdelmajid Dargham 1 Version : Mai Enseignant-chercheur à la Faculté des Sciences, Oujda

2 2 Exercice 1 Solutons des exercices de la série N 1 1. Prototype de la fonction : void quotient_reste_1(int, int); Définition de la fonction : void quotient_reste_1(int x, int y) int q, r; q = 0; /* quotient */ r = x; /* reste */ while(r >= y) q++; r = r - y; printf("quotient = %d, Reste = %d\n", q, r); 2. Prototype de la fonction : int* quotient_reste_2(int, int); Définition de la fonction : int* quotient_reste_2(int x, int y) int* qr; qr = (int*) malloc(sizeof(int) * 2); qr[0] = 0; /* quotient */ qr[1] = x; /* reste */ while(qr[1] >= y) qr[0]++; qr[1] = qr[1] - y; return qr; 3. Prototype de la fonction : void quotient_reste_3(int, int, int*, int*); Définition de la fonction : void quotient_reste_3(int x, int y, int* q, int* r) *q = 0; /* quotient */ *r = x; /* reste */

3 3 while(*r >= y) (*q)++; *r = *r - y; Le programme principal : main() int a, b, q, r; int* qr; printf("valeur de a : "); scanf("%d", &a); printf("valeur de b : "); scanf("%d", &b); /* Appel de quotient_reste_1 */ quotient_reste_1(a, b); /* Appel de quotient_reste_2 */ qr = (int*) malloc(sizeof(int) * 2); qr = quotient_reste_2(a, b); printf("quotient = %d, Reste = %d\n", qr[0], qr[1]); /* Appel de quotient_reste_3 */ quotient_reste_3(a, b, &q, &r); printf("quotient = %d, Reste = %d\n", q, r); getch(); Exercice 2 1. Le programme précédent affichera : j = 0 j = 0 j = 0 j = 0 j = 0 j = 0 j = 0 j = 0 j = 0 j = 0

4 4 La valeur finale de j est 11 Justification : la variable j déclarée dans la ligne 2 est une variable globale (initialisée avec la valeur 11). Elle est allouée une fois pour toute, dans le segment de Données pendant la phase de compilation. la variable j déclarée dans la ligne 8 est une variable locale au bloc de l instruction for (initialisée avec la valeur 0). Elle est ré-alouée et réinitialisée à chaque entrée dans la boucle (à chaque itération) dans le segment de Pile pendant la phase d exécution. L instruction printf (ligne 9) va afficher toujours j = 0 (10 fois). L instruction d incrémentation (j + +) sera exécutée et la valeur de j passera à 1, mais dès que l on quitte le bloc de for, la variable j sera détruite. Après la terminaison de la boucle, la variable j concernée par l instruction printf (ligne 12) est la variable globale déclarée dans la ligne 2. Cette variable n est pas modifiée dans le programme, elle gardera alors sa valeur initiale qui est 11. L affichage produit est alors : La valeur finale de j est Si l on remplace la déclaration int j = 0 ; dans la ligne 8 par static int j = 0 ;, l affichage sera : j = 0 j = 1 j = 2 j = 3 j = 4 j = 5 j = 6 j = 7 j = 8 j = 9 La valeur finale de j est 11 Justification : ce qui a changé c est la déclaration d une variable statique j dans la ligne 8. Cette variable est allouée une fois pour toute, dans le segment de Données pendant la phase de compilation. Elle est aussi initialisée avec la valeur 0. À chaque itération, l instruction printf (ligne 9) affichera la valeur de j, puis l incrémentation de j est effectuée. Comme la variable j est statique, elle gardera toujours sa dernière valeur. D où l affichage : j = 0 j = 1 j = 2

5 5 j = 3 j = 4 j = 5 j = 6 j = 7 j = 8 j = 9 Après la terminaison de la boucle, la variable j concernée par l instruction printf (ligne 12) est la variable globale déclarée dans la ligne 2 (et non pas la variable statique j, car celle-ci n est visible que dans le bloc for). L affichage produit est alors : La valeur finale de j est 11 Exercice 3 1. La macro-fonction : #define DOUBLE(n) ((n) + (n)) 2. Le programme affichera : Le double de n est 14 La valeur finale de n est 9 Justification : la première instruction printf contient le code DOUBLE(n + +). Le pré-processeur effectue alors une expansion du texte DOUBLE(n++) en (n + +) + (n + +). Par suite, la valeur calculée est = 14. L affichage résultant est : Le double de n est 14 Mais, cette instruction causera un effet de bord : la variable n est incrémentée 2 fois. comme la variable n a été incrémenté 2 fois, sa nouvelle valeur est 9, la deuxième instruction printf affiche alors : La valeur finale de n est 9 3. La fonction ordinaire long int doubler 1(long int) : long int doubler1(long int n) return n + n; 4. La fonction en ligne inline long int doubler2(long int) :

6 6 inline long int doubler2(long int n) return n + n; 5. Si l on remplace l appel de la macro-fonction DOUBLE(n++) par l appel doubler1(n++), l affichage produit par le programme est : Le double de n est 14 La valeur finale de n est 8 Justification : la première instruction printf contient maintenant un appel de fonction doubler1(n++). La valeur calculée est 7+7 = 14 et l affichage sera : Le double de n est 14 Après, la variable n est incrémentée une seule fois (n = 8). La deuxième instruction printf affiche donc : La valeur finale de n est 8 6. Si l on remplace l appel de la macro-fonction DOUBLE(n++) par l appel doubler2(n++), l affichage produit par le programme est : Le double de n est 14 La valeur finale de n est 8 Justification : la première instruction printf contient maintenant un appel de fonction doubler2(n + +). Comme elle s agit d une fonction en ligne, l incrémentation dans l appel ne cause pas un effet de bord. La valeur calculée est = 14 et l affichage sera : Le double de n est 14 Après, la variable n est incrémentée une seule fois (n = 8). La deuxième instruction printf affiche donc : La valeur finale de n est 8 7. Programme (complet) pour comparer les temps d exécution des trois fonctions : #include <stdio.h> #include <time.h> #define DOUBLE(n) ((n) + (n)) long int doubler1(long int n)

7 7 return n + n; inline long int doubler2(long int n) return n + n; main() float t1, t2, t; long int n = 7; long int i; long int a; puts("temps d execution de la macro-fonction DOUBLE :"); t1 = clock(); for(i = 0; i < ; i++) a = DOUBLE(n); t2 = clock(); t = (float) (t2 - t1) / CLOCKS_PER_SEC; printf("%f secondes\n", t); puts("temps d execution de la fonction ordinaire doubler1 :"); t1 = clock(); for(i = 0; i < ; i++) a = doubler1(n); t2 = clock(); t = (float) (t2 - t1) / CLOCKS_PER_SEC; printf("%f secondes\n", t); puts("temps d execution de la fonction en ligne doubler2 :"); t1 = clock(); for(i = 0; i < ; i++) a = doubler2(n); t2 = clock(); t = (float) (t2 - t1) / CLOCKS_PER_SEC;

8 8 printf("%f secondes\n", t); getch();

9 9 Exercice 1 Solutons des exercices de la série N 2 1. Fonction récursive qui calcule le quotient de l entier x par l entier y 0 par la méthode des soustractions : int quotient(int x, int y) if(x < y) return 0; return quotient(x - y, y) + 1; 2. Fonction récursive qui calcule la somme des chiffres d un entier x : int somme_chiffres(int x) if(x < 10) return x; return x % 10 + somme_chiffres(x / 10); 3. Fonction récursive qui calcule le produit de deux entiers x et y par la méthode Russe : int produit(int x, int y) if(y == 0) return 0; if(y % 2 == 0) return produit(2 * x; y / 2); return produit(x, y - 1) + x; Exercice 2 1. Fonction récursive qui calcule F (n) : int Fibo1(int n)

10 10 if(n <= 1) return 1; return Fibo1(n - 1) + Fibo1(n - 2); 2. Fonction itérative qui calcule F (n) en utilisant un tableau pour stocker les valeurs de F (i) pour les valeurs de i < n : int Fibo2(int n) if(n <= 1) return 1; int i; int *tab; tab = (int*) malloc(sizeof(int) * (n + 1)); tab[0] = 1; tab[1] = 1; for(i = 2; i <= n; i++) tab[i] = tab[i - 1] + tab[i - 2]; return tab[n]; 3. Fonction itérative qui calcule F (n) sans utiliser aucun tableau : int Fibo3(int n) if(n <= 1) return 1; int i, a, p, c; /* a : terme avant précédent */ /* p : terme précédent */ /* c : terme courant */ a = 1; p = 1; for(i = 2; i <= n; i++) c = p + a;

11 11 a = p; p = c; return c; On peut même utiliser 2 variables seulement : int Fibo4(int n) if(n <= 1) return 1; int i, p, c; /* p : terme précédent */ /* c : terme courant */ p = 1; c = 1; for(i = 2; i <= n; i++) c = c + p; p = c - p; return c; 4. Quelques définitions : Soit A un algorithme qui résout un problème P. Notons n la taille d une donnée d entrée pour l algorithme A (n est une mesure de la taille des paramètres de l algorithme A). Soit D le domaine des valeurs des paramètres de l algorithme A. L efficacité théorique en temps de l algorithme A est une approximation du temps d exécution T A (n) de l algorithme A. Cette approximation théorique est calculée indépendamment de l environnement d exécution de l algorithme A (compilateur utilisé, système d expolitation de la machine, caractéristiques matérielles de la machine,...etc). L approximation du temps d exécution d un algorithme peut être meséurée en se basant sur le nombre des opérations élémentaires (ou fondamentales) de l algorithme A.

12 12 L efficacité théorique en espace de l algorithme A est une approximation de l espace mémoire E A (n) requis pour exécuter l algorithme A. Cette approximation se calcule en mesurant la taille mémoire nécessaire pour faire fonctionner l algorithme A. Applications : calculons l efficacité théorique en temps et en espace des algorithmes Fiboi (i = 1, 2, 3, 4). Nous allons noter : T i (n) : l efficacité théorique en temps d exécution de l algorithme Fiboi. Elle sera mesurée par le nombre d instructions élémentaires : test, affectation, additions, multiplications, soustraction et instruction return. : l efficacité théorique en espace de l algorithme Fiboi. On mesurera la taille en octets des paramètres formels, des variables locales et des retours de la fonction. Analyse de l algorithme Fibo1 : T 1 (n) = 2, si n 1 et T 1 (n) = T 1 (n 1) + T 1 (n 2) + 3, si n 2. On peut résoudre cette équation de récurrence (il s agit d une equation de récurrence linéaire d ordre 2 avec second membre). Pour avoir une idée sur la solution, on va tout simplement minorer T 1 (n) par une fonction exponentielle. Il est clair que : T 1 (n) = 2T 1 (n 2) + T 1 (n 3) + 6 > 2T 1 (n 2) T 1 (n) > 2T 1 (n 2) > 2 2 T 1 (n 4) >... > 2 k T 1 (n 2k) Si n 2k = 2, c est-à-dire k = (n 2)/2, alors : T 1 (n) > 2 (n 2)/2 T 1 (2) = 7 2 (n 2)/2 = 7 2 ( 2) n Par exemple, T 1 (100) est très grand que (trois millions neuf cents quarante miles six cents quarante neuf milliards, six cents soixante treize millions, neuf cents quarante neuf miles cent quatre vignts quatre). E 1 (n) = 2 4 = 8 octets, si n 1 et E 1 (n) = E 1 (n 1) octets, si n 2. Donc, E 1 (n) = 8n octets. Analyse de l algorithme Fibo2 : T 2 (n) = 2, si n 1 et T 2 (n) = 4n + 3, si n 2. E 2 (n) = 2 4 = 8 octets, si n 1 et E 2 (n) = 4 (n + 4) = 4n + 16 octets, si n 2.

13 13 Analyse de l algorithme Fibo3 : T 3 (n) = 2, si n 1 et T 3 (n) = 6n, si n 2. E 3 (n) = 2 4 = 8 octets, si n 1 et E 3 (n) = 6 4 = 24 octets, si n 2. Analyse de l algorithme Fibo4 : T 4 (n) = 2, si n 1 et T 4 (n) = 6n, si n 2. E 4 (n) = 2 4 = 8 octets, si n 1 et E 4 (n) = 5 4 = 20 octets, si n Programme principale pour mesurer les temps d exécution pour calculer F (10), F (15), F (20),..., F (50) pour chacune des fonctions précédentes : main() int n, r; float t1, t2, t; for(n = 10; n <= 50; n += 5) t1 = clock(); r = Fibo1(n); t2 = clock(); t = (t2 - t1) / CLOCKS_PER_SEC; printf("fibo1(n) = %d\n", r); printf("temps d execution de Fibo1 : %d\n secondes", t); t1 = clock(); r = Fibo2(n); t2 = clock(); t = (t2 - t1) / CLOCKS_PER_SEC; printf("fibo2(n) = %d\n", r); printf("temps d execution de Fibo2 : %d\n secondes", t); t1 = clock(); r = Fibo3(n); t2 = clock(); t = (t2 - t1) / CLOCKS_PER_SEC; printf("fibo3(n) = %d\n", r); printf("temps d execution de Fibo3 : %d\n secondes", t); t1 = clock(); r = Fibo4(n); t2 = clock(); t = (t2 - t1) / CLOCKS_PER_SEC; printf("fibo4(n) = %d\n", r);

14 14 printf("temps d execution de Fibo4 : %d\n secondes", t); getch(); 6. Question hors série : cette question est hors-série. Exercice 3 1. D après la définition de la partie entière, F (x) = Maxk 0 k 2 x. On fait donc une recherche séquentielle pour trouver le plus grand élément de l ensemble k 0 k 2 x. D où la fonction suivante : int F(int x) int k = 0; while(k * k <= x) k++; return k - 1; Remarque : à la sortie de la boucle while, on a k 2 retourner est donc k 1. > x. La valeur à 2. Posons y = F (x/4). Par définition, y x/4 < y + 1 et par suite y 2 x/4 < (y + 1) 2 (2y) 2 x < (2y + 2) 2 2y x < 2y + 2. Il y a alors deux cas : si 2y x < 2y + 1, alors F (x) = 2y et si 2y + 1 x < 2y + 2, alors F (x) = 2y + 1. Le cas de base est F (0) = 0. D où l algorithme : int F(int x) if(x == 0) return 0; int y = F(x / 4); /* appel récursif */ if(x < (2 * y + 1) * (2 * y + 1)) return 2 * y; return 2 * y + 1;

15 15 Remarque : n utilisez pas pow(2 y + 1, 2), cette fonction est faite pour le type double et non pas pour le type int. Elle ne donne pas toujours un résultat correct. Par exemple pour les valeurs de x suivantes : 49, 789,..., elles donne des résultats faux. 3. Soit x 0 un entier. On sait que F (x) est le plus grand entier k vérifiant k 2 x. Si x 1, alors F (x) = x. Il est clair que 0 F (x) < x, pour x 2. On peut donc effectuer une rechreche dichotomique pour trouver k dans l intervalle [0...x]. Soient x 2 et d et f deux entiers tels que d 2 x < f 2. Il est clair que F (x) [d...f 1]. Si f = d + 1, alors F (x) = d. Sinon, l intervalle [d...f 1] contient au moins deux éléments. On le divise par deux en calculant son milieu m = (d + f)/2. Il y a alors trois cas : Si m 2 = x, alors F (x) = m. Si m 2 > x, alors F (x) [d...m]. Si m 2 < x, alors F (x) [m...f]. D où l algorithme : int F(int x, int d, int f) if(x <= 1) return x; if(f - d == 1) return d; int m = (d + f) / 2; if(m * m == x) return m; if(m * m < x) return F(x, m, f); return F(x, d, m); Voici un programme principal qui illustre l utilisation de ces trois fonctions (Nous appelons la première F1, la deuxième F2 et la troisième F3) : main() int x, y;

16 16 printf("donner la valeur de x : "); scanf("%d", &x); y = F1(x); printf("la valeur de F(x) par l algorithme 1 : %d\", y); y = F2(x); printf("la valeur de F(x) par l algorithme 2 : %d\", y); y = F3(x, 0, x); printf("la valeur de F(x) par l algorithme 3 : %d\", y); getch(); 4. Comparaison des temps d exécution des trois algorithmes : notons par T i (x) (resp. E i (x)) l efficacité en temps (resp. en espace) de l algorithme i. Analyse de l algorithme 1 : T 1 (x) = 3 x + 8, x 0. E 1 (x) = 3 4 = 12 octets, x 0. Analyse de l algorithme 2 : T 2 (x) = 2, si x = 0. Si x 1, on a : On en déduit alors que : 11 + T 2 ( x/4 ) T 2 (x) 12 + T 2 ( x/4 ) 11k + T 2 ( x 4 k ) T 2(x) 12k + T 2 ( x 4 k ) Soit k le plus petit entier tel que k log(4) < log(x), c est-à-dire k = 1 + log 4 (x). Alors : log 4 (x) T 2 (x) log 4 (x) On dit alors que T 2 (x) = Θ(log 4 (x)). E 2 (x) = 2 4 = 8 octets, si x = 0 et E 2 (x) = E 2 ( x/4 ) = 12 + E 2 ( x/4 ) octets, si x 1. On en déduit alors que : E 2 (x) = 12k + E 2 ( x 4 k ). Soit k = 1 + log 4 (x). Alors : E 2 (x) = 12(1 + log 4 (x) ) + 8 = ( log 4 (x) ) On écrit : E 2 (x) = Θ(log 4 (x)). Analyse de l algorithme 3 : On montre que T 3 (x) = Θ(log 2 (x)). On montre que E 3 (x) = Θ(log 2 (x)) octets. En conclusion, l algorithme le plus efficace en temps est l algorithme 2, car il est en Θ(log 4 (x)), et le plus efficace en espace et l algorithme 1, car il utilise une quantité de mémoire constante (Θ(1)).

17 17 Exercice 4 #include <stdio.h> #include <math.h> #include <stdarg.h> int bintodec(int nb,...) if(nb == 0) return 0; va_list x; int r = 0, i; va_start(x, nb); for(i = 0; i < nb; i++) r = r + (va_arg(x, int) - 0 ) * pow(2, nb i); va_end(x); return r;

18 18 Exercice 1 Solutons des exercices de la série N 3 (a) Correct : on affiche un caractère (%c) et \n est un caractère. (b) Incorrect : on affiche un caractère (%c), mais "\n" est une cha^ıne et n est pas un caractère. (c) Incorrect : on affiche une cha^ıne (%s), mais \n est un caractère et n est pas une cha^ıne. (d) Correct : on affiche une cha^ıne (%s) et "\n" est une cha^ıne. (e) Incorrect : le premier argument de printf doit ^etre une cha^ıne constante, mais \n ne l est pas. (f) Correct : le premier argument de printf doit ^etre une cha^ıne constante et "\n" est une cha^ıne constante. (g) Correct : l argument de putchar doit ^etre un caractère et \n est un caractère. (h) Incorrect : l argument de putchar doit ^etre un caractère et "\n" n est pas un caractère. (i) Incorrect : l argument de puts doit ^etre une cha^ıne, mais \n n est pas une cha^ıne. (j) Incorrect : puts("\n") va afficher deux sauts de lignes. (k) Correct : l argument de puts doit ^etre une cha^ıne et "" est une cha^ıne (vide, donc n affiche rien, mais après puts ajoute un saut de ligne à la fin). Exercice 2 Il suffit d analyser le prototype de chacune des deux fonctions : int putchar(int); int puts(const char*); (a) Incorrect, car p est un pointeur sur char et non pas un char. (b) Correct, car *p est un char (donc aussi un int). (c) Correct, car p est un pointeur sur char. (d) Incorrect, car *p est un char et non pas un pointeur sur char. Exercice 3 La fonction scanf doit lire un entier et le stocker dans la variable i, une chaîne et la stocker dans le variable s, puis un entier et le stocker dans la variable j. Il ne faut pas oublier que la fonction scanf lit les données depuis un tempon (buffer). Si l utilisateur a saisi l entrée :

19 19 12abc34 56def78 alors le tempon contiendra : Pour lire un entier (%d), scanf va accepter uniquement des chiffres. Par conséquent, les caractères 1 et 2 seront lus et l entier crée est 12. Maintenant, le pointeur de lecture pointe sur le caractère a. Pour lire une chaîne (%s), scanf va accepter tous les caractères sauf le caractère espace et tabulation. Par suite, les caractères a, b, c, 3 et 4 seront lus et la chaîne formée est abc34. Maintenant, le pointeur de lecture pointe sur le caractère espace. Pour lire un entier (%d), scanf va accepter uniquement des chiffres. Tout d abord, le caractère espace sera ignoré (car on doit lire un entier). Puis, les caractères 5 et 6 seront lus et l entier crée est 56. Maintenant, le pointeur de lecture pointe sur le caractère d. En conclusion, la variable i contient la valeur 12, la chaîne s contient la valeur abc34 et l entier j contient la valeur 56.

20 20 Exercice 4 Pour comprendre les effets des instructions, supposons par exemple que la chaîne str contient la valeur abc, ce qui sera schématisé par la figure suivante : (a) l instruction : *str = 0; affecte la valeur 0 à *str. Cela a pour effet de faire pointer str sur le caractère de code ASCII 0, c est-à-dire le caractère \0. Par suite, la chaîne str est vide : (b) l instruction : str[0] = \0 ; affecte le caractère \0 au premier élément de la chaîne str (c est-à-dire str[0]). Par conséquent, la chaîne str est vide : (c) l instruction : strcpy(str, ""); réalise une copie de la chaîne vide sur la cahîne str. Ce qui donne exactement le même effet :

21 21 (d) l instruction : strcat(str, ""); effectue la concaténation de la chaîne vide à la fin de la cahîne str. Ceci à pour effet d ajouter un autre caractère \0 à la fin de str : Dans ce cas, la chaîne str n est pas vide, mais contient la valeur abc. Finalement, l instruction qui est différente des trois autres est l instruction écrite en (d). Exercice 5 1. #include <ctype.h> 2. void majuscule(char str[]) int i = 0; while(str[i]!= \0 ) if(islower(str[i])) str[i] = toupper(str[i]); i++; main() char str1[20], str[20], *str2;

22 22 3. printf("str1 : "); gets(str1); majuscule(str1); puts(str1); /* on fait pointer str2 sur str */ str2 = str; printf("str2 : "); gets(str2); majuscule(str2); puts(str2); /* ou bien on alloue de la mémoire pour str2 */ str2 = (char*) malloc(sizeof(char) * 20); printf("str2 : "); gets(str2); majuscule(str2); puts(str2); getch(); void majuscule(char *str) while(*str!= \0 ) if(islower(*str)) *str = toupper(*str); str++; 4. Le programme principal ne change pas. Exercice 6 void modifier(char *str) while(*str) if(strncmp(str, "foo", 3) == 0) strnset(str, x, 3); str += 3;

23 23 str++; Exercice 7 int est_prefixe(const char *str1, const char *str2) while(*str1) if(*str1!= *str2) return 0; str1++; str2++; return 1; Exercice 8 #include <stdio.h> #include <string.h> #define TAILLE_MAX 20 typedef char chaine[taille_max + 1]; main() chaine str, courte, longue; printf("saisir une chaine : "); gets(str); if(*str == \0 ) printf("aucune chaine saisie, Arret du programme\n"); getch(); exit(0);

24 24 strcpy(courte, strcpy(longue, str)); while(1) printf("saisir une chaine : "); gets(str); if(*str == \0 ) break; if(strlen(str) < strlen(courte)) strcpy(courte, str); if(strlen(str) > strlen(longue)) strcpy(longue, str); printf("la chaine la plus courte est : %s\n", courte); printf("la chaine la plus longue est : %s\n", longue); getch();

25 25 Exercice 1 Solutons des exercices de la série N 4 Oui, elles sont légales. En effet, la première déclare une variable x de type structure (anonyme) et la deuxième déclare une variable y de type structure (également anonyme). La structure x peut avoir un champ de nom x (la règle de portée est respectée, car ce champ appartient au bloc entre accolades). Même chose pour y. Oui, on peut les mettre ensemble dans le même programme. L instruction d affectation : x = y; est interdite. En effet, le langage C considère deux variables dont le type n a pas été déclaré explicitement comme ayant des types non compatibles. Le compilateur va lancer une erreur d incompatibilité de types. Dans notre cas, même si les deux variables sont réellement deux structures comportant chacune deux entiers, mais elles sont incompatibles à cause du fait que leut type n a pas été déclaré d une manière explicite. Pour remédier à ce problème, on a plusieurs possibilités : 1. Déclarer x et y en même temps (moins efficace) : struct int x; int y x, y; 2. Déclarer le type d une manière explicite : struct t int x; int y x, y; 3. Déclarer le type avec un aléas : typedef struct t int x; int y; t x, y; Exercice 2 1. #include <stdio.h> main() struct char lettre; int numero; sigle;

26 26 2. #include <stdio.h> main() struct char lettre; int numero; sigle = X, 25; putchar(sigle.lettre); printf("%d\n", sigle.numero); getch(); 3. Dans le cours, on a vu que la taille mémoire d une structure est généralement la somme des tailles de ses champs. Si un char occupe 1 octet et un int 4 octets, notre structure devrait alors prendre au total 1+4 = 5 octets. Mais, voyons voir ce que ce code de vérification donne : #include <stdio.h> main() struct char lettre; int numero; sigle = X, 25; printf("la taille total est = %d octets\n", sizeof(sigle)); getch(); L exécution de ce code affiche : La taille total est = 8 octets Justification de ce phénomène : le bus de données permet souvent de charger un certain nombre d octets depuis la mémoire. Ce nombre d octets n est rien d autre que la taille du bus de données. Le processeur de l ordinateur peut ainsi charger 2, 4 ou 8 octets d un seul coup (et parfois plus). On dit que le processeur accède aux données stockées dans la mémoire par mot mémoire. Pour le cas d une structure, et afin de régulariser l accès à ses champs, le compilateur réalise ce qu on appelle un alignement des champs en tenant compte de la taille du bus de données.

27 Dans notre cas, la structure contient un champ de type char (1 octet) et un champ de type int (4 octets). Le compilateur va procéder à un alignement des champs en rajoutant 3 octets supplémentaires après le premier octet, ceci pour avoir des adresses multiples de 4. On peut vérifier ceci à l aide du code suivant : #include <stdio.h> main() struct char lettre; int numero; sigle = X, 25; 27 printf("adresse du premier champ : %d\n", &sigle.lettre); printf("adresse du second champ : %d\n", &sigle.numero); getch(); L exécution de ce code donne : Adresse du premier champ : Adresse du second champ : #include <stdio.h> struct sigle char lettre; int numero; ; main() struct sigle sig = X, 25; #include <stdio.h> struct sigle char lettre; int numero; ; void afficher(struct sigle s)

28 printf("%c%d\n", s.lettre, s.numero); main() struct sigle sig = X, 25; afficher(sig); getch(); #include <stdio.h> typedef struct sigle char lettre; int numero; sigle; void afficher(struct sigle s) printf("%c%d\n", s.lettre, s.numero); main() sigle les_sigles[3] = X, 101, X, 102, X, 103; int i; for(i = 0; i < 3; i++) afficher(les_sigles[i]); getch(); void modifier_numero(sigle *s, int n) (*s).numero = n; /* et non pas *s.numero = n; */ /* ou bien : s->numero = n; */ En effet, l opérateur. est plus prioritaire que l opérateur *. 8. #include <stdio.h>

29 typedef struct sigle char lettre; int numero; sigle; void afficher(struct sigle s) printf("%c%d\n", s.lettre, s.numero); void modifier_numero(sigle *s, int n) s->numero = n; main() sigle les_sigles[3] = X, 101, X, 102, X, 103; int i; 29 puts("avant :\n"); for(i = 0; i < 3; i++) afficher(les_sigles[i]); for(i = 0; i < 3; i++) modifier_numero(&les_sigles[i], i); puts("\napres :\n"); for(i = 0; i < 3; i++) afficher(les_sigles[i]); getch(); Exercice 3 1. typedef enum categorie INT, FLOAT, DOUBLE categorie; typedef struct Nombre categorie cat; union int ival; float fval; double dval; valeur;

30 Nombre; Nombre creer_nombre(categorie cat) Nombre n; n.cat = cat; switch(cat) case INT : printf("un entier : "); scanf("%d", &n.valeur.ival); break; case FLOAT : printf("un flottant : "); scanf("%f", &n.valeur.fval); break; case DOUBLE : printf("un double : "); scanf("%lf", &n.valeur.dval); break; return n; void afficher_nombre(nombre n) switch(n.cat) case INT : printf("un entier %d\n", n.valeur.ival); case FLOAT break; : printf("un flottant %f\n", n.valeur.fval); break; case DOUBLE : printf("un double : %lf\n", n.valeur.dval); break; main() Nombre tabnb[10]; Nombre *entiers, *floats, *doubles; int i, cat; int ni = 0, nf = 0, nd = 0; int j = 0, k = 0, l = 0;

31 31 for(i = 0; i < 10; i++) printf("categorie du nombre : "); scanf("%d", &cat); tabnb[i] = creer_nombre(cat); ni += (cat == INT); nf += (cat == FLOAT); nd += (cat == DOUBLE); entiers = (Nombre*) malloc(sizeof(nombre) * ni); floats = (Nombre*) malloc(sizeof(nombre) * nf); doubles = (Nombre*) malloc(sizeof(nombre) * nd); for(i = 0; i < 10; i++) switch(tabnb[i].cat) case INT : entiers[j] = tabnb[i]; j++; break; case FLOAT : floats[k] = tabnb[i]; k++; break; case DOUBLE : doubles[l] = tabnb[i]; l++; break; for(i = 0; i < ni; i++) afficher_nombre(entiers[i]); for(i = 0; i < nf; i++) afficher_nombre(floats[i]); for(i = 0; i < nd; i++) afficher_nombre(doubles[i]); getch();

32 32 Exercice 4 1. (a) x est un tableau de 10 pointeurs sur fonctions ayant comme argument un int et retournant un char. 2. (b) x est une fonction ayant n ayant pas d arguments et retournant un pointeur sur une fonction ayant comme argument un int et retournant un pointeur sur float. (a) typedef struct point float x; float y; point; point *p[10]; (b) char* (* (*p)[10] )(double); Exercice 5 Tout d abord, le prototype de la fonction est le suivant : int sigma(int (*f)(int), int n, int m); Une solution itérative : int sigma(int (*f)(int), int n, int m) int s = 0; int i; for(i = n; i <= m; i++) s += (*f)(i); /* ou bien : s += f(i) */ return s; Une solution récursive : (basée sur le fait que m i=n f(i) = m 1 i=n f(i) + f(m) ) int sigma(int (*f)(int), int n, int m) if(n > m)

33 33 return 0; return sigma(&f, n, m - 1) + f(m);