> Théorie
PrograZine issue #8 - http://www.citeweb.net/discase/8/MEMC3.htm Edito Sommaire Contribution Contacts


Gestion de la mémoire en C (III)
par SiGmA9o9/oTl! - 06 56 046 799 [TaToO tExT] [07h/24h] Just It BBS - 03 84 52 19 45
Initié Dos C
> fichiers attachés





     Bahhh.. apres un temps d'absence assez long, voici la troisieme partie de mon article sur la gestion de la memoire en -C- .. Je pense que vous avez eu le temps de potasser les deux premiers articles .. qui, en faite n'utilises que la bibliotheque standart "#include <stdio.h>"... largement suffisante pour une simple declaration/creation d'un bloc de variables, mais qui est tres limitee en ce qui conserne le traitement de la memoire...

     Je vais donc dans cet article vous expliquez qu'il est aussi **possible** d'utiliser une autre bibliotheque, qui malheureusement n'appartient pas a la norme standart du -C-.. mais qui est pourtant disponible dans tout les Compilateur -C-

     Avant d'aborder notre article sur la bibliotheque **#include <malloc.h>** il faut savoir qu'une bibliotheque dite ** NON STANDART! ** peut etre declaree/definit de plusieurs facons.. (Le corps, les noms et l'utilisation des fonctions peuvent changer entre un compilateur et un autre)...

     Personnellement j'utilise le compilateur * FREEWARE * -C/C++/ASM- de chez SYMANTEC. A mon avis y'a pas mieux dans le genre, surtout³a ce prix la!!! ahah! :) il est disponible gratuitement sur le web de la societe... ou en telephonant simplement sur le site de distribution de pROGR@zINE (jUST iT bBS)...
lLe fichier "malloc.c" a etait cree pour la compatibilite avec les utilitaires MICROSOFT et BORLAND. (Les fonctions sont disponibles dans le fichier "stdlib.h"...
ben voila... let's go!
>... #include <malloc.h> ...

     Lors de cet article³je vais expliquer *l'utilisation* des.principals fonc tions que rassemblent la bibliotheque malloc.h . Je laisserai de cote les fonctions similaires a la bibliotheque standart <stdio.h>³... par exemple malloc(); , calloc(); ou realloc();

     Voir les deux premiers articles si vous voulez connaitre les "prototypes" des fonctions primaires... (creation d'une variable, d'un³bloc et utilisation n'on pas par son nom, mais par son adresse)...

     Maintenant, et grace a la bibliotheque "malloc.h", vous allez pouvoir ex- ploiter/diriger la memoire de vos programmes de facon moins statique...
>alloca(); /* void alloca(size_t size); */
: :
    Cette fonction creer un tableau de XX bytes en memoire et libere automatiquement celle-ci a la fin du programme...
  • Retourne:une valeur NULL si la fonction ne peut creer l'espace demande par le parametre "size_t". En cas de *succes* le pointeur se place sur l'adresse du premier byte que compose le tableau...
             ex: alloca(nb_variables * sizeof(type));
l
l Similaire dans ca conception premiere a malloc() de la bibliotheque "#include <stdio.h>... Ne pas confondre avec la bibliotheque "alloc.h"...
>freect(); /* unsigned int freect(size_t size); */

     La fonction determine le nombre de fois qu'un programme peut appeler une fonction de la bibliotheque "malloc.h".
  • Retourne:le nombre de cycles...
l teste par exemple, le temps que va mettre un bloc de n variables a atteindre la fin de la memoire... l
>memavl(); /* memavl (void); */

     La fonction retourne! la valeur approximative du³nombre de bytes disponibles en memoire. (cette valeur n'est pas forcement linaire... mais peut etre adressee automatiquement...)
  • Retourne : le nombre de bytes disponibles en memoire...
l infos : La fonction ** memmax() ** peut etre utilisee:pour trouver le plus gros bloc de memoire "linaire" disponible en memoire...
>memmax(); /* memmax(void); */

     La fonction retourne la taille en byte, du plus gros bloc de memoire... (Linaire seulement!!!)...
  • Retourne:une valeur NULL si "aucun!" bloc ne peut etre adresse (par exemple quand il n'y a plus de bloc disponible...)
  • En cas de *succes*, la fonction retourne la taille du block... (c'est la taille du plus "gros" bloc de memoire disponible qui sera pris en compte par la fonction memmax();)
>msize(); /* msize(void * memblock); */
. .
    la fonction retourne la taille en bytes, du bloc|memoire declare par la fonction malloc(); , calloc(); ou realloc();...

     fmsize(); idem... mais retourne la taille en bytes, d'un "bloc" cree avec la fonction fcalloc(); , fmalloc(); ou:frealloc();...
  • Retourne.la taille en bytes du bloc...


     Voila pour aujourd'hui... Comme vous l'avez deja "surement" remarque.. la bibliotheque **malloc.h** n'est utilisee qu'avec des blocs memoire preala blement declares avec les fonctions malloc(); , calloc();|et realloc();..

     Maintenant, vous avez donc la possibilite de gerer votre memoire de facon plus precise... savoir par exemple a l'avance, combien vous pourrez avoir de bloc en memoire... sans faire de teste... et etre bien:entendu certain a l'avance d'avoir la place ou pas... (et pas lors d'un teste avec 'if').

     Vous pouvez aussi calculer la taille d'un bloc sans passer par une opera- tion du style "int a = nb_variables * (sizeof(type));"...|qui en faite ne calcule pas vraiment la vrai place prise par le bloc lui meme.. mais fait un simple calcul *virtuel*...

     et pour finir... le:plus simplement possible... vous pouvez "calculer" la taille de memoire disponible *pendant* l'execution de votre programme...
> Exemple de l'utilisation des fonctions de la bibliotheque "malloc.h".
 #include <stdio.h>
 #include <stdlib.h> /* pour BORLAND ou MICROSOFT */
 #include <malloc.h>

 int main() {
             unsigned long   a,    /* valeur non signe */
                             *b;   /* pointeur pour bloc memoire */
                      size_t size;

              /* calcul & affichage de l'espace memoire disponible */

             a = _memavl();  /* 'A' prends le nombre de bytes de la memoire
                                 disponible */

             printf ("\n # Memoire disponible : %u\n", a);

              /* allocation d'un bloc de 20 variables (entier) */

             b = malloc (20 * sizeof (long)); /* long = 4 octets/16bits */

              /* affichage du reste de la memoire grace a memavl() */
              
             a = _memavl(); /* 'A' prends le nombre de bytes de la memoire
                                restante */

             printf ("\n # Memoire restante : %u\n", a);

              /* affichage de la taille reel du bloc de memoire (b!) */

             size = _msize(b);  /* prends la taille du bloc 'B' */
             printf ("\n # Taille du bloc en memoire : %d\n", size);

               /* teste la largeur du plus gros bloc de memoire libre */

             size = _memmax();
             printf ("\n # Largeur du plus gros bloc de mem. libre : %u\n",
                     size);

             return (0); /* fin du programme! */
            }
l

     Voila.. les fonctions s'utilisent en *complement* d'une allocation memoire faite grace aux fonctions "malloc();", "calloc();" ou "realloc();"...

     Voici un exemple de creation d'un bloc de memoire avec la fonction : "alloca();" (Disponible dans la bibliotheque "malloc.h")...
 #include <stdio.h>
 #include <stdlib.h> /* pour BORLAND ou MICROSOFT */
 #include <malloc.h>

 int main() {
             size_t size;
             char   *a;
             int    b;

              /* creation d'un tableau de caracteres de 50 unites */

             a = _alloca(50 * sizeof(char));

              /* affichage de la taille du tableau ** VIRTUEL ** */

             b = (50 * sizeof(char));
             printf ("\n # Affichage de la taille du bloc *VIRTUEL*: %d\n",
                     b);

             return(0);
            }
l
l
     ATTENTION: la taille|VIRTUEL est calculee par rapport a un³calcul prennant en compte³la taille d'un seul "TYPE" multiplie par le nombre de variable(s)... exemple :
               int a = (nb_variables * sizeof(TYPE) );
l

     La taille|REEL est calculee par rapport au bloc.lui meme...
               int *b; /* pointeur pour le bloc memoire */ |
               size_t a = _msize(b);
l

    Voila... rien de plus en ce qui concerne la bibliotheque "malloc.h"...
Cet article est la propriété de SiGmA9o9/oTl!. L'auteur et la rédaction du magazine déclinent toutes responsabilités vis-à-vis des conséquences que pourrait entraîner ce document.