Tableaux et pointeurs (corrigé)

Transcription

1 Tableaux et pointeurs (corrigé) Tous les exercices sont à faire. 1 Tableaux Exercice 1. Moyenne (*) Écrivez une fonction qui calcule la moyenne de n nombres stockés dans un tableau de double. Prototype : double moyenne (double t[], int n); Le principe est de parcourir le tableau pour en calculer la somme de tous ses éléments, puis de retourner le quotient de cette somme par le nombre d éléments. Dans une boucle, on accumulera dans une variable les valeurs des éléments de calcule de la somme. Ce genre de boucle est appelé schéma d accumulation Par exemple, l écriture mathématique s écrira en C : var=0.0; for (i=a;i<=b;++i) var += expr(i); b expr(i) i=a Le parcours d un tableau de n éléments en langage C se fait en général par une boucle allant de l indice 0 à l indice n 1 (inclus). Il vaut mieux écrire la condition de répétition sous la forme i < n que sous la forme i <= n-1, ce qui permet d une part de gagner une soustraction par tour de boucle, et d autre part de garder sous forme explicite le nombre d éléments à traiter dans l écriture du programme. Ce qui donne la solution possible suivante : double moyenne(double *t, int n) { double total=0.0; for (i = 0 ; i < n ; ++i) { total += t[i]; return total/n; Exercice 2. Recherche d éléments sur critère(*) Écrivez la fonction qui retourne l indice du premier élément strictement négatif parmi les n premiers éléments d un tableau de double ( -1 si aucun élément n est négatif). Prototype : int indice_premier_negatif (double t[], int n); Ici, l analyse du problème nous conduit à la solution suivante : 1/13

2 on parcourt le tableau si l on rencontre un élément négatif, on termine la fonction en retournant l indice courant si l on a parcouru l intégralité du tableau sans avoir rencontré d élément négatif, on retourne 1 comme indiqué dans la spécification. Attention : c est après la boucle que l on peut constater l absence d élément négatif. Une erreur courante de programmation consiste à retourner 1 trop tôt, avec un test du style if (t[i]<0) return i; else return -1; ce qui conduit à retourner -1 si le premier un élément n est pas négatif. C est toute la différence entre une recherche existentielle : i t[i] < 0 et une recherche universelle i t[i] 0. int indice_premier_negatif (double t[], int n) { for (i=0; i<n ; ++i) { if (t[i]<0) return i; return -1; Exercice 3. Maximum (*) Écrivez la fonction qui retourne la valeur du plus grand des n premiers éléments d un tableau de double. Prototype : double valeur_plus_grand (double t[], int n); Un parcours du tableau s impose, avec une mémorisation du plus grand élément rencontré. En effet, le plus grand élément du tableau peut se situer n importe où (en début, en cours ou en fin de tableau) et donc on ne peut le connaître qu après avoir examiné tous les éléments du tableau, et le mémoriser permettra de le retourner en fin de parcours. L initialisation de ce maximum pourra se faire par le premier élément du tableau ( t[0] ), et la boucle peut commencer par l indice 1. Le corps de la boucle consistera à comparer l élément courant au maximum, et, s il lui est supérieur, à le mémoriser dans le maximum. Ce qui conduit à la solution suivante : double valeur_plus_grand (double t[], int n) { double maxi=t[0]; for (i=1;i<n;++i) { if (t[i]>maxi) maxi=t[i]; return maxi; Exercice 4. Position du maximum (*) Écrivez la fonction qui retourne l indice du plus grand des n premiers éléments d un tableau de double (en cas d ex-æquo, l indice du premier d entre eux). Prototype : int indice_plus_grand (double t[], int n); 2/13

3 Le programme est semblable au précédent. Un parcours du tableau s impose, avec une mémorisation de l indice du plus grand élément rencontré. En effet, le plus grand élément du tableau peut se situer n importe où (en début, en cours ou en fin de tableau) et donc on ne peut le connaître qu après avoir examiné tous les éléments du tableau ; mémoriser sa position permettra de la retourner en fin de parcours. L initialisation de cet indice maximum pourra se faire par l indice du premier élément du tableau ( 0 ), et la boucle peut commencer par l indice 1. Ce qui conduit à la solution suivante : int indice_plus_grand (double t[], int n) { int imax=0; for (i=1;i<n;++i) { if (t[i]>t[imax]) imax=i; return imax; Exercice 5. Résistance équivalente (**) Écrivez une fonction qui calcule la résistance équivalente d un nombre quelconque de résistances en parallèle. 1 n Rappel : R = 1 R i=1 i Prototype : double resistance (double r[], int n); C est un schéma classique d accumulation (somme des inverses des éléments du tableau), puis retour de l inverse de l accumulateur. Un écueil à éviter est l oubli du cas où un des éléments est nul, ce qui conduirait à une division par 0. La solution consiste à retourner directement 0 si l un des éléments est nul. double resistance (double r[], int n) { double req=0.0; for (i=0;i<n;++i) { if (r[i]==0.0) return 0.0; req += 1/r[i]; return 1/req; Exercice 6. Conversion chaîne de caractères en entier (**) Écrivez une fonction qui prend en argument une chaîne de caractères représentant un entier en décimal et retourne l entier équivalent. ( "123" 123 ). On supposera que la chaîne est correcte et représente bien un entier. Prototype : int chaine_vers_entier (char *s); 3/13

4 Une chaîne représentant un entier est composée d une suite de caractères chiffres (compris entre '0' et '9' ), éventuellement précédée d une caractère ' ' ou '+'. L entier correspondant à un caractère chiffre est égal à ce caractère moins le caractère '0'. ( '2' '0' 2) S il y a un signe, on le mémorise sous le forme d une variable valant 1 ou +1. Puis, on accumule dans un résultat le nombre représenté selon le principe suivant : pour chaque chiffre, on multiplie par 10 la valeur accumulée et on ajoute la valeur du chiffre. En fin de calcul, on retourne le résultat multiplé par le signe. int chaine_vers_entier (char * s) { int i=0, signe=1, res=0; if (s[i]=='+') ++i; else if (s[i]=='-') { signe=-1; ++i; for(;s[i]!='\0';++i) { res=res*10+s[i]-'0'; return signe*res; Note : c est ainsi que les fontions atoi (conversion d une chaîne en int ) et atol (conversion d une chaîne en long ) de la librairie libc opèrent. Elles permettent également la conversion d une chaîne exprimant un nombre en base 8 (commençant par un 0) ou en base 16 (commençant par 0x ou 0X). De plus, elles interrompent le calcul lorsqu elles parviennent à un caractère non autorisé et retournent le résultat courant. Exercice 7. Miroir (*) Écrivez une fonction qui prend en argument une chaîne de caractères, la renverse sur ellemême ( "toto" "otot" ) et retourne l adresse de cette chaîne. Prototype : char * miroir (char *s); Il faut déjà parcourir la chaîne pour accéder à son dernier caractère. Puis permuter les couples de caractères symétriques en évitant de le faire deux fois, ce qui laisserait la chaîne inchangée. char * miroir (char * s) { int g,d; /* indice gauche et droit de parcours */ char c; for (d=0;s[d]!=0;++d); for (g=0,--d;g<d;++g,--d) { c=s[g]; s[g]=s[d]; s[d]=c; return s; Exercice 8. Répétition (*) Écrivez une fonction qui prend en argument une chaîne de caractères et l affiche en répétant chaque caractère n fois (l appel avec "toto" et 3 affichera "tttoootttooo" ). 4/13

5 Prototype : void repete (char *s, int n); Deux boucles imbriquées : l une pour parcourir la chaîne, l autre pour répéter l affichage du caractère : void repete (char *s, int n) { int j; for(;*s!='\0';++s) { for (j=0;j<n;++j) { printf("%c",*s); Exercice 9. Mise en majuscules (*) Écrivez une fonction qui prend en argument une chaîne de caractères, la transforme en majuscules ( "toto" "TOTO" ) et retourne son adresse. On laissera inchangés les caractères non lettre. On supposera la chaîne sans caractères accentués ou cédillés. Prototype : char * majuscule (char *s); L écart entre majuscules et minuscules en ASCII est de 32 ((20) hexa ). Ce n est pas la peine de s en souvenir : a - A 32 char * majuscule (char *s) { char *ret = s; for(;*s!='\0';++s) { if ('a'<=*s && *s<='z') { *s += 'A'-'a' return ret; Exercice 10. Recherche de motif (1) (**) Écrivez une fonction qui prend en argument deux chaînes de caractères et retourne 1 si la première chaîne commence par la seconde (les premiers caractères de la chaîne1 sont ceux de la chaîne2) et 0 sinon. Écrivez un programme pour tester cette fonction. Prototype : int debute_par (char * chaine1, char * chaine2); Il suffit de regarder pour chaque caractère de chaine2 s il est égal au caractère correspondant de chaine1. Dès qu il y a inégalité, on retourne 0 (faux). Si on arrive en bout de chaine2 sans avoir détecté d inégalité, on retourne 1 (vrai). Note : ce programme renvoie toujours 1 si la chaine2 est vide. int debute_par (char * chaine1, char * chaine2) { for (i=0;chaine2[i]!='\0';++i) if (chaine1[i]!=chaine2[i]) return 0; 5/13

6 return 1; Exercice 11. Recherche de motif (2)(**) Écrivez une fonction qui prend en argument deux chaînes de caractères et retourne la position de la première occurrence de la chaîne2 dans la chaîne1 si elle y est présente et -1 sinon. Prototype : int presence (char * chaine1, char * chaine2); Un appel itératif à debute_par permettra de détecter la présence de la sous-chaîne. Note : ce programme considère que la chaîne vide débute toute chaîne (retour 0). int presence (char * chaine1, char * chaine2) { for (i=0;chaine1[i]!='\0';++i) if (debute_par(&chaine1[i],chaine2)) return i; return -1; Exercice 12. Fréquence (**) Écrivez une fonction qui compte le nombre d occurrences d un caractère c dans une chaîne s. La fonction devra être récursive. Écrivez un programme pour tester cette fonction. Prototype : int compte (char c, char * s) int compte (char c, char * s) { if (*s=='\0') { return 0; return compte(c,s+1) + (*s==c?1:0) Exercice 13. Chercher/remplacer (**) Écrivez une fonction qui recherche dans une chaîne chaque caractère c pour le remplacer par un caractère r et retourne l adresse de la chaîne. Prototype : char * cherche_remplace (char c, char r, char * s); C est un parcours simple avec remplacement lorsque l on tombe sur le caractère à remplacer : char * cherche_remplace (char c, char r, char * s) { for (i=0;s[i]!='\0';++i) if (s[i]==c) s[i]=r; return(s); 6/13

7 2 Mémoire et pointeurs Exercice 14. Représentation mémoire (*) Soit le morceau de programme suivant : int a; int *pa; double x; int **p; a=8; pa=&a; x= ; 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. Après l exécution de ce programme, la mémoire ressemblera au schéma suivant : variable adresse mémoire contenu a pa x p La dernière instruction ( p=281;) sera évaluée comme suit : l affectation =281; va mettre 281 en mémoire. Mais où? p vaut 2008 p est la mémoire dont l adresse est la valeur de p (2008), donc p est le pointeur d entier (p est un int, donc p est un int ) situé en 2008 et sa valeur est /13

8 p est la mémoire dont l adresse est la valeur de p (2004), donc l entier (p est un int, donc p est un int) situé en l affectation p=281; va mettre 281 dans la mémoire située en 2004, donc indirectement dans a. D où la valeur finale de a : 281. Exercice 15. Échanges (1) (*) Soit la fonction suivante : void echange1 (int x, int y) { int z; z=x;x=y;y=z; Pourquoi ne fonctionne-t-elle pas lorsqu on l appelle avec par exemple a=2;b=3;echange1(a,b)? Représentez la mémoire lors de l exécution de ce morceau de programme. Les instructions a=2;b=3; mettent 2 et 3 dans deux zones mémoires de type int (supposées allouées préalablement par une déclaration) int a int b 2 3 L appel echange1(a,b); alloue automatiquement deux zones mémoires de type int (les paramètres formels x et y de la fonction echange1 ) et recopie les valeurs de a et b dans ces zones mémoires : int a int b int x int y La déclaration int z; alloue automatiquement une zone mémoire de type int non initialisée (contenu quelconque marqué????) : int a int b int x int y int z ???? L instruction z=x; recopie le contenu de x dans z : int a int b int x int y int z L instruction x=y; recopie le contenu de y dans x : int a int b int x int y int z L instruction y=z; recopie le contenu de z dans y : int a int b int x int y int z Les variables x et y ont bien été permutées, mais notez bien que les originaux a et b sont restés inchangés. Sur l accolade fermante (fin d exécution de la fonction echange1, les mémoires allouées automatiquement pour la fonction sont restituées. Résultat des courses : on se retrouve dans la même situation qu avant l appel : 8/13

9 int a int b 2 3 Tout ce travail pour rien... Exercice 16. Échanges (2) (*) Soit la fonction suivante : void echange2 (int *x, int *y) { int *z; *z=*x;*x=*y;*y=*z; Pourquoi risque-t-elle ne pas fonctionner lorsqu on l appelle avec par exemple a=2;b=3;echange2(&a,&b)? Représentez la mémoire lors de l exécution de ce morceau de programme. Les instructions a=2;b=3; mettent 2 et 3 dans deux zones mémoires de type int (supposées allouées préalablement par une déclaration et situées par exemple aux adresses 2008 et 2012) int a int b 2 3 L appel echange2(&a,&b); alloue automatiquement deux zones mémoires de type int * (les paramètres formels x et y de la fonction echange2 ) et recopie les valeurs de &a (2008) et &b (2012) dans ces zones mémoires : int a int b int *x int *y 2 3 La déclaration int *z; alloue automatiquement une zone mémoire de type int * non initialisée (contenu quelconque marqué????) : int a int b int *x int *y int *z 2 3???? L instruction *z=*x; recopie la valeur de *x (c est-à-dire la valeur de la zone mémoire dont l adresse est donnée par x, soit la zone mémoire int située en 2008, donc 2) dans la zone mémoire dont l adresse est donnée par z. Or, z n étant pas initialisée, la zone mémoire qu elle indique peut être située n imorte où. Si l on a de la chance, elle sera interdite en écriture et un message de type Segmentation fault nous avertira de l erreur de programmation, avant l arrêt du programme. Si l on est moins chanceux, cette zone mémoire ne sera pas interdite en écriture et le programme, quoique faux, pourra sembler fonctionner comme dans echange3 (voir ci-dessous). Dans tous les cas, ce programme est faux et il ne faut jamais utiliser une variable sans l avoir initialisée. Exercice 17. Échanges (3) (*) 9/13

10 Soit la fonction suivante : void echange3 (int *x, int *y) { int z; z=*x;*x=*y;*y=z; et l appel suivant : a=2;b=3;echange3(&a,&b) Représentez la mémoire lors de l exécution de ce morceau de programme. Les instructions a=2;b=3; mettent 2 et 3 dans deux zones mémoires de type int (supposées allouées préalablement par une déclaration et situées par exemple aux adresses 2008 et 2012) int a int b 2 3 L appel echange3(&a,&b); alloue automatiquement deux zones mémoires de type int * (les paramètres formels x et y de la fonction echange3 ) et recopie les valeurs de &a (2008) et &b (2012) dans ces zones mémoires : int a int b int *x int *y 2 3 La déclaration int z; alloue automatiquement une zone mémoire de type int non initialisée (contenu quelconque marqué????) : int a int b int *x int *y int z 2 3???? L instruction z=*x; recopie la valeur de *x (c est-à-dire la valeur de la zone mémoire dont l adresse est donnée par x, soit la zone mémoire int située en 2008, donc 2) dans la zone mémoire z de type int : int a int b int x int y int z L instruction *x=*y; recopie le contenu de *y (soit le contenu de la zone mémoire de type int dont l adresse est donnée par la valeur de y, soit 3), dans *x (soit la zone mémoire de type int dont l adresse est donnée par la valeur de x, soit la zone mémoire située en 2008, c est à dire a ) : int a int b int *x int *y int z L instruction *y=z; recopie le contenu de z (2) dans *y (soit la zone mémoire de type int dont l adresse est donnée par la valeur de y, soit la zone mémoire située en 2012, c est à dire b ) : int a int b int *x int *y int z /13

11 Les variables a et b ont bien été permutées. Sur l accolade fermante (fin d exécution de la fonction echange3, les mémoires allouées automatiquement pour la fonction sont restituées. Résultat des courses : la fonction echange3 a bien fonctionné. int a int b 3 2 Ouf! Exercice 18. Échanges (4) (**) Soit la fonction suivante void echange(type *x, type *y) { *y=*x + *y; *x=*y - *x; *y=*y - *x; ou type peut être double ou int. Faites tourner cette fonction à la main avec par exemple : int a,b; a=2;b=3;echange(&a,&b) Fonctionne-t-elle dans tous les cas? Donnez un exemple avec des double et un exemple avec des int où elle est incorrecte. Si par exemple, a vaut 1e10 et b vaut 1e-10, la différence entre a et b sera évaluée à 0, la précision des double étant d environ 15 chiffres significatifs. Donc l échange, au lieu de permuter les valeurs, considérera la plus petite comme nulle. Exercice 19. Pointeurs vs. tableau (**) Soit les deux déclarations suivantes : char tabstring[]="toto"; char *ptrstring="titi"; Essayez d en trouver les différences de comportement. En particulier, notez les possibilités d exécuter les instructions suivantes : tabstring[2]='e'; ptrstring[2]='e'; tabstring=ptrstring; ptrstring = tabstring; Lesquelles provoquent une erreur à la compilation? à l exécution? Faites un dessin représentant la mémoire. tabstring[2]='e'; // possible ptrstring[2]='e'; // impossible tabstring=ptrstring; // impossible ptrstring = tabstring; // possible 11/13

12 Exercice 20. Copie (**) Écrivez la fonction qui copie les n premiers éléments d un tableau source de double dans le tableau destination de double et retourne l adresse du tableau destination. On prendra en compte le fait que les deux tableaux peuvent se recouvrir partiellement. Prototype : double * copie (double * destination, double * source, int n); La solution naturelle est basée sur le principe : on parcourt parallèlement les deux tableaux et on copie élément par élément le contenu du tableau source dans le tableau destination, ce qui donne : double *copie(double *destination, double *source, int n) { /* Attention : ne fonctionne que si * les tableaux ne se recouvrent pas */ for (i=0 ; i<n ; ++i) { destination[i] = source[i]; return destination; Une erreur peut survenir lorsque l on appelle cette fonction avec deux tableaux se recouvrant. Par exemple, avec le morceau de programme suivant : double tab[]={8,2,103,-4,5,8; copie(&tab[1],tab,5);/* tentative de decalage droite */ on voudrait décaler d une position vers la fin de tableau les cinq premiers éléments. Or la fonction va écraser succesivement les éléments du tableau qu elle n a pas encore copiés, ce qui conduira au résultat suivant : alors que l on aurait voulu obtenir : Faire la boucle dans l autre sens (de la fin vers le début) poserait le même problème pour un décalage vers la gauche. Une solution consiste à tester la position de la source par rapport à la destination : si source est avant destination, on copie de la fin vers le début si source est après destination, on copie du début vers la fin Pour tester le positionnement des deux tableaux, il suffit de les soustraire. La différence de deux pointeurs de même type donne le nombre d éléments de ce type situés entre ces deux pointeurs ( &t[5] - &t[3] vaut 2, &t[3] - &t[5] vaut 2, quel que soit le type de t. Ce qui conduit à : double *copie2(double *destination, double *source, int n) { /* fonctionne meme si les tableaux se recouvrent */ if (destination - source < 0 ) { for (i=0 ; i<n ; ++i) { destination[i] = source[i]; else { for (i=n-1 ; i>=0 ; --i) { destination[i] = source[i]; 12/13

13 return destination; Attention : les fontions memcpy (copie de zones mémoires) et strcpy (copies de chaînes de caractères) de la librairie libc ne gèrent pas les recouvrements. Ci-dessous, un extrait de la documentation de memcpy : If the regions overlap, the behavior is undefined. 13/13