imcomprehension allocation mémoire

Version imprimable

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:

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.

Citation:
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:

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:

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

Thierry

01/12/2006, 10h56
sone47

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.
01/12/2006, 10h59
sone47

en faisant

Code:

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.
01/12/2006, 11h04
Thierry Chappuis

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
01/12/2006, 11h11
Thierry Chappuis

Citation:

Envoyé par sone47

en faisant

Code:

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
01/12/2006, 11h12
zooro

Citation:

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.
01/12/2006, 11h14
Thierry Chappuis

Citation:

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
01/12/2006, 11h20
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
01/12/2006, 11h22
sone47

Je vous remercie deja pour toutes ces informations.
01/12/2006, 11h30
zooro

Citation:

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 :oops:, j'ai préféré ne pas trop détailler. ;)
01/12/2006, 11h32
zooro

Citation:

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).
01/12/2006, 11h50
sone47
En fin de compte il vaut mieux ne pas initialiser son pointeur sur une case
Code:

1 2 float *p p=&a
mais l'initialiser avec la fonction malloc directement
Code:

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?
01/12/2006, 12h00
Médinoc

Citation:

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...
01/12/2006, 12h07
Emmanuel Delahaye
Citation:
Envoyé par sone47

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

Code:

1 2 float *p p=&a

mais l'initialiser avec la fonction malloc directement

Code:

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
01/12/2006, 12h16
sone47

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?

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:

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

01/12/2006, 12h45
Emmanuel Delahaye
Citation:

Envoyé par sone47

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

OK.

Citation:

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:

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

ou

Code:

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:

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:

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:

free (p), p = NULL;
01/12/2006, 12h52
Thierry Chappuis

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
01/12/2006, 15h50
sone47

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
01/12/2006, 15h52
zooro

Citation:

Envoyé par sone47

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

... lesquelles ?
Comme disait Emmanuel (on devrait sortir un recueil de citations ;)), j'ai oublié ma boule de cristal !
01/12/2006, 17h47
Thierry Chappuis

Citation:

Envoyé par sone47

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

S'il y a encore des choses qui ne sont pas claires, n'hésite pas à poser des questions.

Thierry
01/12/2006, 18h32
Emmanuel Delahaye

Citation:

Envoyé par sone47

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

Va falloir préciser, parce que là je peux difficilement détailler plus...