Feuille 6 : Allocation - types avec pointeurs

1. Type d'expression

   Remplir le tableau suivant en fournissant le type de l'expression, si celle-ci est définie, sachant qu'on a défini:

   typedef char * Pchar;
   
   

   Déclarations	Expressions
   	v	*v	&v	v[3]	v+3
   int v
   int v[10][3]
   Pchar v[4]
   char * v
   char * * v

2. Types des paramétres de sous-programmes
   Donner le prototype d’un sous programme qui:
   1. reçoit un entier n, reçoit un tableau d’entiers et le remplit par n entiers lus, alloue un tableau de n entiers et le remplit par les carrés respectifs des nombres précédemment lus et fournit ce nouveau tableau.
      
   2. reçoit un tableau de caractères et le remplit par une ligne lue au clavier, alloue un tableau de caractères pour y coder une copie de cette ligne et la fournir à son appelant.
      
   3. reçoit un entier n (au plus égal à 100), un tableau de 100 pointeurs sur caractères lit n lignes, et pour chacune alloue une zone mémoire pour la mémoriser et note son adresse dans le tableau de pointeurs fourni.
      
   4. reçoit un entier n (au plus égal à 100), alloue un tableau de n pointeurs, lit n lignes, et pour chacune alloue une zone mémoire pour la mémoriser et fournit ces adresses dans le tableau de pointeurs alloué.

3. Comparaisons de codages suivant l'encombrement mémoire
   On travaille sur NMAX=200 000 livres, dont les titres ont une longueur maximum de LGT=128 caractères, et une longueur moyenne de 15. On utilise deux codages pour mémoriser les titres:
   codage 1:
   
   char titres[NMAX][1+LGT];     // Tableau de chaînes de longueur maxima
   codage 2:
   
   typedef char * Pchar;
   Pchar tt[NMAX];     // Tableau de pointeurs sur chaînes
   où tt[i] est l'adresse d'une zone allouée, contenant le titre du ième livre; la taille de cette zone est adaptée à la longueur du titre.
   1. Evaluer en octets la taille de la zone réservée pour mémoriser les titres pour chaque codage.
   2. Ecrire le sous-programme litEtAlloue, qui lit un titre de livre (écrit sur une ligne), alloue une zone dont la taille est adaptée à la longueur du titre et fournit un booléen indiquant si l'allocation a été effectuée ainsi que l'adresse de cette zone.
   3. Ecrire une suite d'instructions qui lit et mémorise les 'titres' de 50 livres, par exemple.
   4. Vous devez écrire un sous-programme de nom traiteTitres, qui prend en paramètres un tableau de titres et le nombre de titres; écrire les prototypes de ce sous-programme, respectivement pour chaque codage des titres.

4. Valeur renvoyée de type pointeur

   Ci-dessous figurent plusieurs versions d’un sous-programme fournissant une chaîne constituée par la duplication, n fois, d'un caractère c.

   Après avoir étudié les résultats fournis par le programme suivant, expliquez pourquoi les sous-programmes dup0, dup1 et dup2 sont incorrects.
   (le sous-programme dup0 étant incorrect du point de vue syntaxique est mis en commentaire)

   
       #include  <stdio.h>
       typedef   char  *  Pchar;
       
   
       /* Construit (mal) une chaîne contenant n fois le caractère c et renvoie 
       l'adresse du premier octet .
       Condition d'emploi:  n>=0
       Pchar dup0( char c, int n) {
       char tc[n+1]; int i;
       for( i=0; i<n; i++) tc[i]=c;
       tc[i]='\0';
       return tc;
       }*/
       
   
       Pchar dup1( char c, int n) { 
       /* Construit (mal) une chaîne contenant n fois le caractère c.   
          Renvoie l'adresse de son premier octet.   
          Condition d'emploi:   n >= 0   &&  n <= 256
       */
       char tc[256+1]; int i;
       for( i=0; i<n; i++) tc[i]=c;
       tc[i]='\0';
       return tc;
       }
       
   
       Pchar dup2( char c, int n) {
       /* Construit (mal) une chaîne contenant n fois le caractère c.
          Renvoie l'adresse du premier octet de la chaîne.
          Condition d'emploi:  n>=0   &   n<=256
       */
       static char tc[256+1]; int i;
       for( i=0; i<n; i++) tc[i]=c;
       tc[i]='\0';
       return tc;
       }
       
       /*	 V e r s i o n   c o r r e c t e */ 
       
   
       Pchar dup3( char c, int n) {
       /* Construit une chaîne contenant n fois le caractère c.
          Renvoie l'adresse ad du premier octet de la chaîne.
          Après utilisation, la zone mémoire contenant la chaîne doit être libérée
          par:
                          free(ad);
       */
       int i;
       Pchar  tc = (Pchar) malloc( n+1 );
       if ( tc != NULL ) {
          for( i=0; i<n; i++) tc[i]=c;
          tc[i]='\0';
          }
       return tc;
       }
       
   
       void affiche( char * tc) { 
       /* Affiche la chaîne de caractères pointée par tc */
       int ti[500], i;
       for(i=0; ilt;500; i++) ti[i]=33333333;
       printf(" %s\n", tc);
       }
       
   
       void main() {
       Pchar tc1, tc2, tc22,  tc3, tc33;
   
       /* Une utilisation de dup1, et deux affichages de tc1 */
       tc1 = dup1( 'A', 3);
       printf( "tc1 :%s   tc1 :", tc1);  affiche(tc1);
       /* Deux utilisations de dup2 */
       tc2 = dup2( 'B', 4);
       printf( "tc2 :%s   tc2 :", tc2);  affiche(tc2);
       tc22 = dup2( 'C', 5);
       printf( "tc22 :%s   tc22 :", tc22);  affiche(tc22);
       printf( "tc2 :%s   tc2 :", tc2);  affiche(tc2);
       /* Deux utilisations de dup3 */
       tc3= dup3( 'D', 6);
       printf( "tc3 :%s   tc3 :", tc3);  affiche(tc3);
       tc33 = dup3( 'E', 7);
       printf( "tc33 :%s   tc33 :", tc33);  affiche(tc33);
       printf( "tc3 :%s   tc3 :", tc3);  affiche(tc3);
   
       free(tc3); free(tc33);
       }