imcomprehension allocation mémoire

**sone47** · 01/12/2006, 10h21

Bonjour,
je voulais avoir quelques explications sur la fonction malloc et calloc;
En effet, j'ai bien compris que ces deux fonctions allouaient de la mémoire mais je ne comprends pas comment on peut définir le début de cette allocation.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
/* allocation memoire */
/**********************/
i= (float *)calloc(nbrcoef,sizeof(float));
printf("adresse de i=%d",i);
j = (float *)calloc(nbrcoef,sizeof(float));
if (i==NULL || j==NULL)
{
  printf("Erreur d'allocation mémoire !!!");
  exit(1);
}
else
{
  printf("memoire allouee");
}

i et j sont des pointeurs.
Mais lorsque j'affiche la valeur de ces pointeurs apres l'allocation, cette derniere est differente de celle a l'origine.
Je ne comprend pas comment définir de la mémoire a partir d'une adresse précise.
Est ce que le fait d'utiliser ces fonctions réinitialise les pointeurs?
Merci d'avance.

**Thierry Chappuis** · 01/12/2006, 10h45

Envoyé par sone47

Bonjour,
je voulais avoir quelques explications sur la fonction malloc et calloc;
En effet, j'ai bien compris que ces deux fonctions allouaient de la mémoire mais je ne comprends pas comment on peut définir le début de cette allocation.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
/* allocation memoire */
/**********************/
i= (float *)calloc(nbrcoef,sizeof(float));
printf("adresse de i=%d",i);
j = (float *)calloc(nbrcoef,sizeof(float));
if (i==NULL || j==NULL)
{
  printf("Erreur d'allocation mémoire !!!");
  exit(1);
}
else
{
  printf("memoire allouee");
}

i et j sont des pointeurs.
Mais lorsque j'affiche la valeur de ces pointeurs apres l'allocation, cette derniere est differente de celle a l'origine.
Je ne comprend pas comment définir de la mémoire a partir d'une adresse précise.
Est ce que le fait d'utiliser ces fonctions réinitialise les pointeurs?
Merci d'avance.

Salut,

Tout d'abord, trois petites remarques: (1) i et j ne sont pas des noms terribles pour des pointeurs (habituellement utilisés pour nommer des indices de boucles), (2)pour afficher la valeur d'un pointeur avec printf, il faut utiliser le spécificateur de format %p, et (3) il n'est pas conseillé de caster la valeur de retour de malloc ou calloc (conversion implicite entre un pointeur void * et n'importe quel autre pointeur en C).

Qu'entends-tu par "cette derniere (valeur) est differente de celle a l'origine"?

Les fonctions malloc et calloc te servent à allouer de la mémoire dans ce qu'on appelle le tas (heap memory en anglais). En cas de succès de l'allocation, ces fonctions retourne l'adresse du bloc alloué. En cas d'échec malloc et calloc retourne NULL (voir la doc http://man.developpez.com/man3/malloc.3.php ). Dans ton cas précis, je ne sais pas quelles valeurs contiennent tes variables avant allocation, mais ce qui certain, c'est que l'allocation modifie ces valeurs avec l'adresse du bloc alloué en cas de succès et NULL en cas d'échec. Un excellent tutoriel sur l'allocation dynamique de mémoire en langage C:
http://rperrot.developpez.com/articles/c/allocationC/

N'oublie pas que chaque espace mémoire alloué avec malloc, calloc ou realloc doit être libéré avec free.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
free(i), i = NULL;
free(j), j = NULL;

Meilleures salutations

Thierry

**sone47** · 01/12/2006, 10h56

En fait, je définie un pointeur que j'initialise sur une autre variable.
Je rentre une valeure x dans la case pointée par ce pointeur.
Apres avoir utilisée calloc, les cases sont initialement mises á 0.
Je désire donc rerentré la meme valeur x dans la premiere case mémoire allouée mais est ce que cette premiere case est la meme qu'au tout début?
Merci pour les remarques précédentes.

**sone47** · 01/12/2006, 10h59

en faisant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

a = (float *)calloc(nbrcoef,sizeof(float));

calloc retourne NULL si l'allocation á échoué et l'adresse de la premiere case si l'allocation á réussi. Cette premiere case dépend de quoi? Est elle choisie au hasard?
Merci pour l'aide.

**Thierry Chappuis** · 01/12/2006, 11h04

malloc et calloc allouent un nouvel espace mémoire située dans une zone appelée le tas. L'adresse retournée par malloc ou calloc n'a rien a voir avec l'adresse initiallement contenu dans tes pointeurs. D'ailleurs, ni malloc ni calloc n'a connaissance de la valeur contenu dans i ni dans j. As-tu lu la documentation de ces fonctions et le tutoriel que je t'ai conseillé? Ce sont à mon sens des prérequis à une bonne utilisation de ces fonctions.

Thierry

**Thierry Chappuis** · 01/12/2006, 11h11

Envoyé par sone47

en faisant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

a = (float *)calloc(nbrcoef,sizeof(float));

calloc retourne NULL si l'allocation á échoué et l'adresse de la premiere case si l'allocation á réussi. Cette premiere case dépend de quoi? Est elle choisie au hasard?
Merci pour l'aide.

Du point de vue du programmeur, oui, cette adresse est choisie d'une manière qui peut te sembler aléatoire. Le runtime C fait appel au système d'exploitation pour réaliser cette allocation. Il est clair que le système d'exploitation optimise ce processus, notamment pour éviter une fragmentation trop importante dans l'espace mémoire alloué au processus, mais c'est un domaine dont je ne maitrise pas, et ne mesure pas d'ailleurs, tous les enjeux.

Thierry

**zooro** · 01/12/2006, 11h12

Envoyé par sone47

Cette premiere case dépend de quoi? Est elle choisie au hasard?

Non, il s'agit généralement de l'adresse de la première zone contigüe du tas, dont la taille est supérieure ou égale à la taille demandée.

**Thierry Chappuis** · 01/12/2006, 11h14

Envoyé par zooro

Non, il s'agit généralement de l'adresse de la première zone contigüe du tas, dont la taille est supérieure ou égale à la taille demandée.

Merci zooro pour ton complément d'information, je pensais que l'algo était plus compliqué.

Thierry

**sone47** · 01/12/2006, 11h20

Il n'existe donc pas de possibilitée de tenter d'allouer de la mémoire á partir d'une adresse définit initialement.
Aussi, si l'on définit un pointeur du meme type que celui que l'on a definit dans calloc il suffira donc d'ajouter 1 au pointeur pour passer a la case superieur.
Et encore, je n'ai pas bien compris le fait que si tous les bits sont a 0 pour un entier cela fait 0 mais pour d'autres types cela n'est pas certain?
Merci

**sone47** · 01/12/2006, 11h22

Je vous remercie deja pour toutes ces informations.

**zooro** · 01/12/2006, 11h30

Envoyé par mujigka

Merci zooro pour ton complément d'information, je pensais que l'algo était plus compliqué.

Il l'est sans doute, mais comme ça dépend de l'OS, et que mes souvenirs de cours sont assez flous

, j'ai préféré ne pas trop détailler.

**zooro** · 01/12/2006, 11h32

Envoyé par sone47

Il n'existe donc pas de possibilitée de tenter d'allouer de la mémoire á partir d'une adresse définit initialement.
Aussi, si l'on définit un pointeur du meme type que celui que l'on a definit dans calloc il suffira donc d'ajouter 1 au pointeur pour passer a la case superieur.
Et encore, je n'ai pas bien compris le fait que si tous les bits sont a 0 pour un entier cela fait 0 mais pour d'autres types cela n'est pas certain?
Merci

Si tu as déjà alloué un bloc (avec malloc ou calloc), tu peux utiliser realloc pour en augmenter la taille. Si c'est possible, l'adresse initiale ne changera pas (bien sûr, parfois ce n'est pas possible, et le bloc est alors déplacé ailleurs en mémoire).

**sone47** · 01/12/2006, 11h50

En fin de compte il vaut mieux ne pas initialiser son pointeur sur une case

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
float *p
p=&a

mais l'initialiser avec la fonction malloc directement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
float *p
p = (float *)calloc(nbrcoef,sizeof(float));

comme cela, si on initialise la premiere case a une certaine valeure, cette case sera bien la premiere de l'allocation.
Est ce correct?

**Médinoc** · 01/12/2006, 12h00

Envoyé par sone47

Et encore, je n'ai pas bien compris le fait que si tous les bits sont a 0 pour un entier cela fait 0 mais pour d'autres types cela n'est pas certain?
Merci

Les flottants par exemple, sont codés différemment des entiers et leur codage effectif dépend de l'implémentation. Ainsi, la valeur 0.0 peut être n'importe quoi au niveau binaire, d'autant qu'un zéro en virgule flottante peut être positif ou négatif...

**Emmanuel Delahaye** · 01/12/2006, 12h07

Envoyé par sone47

En fin de compte il vaut mieux ne pas initialiser son pointeur sur une case

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
float *p
p=&a

mais l'initialiser avec la fonction malloc directement

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
float *p
p = (float *)calloc(nbrcoef,sizeof(float));

comme cela, si on initialise la premiere case a une certaine valeure, cette case sera bien la premiere de l'allocation.
Est ce correct?

Ca dépend de ce qu'on veut faire. Initialiser un pointeur n'est pas une fin en soi. Certes, si on doit utiliser un pointeur, on doit l'initialiser avant, mais les questions à se poser sont :

- qu'est-ce que je veux faire ?
- pour le faire, ai-je besoin d'un pointeur ?
- si oui, comment initialiser ce pointeur ?

Peux-tu répondre à ces questions ?

Compléments :

http://emmanuel-delahaye.developpez.....htm#pointeurs
http://emmanuel-delahaye.developpez....util_pointeurs

**sone47** · 01/12/2006, 12h16

En réalité je veux réaliser un tableau a taille définie par l'utilisateur.
Mon pointeur me sert donc a definir la premiere case de ce tableau.
Et la fontion malloc a definir la taille du tableau.
Est ce une bonne méthode?

**Thierry Chappuis** · 01/12/2006, 12h30

Oui, c'est même à ma connaissance, en excluant les tableaux à taille variable du C99 qui ne sont pas supportés par tous les compilateurs, la seule manière de définir un tableau dont la taille n'est connu qu'à l'exécution.

Exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
    int i; /*index de boucle */
    int taille = 10; /* taille d'un tableau qui peut être définie à l'exécution par un 
                     utilisateur. Ici, j'initialise à 10 */
    int *da_tableau; /* Pointeur sur la 1ère case du tableau */
 
    da_tableau = malloc(taille * sizeof(*da_tableau));
    if (da_tableau == NULL) /* si l'allocation a échoué */
    {
        fprintf(stderr, "Allocation failed!\n");
        exit(EXIT_FAILURE);
    }
 
    /* initialisation du tableau */
    for (i=0; i<taille; i++){
        da_tableau[i] = i;
    }
 
    /* Libérer la mémoire allouée à la fin du programme */
    free(da_tableau), da_tableau = NULL; 
 
    return EXIT_SUCCESS;
}

Meilleures salutations

Thierry

**Emmanuel Delahaye** · 01/12/2006, 12h45

Envoyé par sone47

En réalité je veux réaliser un tableau a taille définie par l'utilisateur.

OK.

Mon pointeur me sert donc a definir la premiere case de ce tableau.
Et la fontion malloc a definir la taille du tableau.
Est ce une bonne méthode?

Oui, mais c'est mal exprimé parce que ta pensée n'est pas droite.

On part de la spécification :

"je veux réaliser un tableau a taille définie par l'utilisateur."

C'est un peu flou (type des éléments ? nombre de dimensions ?) mais c'est suffisant pour faire une maquette de faisabilité en prenant un type int et un nombre de dimensions de 1, par exemple.

La spécification de la maquette devient :

"Soit à définir un tableau de type int à une dimension dont la taille est définie par l'utilisateur."

Ensuite, on doit trouver le moyen de le faire. Le langage C fournit des fonctions d'allocations mémoire qui permettent de créer un bloc de donnée dont la taille peut être fixée à l'exécution : malloc(), par exemple.

En étudiant la doc de malloc(), on voit qu'il faut passer une taille en nombre de bytes (l'unité de compte de la mémoire en C) et que la fonction retourne l'adresse du premier byte du bloc. Le type des éléments situés à cette adresse n'est pas précisé (void *).

D'autre part, si on veut être capable d'utiliser le bloc alloué, il faut sauvegarder son adresse quelque part. Quoi de mieux qu'un pointeur pour sauvegarder une adresse.

De quel type doit être le pointeur ? Tout simplement du même type que les données que l'on désire (ici, int, donc int *).

Maintenant, on est en mesure d'écrire le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int *p = malloc (nb_elements * sizeof (int));

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int *p = malloc (nb_elements * sizeof *p);

Et là, par conséquent, p est bien un pointeur vers le début du bloc, donc vers le premier élément du tableau d'int.

Attention, malloc() peut échouer. Il faut donc tester la valeur retournée avant de l'utiliser.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
   if (p != NULL)
   {
      /* OK */

On peut accéder aux éléments d'indice 0 à nb_elements - 1 avec, par exemple, la notation tableau :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
   for (i = 0; i < nb_elements; i++)
   {
      p[i] = -1;
   }

Ne pas oublier de libérer le bloc pointé par p quand on ne l'utilise plus. Le bon usage veut qu'on remette alors le pointeur à NULL, afin que sa valeur soit clairement définie, en accord avec l'état réel du système (le bloc a été libéré, son usage est interdit).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   free (p), p = NULL;

**Thierry Chappuis** · 01/12/2006, 12h52

Note que des explications similaires à celles que t'as fourni Emmauel figurent dans l'excellent tutoriel dont je t'ai déjà donné la référence plus haut.

Thierry

**sone47** · 01/12/2006, 15h50

Merci
J'ai lu les explications mais cependant il reste toujours quelques incompréhension et une explication détaillee ne fait pas de mal.
Merci encore

imcomprehension allocation mémoire

C

Discussions similaires

Partager

Partager