next up previous contents Next:  Opérations sur les chaînes. Up: Les bases du C. Previous:  Les déclarations for, while,   Table des matières  


23.1.5  Chaînes, vecteurs et allocation mémoire.

Il vous est loisible de définir une liste de 10 nombres entiers par exemple, sous forme d'un tableau monodimensionnel (ou vecteur):

int y[10]; 


En voici un usage simple:

#include <stdlib.h> 
#include <stdio.h> 
 
int main (int argc, char *argv[]) 
{

    int x; 
    int y[10]; 
    for (x = 0; x < 10; x++) { 
        y[x] = x * 2; 
    } 
    for (x =0; x < 10; x++){ 
        printf ("item %d is %d\n", x, y[x]) 
    } 
    return 0; 
} 



Si un tableau est de type charactère, on le désigne sous le terme de chaîne (string):

#include <stdlib.h> 
#include <stdio.h> 
 
int main (int argc, char *argv[]) 
{ 
    int x; 
    char y[11]; 
 
    for (x = 0; x < 10; x++) { 
      y[x] = 65 + x * 2; 
    } 
    for (x =0; x < 10; x++) { 
      printf ("item %d is %d\n", x, y[x]); 
    } 
    y[10] = 0; 
    printf ("string is s%\n", y); 
    return 0; 
} 


Observez qu'il est nécessaire de terminer toute chaîne par un ``zéro''. Le code y[10] = 0 définit le 11 $^{\textrm{ème}}$ caractère du tableau comme étant zéro. La conséquence est que la longueur d'une chaîne contient toujours une unité de plus que le nombre de caractères qui lui donne un sens linguistique. Remarquez aussi que le premier caractère est y[0] et non y[1], une particularité retrouvée dans de nombreux langages de programmation.

Dans l'exemple qui précède, la ligne char y[11] réserve en mémoire 11 octets pour la chaîne. Que se passerait-il si nous voulions 100.000 octets? Le C nous permet de demander de la mémoire au noyau. Cette méthode est appelée l'allocation mémoire (ou allocation memory). Tout programme un peu complexe nécessite de l'allocation mémoire pour lui-même et on ne peut obtenir de blocs mémoires de grande taille autrement qu'en pratiquant ainsi:

#include <stdlib.h> 
#include <stdio.h> 
 
int main (int argc, char *argv[]) 
{ 
    int x; 
    char *y; 
    y = malloc (11); 
    printf ("%ld\n", y); 
    for (x = 0; x < 10; x++) { 
        y[x] = 65 + x * 2; 
    } 
    y[10] = 0; 
    printf ("string is s%\n", y); 
    free (y); 
    return 0; 
} 


La déclaration *y signifie qu'on déclare une variable (un nombre) appelé y qui pointe vers une adresse de la mémoire RAM. Le symbole * veut dire pointeur. Disons que vous avez une machine avec 256 Mo de RAM + swap, y a potentiellement une taille de cette valeur-là. (La valeur numérique d'y est affichée avec printf (``%ld\n'', y);, mais cela n'a pas d'intérêt immédiat pour le programmeur).

Lorsque vous en avez fini avec l'utilisation de la mémoire, vous devez rendre l'espace qui vous a été accordé, au noyau en utilisant free. Les programmes qui n'ont pas restitué toute la mémoire qui leur a été allouée sont dits à fuite de mémoire.

L'allocation de mémoire requiert très souvent de se livrer à un petit calcul préalable de manière à déterminer la quantité de mémoire requise. Dans le cas que nous venons de voir, nous avons alloué l'espace associé à 11 caractères (chars). Etant donné que chaque caractère compte pour un octet, cela ne pose pas de problème. Que se passerait-il si nous avions à faire à 11 entiers (int). Un int sur un PC vaut 32 bits soit 4 octets (4 adresses consécutives de la mémoire). Pour déterminer la taille d'un type, nous pouvons utiliser le mot-clé sizeof:

#include <stdlib.h> 
#include <stdio.h> 
 
int main (int argc, char *argv[]) 
{ 
    int a; 
    int b; 
    int c; 
    int d; 
    int e; 
    int f; 
    int g; 
    a = sizeof (char); 
    b = sizeof (short); 
    c = sizeof (int); 
    d = sizeof (long); 
    e = sizeof (float); 
    f = sizeof (double); 
    g = sizeof (long double); 
    printf ("%d, %d, %d, %d, %d, %d, %d\n", a, b, c, d, e, f, g);  
    return 0; 
} 


Grâce à ce programme, vous pouvez déterminer le nombre d'octets associés à chaque type. A présent, vous pouvez aisément allouer de la mémoire pour des tableaux constitués d'autres types que des char.

#include <stdlib.h> 
#include <stdio.h> 
 
int main (int argc, char *argv[]) 
{ 
    int x; 
    int *y; 
    y = malloc (10 * sizeof (int)); 
    printf ("%ld\n", y); 
    for (x = 0; x < 10; x=++) { 
        y[x] = 65 + x * 2; 
    } 
    for (x = 0; x < 10; x=++) { 
        printf ("%dl\n", y[x]); 
    } 
    free (y); 
    return 0; 
} 


Sur de nombreuses machines, un int compte pour 4 octets (32 bits), mais vous ne devriez jamais postuler cela. Utilisez toujours sizeof avant de pratiquer une allocation mémoire.


next up previous contents Next:  Opérations sur les chaînes. Up: Les bases du C. Previous:  Les déclarations for, while,   Table des matières  
1-01-2006