malloc : je ne comprends pas

Version imprimable

Voir 40 message(s) de cette discussion en une page

22/08/2006, 17h06
stokastik

malloc : je ne comprends pas
Bonjour,

D'après ce que j'ai compris de ce que j'ai lu dans un tuto,
Code:

1 2 float* mabscisse = NULL; mabscisse = malloc(100 * sizeof(float));
est équivalent à :

Code:

float mabscisse[100];

Or quand j'utilise le premier code ça fait des problèmes...
22/08/2006, 17h08
fearyourself
Citation:
Envoyé par stokastik

Bonjour,

D'après ce que j'ai compris de ce que j'ai lu dans un tuto,

Code:

1 2 float* mabscisse = NULL; mabscisse = malloc(100 * sizeof(float));

est équivalent à :

Code:

float mabscisse[100];

Or quand j'utilise le premier code ça fait des problèmes...
Il faudrait un code compilable, minimal qui expose le problème car

Citation:

ça fait des problèmes...

est un peu vague...

Jc
22/08/2006, 17h15
Franck.H
Citation:
Envoyé par stokastik

Bonjour,

D'après ce que j'ai compris de ce que j'ai lu dans un tuto,

Code:

1 2 float* mabscisse = NULL; mabscisse = malloc(100 * sizeof(float));

est équivalent à :

Code:

float mabscisse[100];
Certes mais malloc permet une allocation dynamique, il faut donc vérifier le retour de malloc pour savoir si l'allocation s'est bien déroulée. Il suffit d'une erreur ici pour faire foirer ton programme si tu fait pas le test sinon bin expose ton code et les erreurs que tu recois !

A titre indicatif:

Code:

mabscisse = malloc(100 * sizeof(* mabscisse));

c'est mieux, surtout pour la maintenance du programme !
22/08/2006, 17h46
stokastik

Citation:

A titre indicatif:

Code:

mabscisse = malloc(100 * sizeof(* mabscisse));

c'est mieux, surtout pour la maintenance du programme !

Ca fait la même chose.

Citation:

Il faudrait un code compilable,

J'essayerai d'isoler un bout de code qui expose le problème.

Voilà ce que je reçois à la compilation quand je fais ce malloc :

Citation:

[Warnig] passing arg1 of 'obtenirSimulation' from incompatible pointeur type

LA fonction 'obtenirSimulation' étant celle qui reçoit la variable "mabscisse" en premier argument.
22/08/2006, 17h50
Franck.H

Citation:

Envoyé par stokastik

LA fonction 'obtenirSimulation' étant celle qui reçoit la variable "mabscisse" en premier argument.

On peut voir sa déclaration et l'appel aussi pour voir le passage des arguments ? Là apparement ce n'est pas un problème d'allocation !
22/08/2006, 17h51
Gamdwin

Citation:

Envoyé par stokastik

Ca fait la même chose.

Bravo Sherlock.
Sauf que comme le dit Franck.H, c'est mieux pour la maintenance, puisque si tu changes le type de mabscisse tu n'as rien d'autre à changer.

Salut,

Peut etre est ce que je me trompe, mais, visiblement, tu essaie de faire un malloc dans fonction, sur un pointeur que tu as passé en parametre de celle-ci...

Par exemple
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 int main(void) { // déclaration d'un pointeur sur un réel float *ptr=NULL; //on passe ptr à une procédure pour la l'allocation procedure_alloc(ptr); //voire, on récupere le pointeur apres une fonction pour l'allocation ptr=fonction_allocation(ptr); } //l'allocation par procédure void procedure_alloc(float *nouveau) { ptr=malloc(15*sizeof(float)); } //l'allocation par fonction float* fonction_alloc(float* nouveau) { nouveau=malloc(15*sizeof(float)); return nouveau; }
Hé bien, je peux tout de suite te dire qu'aucune des deux possibilités n'est juste...

Au pire, cela ne compilera pas, au mieux (enfin, si tant est que ce soit mieux :? ) ca provoquera des catastrophes à l'utilisation

En effet, les arguments passés aux routines (procédures et fonctions confondues) sont concidérées comme des variables locales aux routines, et ce, meme si le nom de l'argument est le meme que celui de la variable à transmettre.

Si l'on veut qu'une routine A puisse passer la variable MaVar à la routine B en argument et récupérer apres la valeur de MaVar déterminée dans la routine B, il faut passer un pointeur sur MaVar à la routine B (ou, s'il s'agit d'une fonction, que B renvoie la nouvelle valeur de l'argument)

Donc, si tu veux qu'une fonction modifie pour le compte de la fonction appelante la valeur d'un float fournis en argument et renvoie une valeur de réussite/échec, tu devra founrir un pointeur sur ton float, et, si tu veux travailler sur un pointeur de type float, dans les memes conditions tu devras fournir un pointeur de pointeur à ta fonction

Un petit exemple pour t'en convaincre:
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 28 29 30 31 32 //inclusion des fichiers nécessaires #include <stdio.h> //prototype des fonctions void ChangeNL(int i); void ChangePtr(int *i); void main(void) { //un entier que l'on définit à 10 int entier=10; //la preuve est dan l'affichage printf("%d\n",entier); //Comme tu t'en doute, ChangeNL ne le modifie pas... la preuve ChangeNL(entier); printf("%d\n",entier); //par contre, ChangePtr, elle, le modifie... la preuve ChangePtr(&entier); printf("%d\n,entier); } //la fonction ChangeNL void ChangeNL(int i) { printf("on est dans ChangeNL\n"); i=25; } //la fonction ChangePtr void ChangeNL(int *i) { printf("on est dans ChangePtr\n"); //comme i est un pointeur, il faut travailler sur "l'élément visé par i" *i=25; }
Evidemment, si dans main, j'avais travaillé avec un pointeur, j'aurais du prévoir le passage d'un pointeur de pointeur pour ChangePtr et que la modification soit prise en compte dans main :? mais le principe aurait été exactement le meme

L'utilisation de malloc pour l'allocation d'un pointeur alors que l'on a un pointeur de pointeur se fait alors sous la forme de
Code:

1 2 //il faut faire un malloc sur ce qui est pointé par le pointeur de pointeur *PPtr_Argument=malloc(15*sizeof(float));

22/08/2006, 18h47
millie

C'est également conseillé de forcer la valeur de retour de malloc pour ne pas avoir de problème avec la manipulation du pointeur à coup de ++.
22/08/2006, 21h19
Médinoc

koala01 : Tu inverses "au pire" et "au mieux" et tu auras tout bon.

millie : Tout faux. Il est considéré de ne PAS mettre ce cast inutile, car il peut cacher un oubli d'inclusion de <stdlib.h>.
Et en C++, on n'utilise pas malloc().
22/08/2006, 21h25
koala01

Citation:

Envoyé par Médinoc

koala01 : Tu inverses "au pire" et "au mieux" et tu auras tout bon.

Disons que... tout dépend du point de vue...
Du point de vue du débuttant:
"M** ca ne compile pas ou Youpee, ca compile"
du point de vue de l'utilisateur
"M** j'ai une application qui a un comportement aléatoire"

Finalement, c'est un peu choux vert et vert choux, non? Le résultat étant toujours pareil: un code incorrect et inutilisable...

Et puis, j'ai bien mis entre parenthese "enfin, si tant est que ce soit un mieux" :P

Tant qu'à faire...

Tant qu'à faire, voici un code pour une procédure et une fonction qui fonctionneront pour l'allocation dynamique à l'intérieur de celles-ci

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
#include <stdio.h>
#include <malloc.h>
//prototypes des routine
void ProcAlloc(float **ptr);
float* FoncAlloc(void);
int main(void)
{
    float *pointeur=NULL;
//allocation par procédure
    ProcAlloc(&pointeur);
//Il faut vérifier ici que l'allocation aie réussi (pointeur ne vaut plus NULL)
//pour éviter les pertes de mémoires, si c'est le cas, on libère le pointeur 
//alloué par la procedure
    if(pointeur!=NULL)
    {
        printf("...ok\n");
        free(pointeur);
    }
    else
    {
        printf("...echoue\n");
    }
    //on tente avec la fonction
    pointeur=FoncAlloc();
    //on libère le pointeur avant de quitter
    free(pointeur);
    return EXIT_SUCCESS;
}
void ProcAlloc(float **ptr)
{
    printf("allocation dans la procedure");
    *ptr=malloc(15*sizeof(float));
}
float* FoncAlloc()
{
//comme il n'y a pas d'argument, il faut déclarer un pointeur de travail
//L'astuce est que si la référence à ce pointeur sera détruite en sortie de fonction
//l'allocation dynamique restera
    float *ptr;
    printf("allocation dans la fonction");
    ptr=malloc(15*sizeof(float))
    if(ptr!=NULL)
    {
        printf("...ok");
    }
    else
    {
        printf("...echoué");
    }
    return ptr;
}

22/08/2006, 22h16
millie

Citation:

Envoyé par Médinoc

millie : Tout faux. Il est considéré de ne PAS mettre ce cast inutile, car il peut cacher un oubli d'inclusion de <stdlib.h>.
Et en C++, on n'utilise pas malloc().

Je n'ai jamais parlé de C++ !!!!
22/08/2006, 22h18
Médinoc

Pardon, j'avais vu un C imaginaire.
Mais dans ce cas, je ne vois pas trop ce que ton post voulait dire...
22/08/2006, 23h17
millie
Il me semblait (arrêtez moi si je me trompe) mais mes profs m'ont toujours dis ça :

par exemple dans le code :
Code:

1 2 3 4 5 6 7 8 9 10 11 int i; double *d; double c; d = malloc(10 *sizeof(double)); for(i=0; i<5;i++) { c= *d; d++; }
Le code n'a pas d'interêt mais c'est pour faire une exemple. Enfin bref, pour moi, le faire de pas faire de cast au retour de malloc fait qu'il y a un mauvais alignement mémoire au niveau des double. Lors du d++, on ne saute que d'un sizeof(void*) car malloc retourne normalement un void*.

Alors qu'en réalisant le cast, le saut est un bon saut.
22/08/2006, 23h19
Médinoc

ben non, d est un double *, cast au retour de malloc() ou non.

Et si d était un void*, je crois bien que d++ ne compilerait pas.
23/08/2006, 09h42
Gamdwin

Citation:

Envoyé par millie

Il me semblait (arrêtez moi si je me trompe) mais mes profs m'ont toujours dis ça :
[...]
Lors du d++, on ne saute que d'un sizeof(void*) car malloc retourne normalement un void*.

Alors qu'en réalisant le cast, le saut est un bon saut.

Change de profs.
23/08/2006, 10h05
fearyourself
Citation:

Envoyé par Médinoc

ben non, d est un double *, cast au retour de malloc() ou non.

Et si d était un void*, je crois bien que d++ ne compilerait pas.

En effet, la norme refuse l'arithmétique sur le void* mais les extensions GNU font que gcc l'accepte...

Warning qui permet de le voir :

-Wpointer-arith

[EDIT]
Code:

1 2 3 4 5 6 7 8 9 int main() { int i; void *a=&i; a++; return 0; }
Citation:

$> gcc testvoid.c -Wpointer-arith
testvoid.c: In function 'main':
testvoid.c:6: warning: wrong type argument to increment

[/EDIT]

Jc
23/08/2006, 11h57
stokastik

Citation:

On peut voir sa déclaration et l'appel aussi pour voir le passage des arguments ?

Pour voir la fonction 'obtenirSimulation', mon prog est dans ce topic : http://www.developpez.net/forums/sho...d.php?t=199625
23/08/2006, 12h27
stokastik
koala01, ce que je retire de ce que tu dis est que je dois taper :
Code:

1 2 3 4 float* preabscisse=NULL; *preabscisse=malloc(TAILLE * sizeof(float));
mais cela n'est pas accepté à la compilation. J'ai essayé :
Code:

1 2 3 4 float** preabscisse=NULL; *preabscisse=malloc(TAILLE * sizeof(float));
qui me semble plus cohérent, mais alors le type de 'preabscisse' n'est plus acceptée par ma fonction.
23/08/2006, 13h07
Gamdwin

Citation:

Envoyé par stokastik

koala01, ce que je retire de ce que tu dis est que je dois taper :

Lit une nouvelle fois le post de koala1. Et essaie de comprendre le mécanisme des pointeurs avant de mettre des astérisques au hasard. ;)

(lien didactique et amusant : http://cslibrary.stanford.edu/104 )
23/08/2006, 15h59
koala01
Citation:
Envoyé par stokastik

koala01, ce que je retire de ce que tu dis est que je dois taper :

Code:

1 2 3 4 float* preabscisse=NULL; *preabscisse=malloc(TAILLE * sizeof(float));

mais cela n'est pas accepté à la compilation. J'ai essayé :

Code:

1 2 3 4 float** preabscisse=NULL; *preabscisse=malloc(TAILLE * sizeof(float));

qui me semble plus cohérent, mais alors le type de 'preabscisse' n'est plus acceptée par ma fonction.
Il faudrait vraiment que tu relise ce que j'écris...

tu as, en C, trois manière d'accéder à une variable quelconque:
1. la variable elle meme: int variable
2. un pointeur sur la variable: *pointeur
3. un pointeur de pointeur sur la variable: int **pptr
variable te fournit la valeur meme de celle-ci (10)
pointeur te fournit l'adresse mémoire à laquelle tu trouvera la valeur de variable
pptr te fournit l'adresse mémoire à laquelle un pointeurs sur l'adresse à laquelle tu trouvera la valeur

Quand tu veux faire une allocation dynamique, tu dois allouer la mémoire à un pointeur.

variable =malloc(TAILLE*sizeof(int)) ne fonctionnera pas
pointeur=malloc(TAILLE*sizeof(int)) alloura la mémoire pour TAILLE entiers
pptr=malloc(TAILLE*sieof(int *)) allouera la mémoire pour TAILLE pointeur sur des entiers (sans allouer de mémoire pour les entiers en eux-meme
*pptr=malloc(TAILLE*sizeof(int)) allouera, si pptr a déjà la place pour contenir une valeur de pointeur, la mémoire pour TAILLE entiers

Quand tu passe un parametre à une fonction, tu crée une copie locale du type que tu passe en parametre

fonction(int param1) crée, lorsque tu l'appelle, une copie de type entier et de la valeur de la variable (ou de la constante) que tu passe en parametre...

Et c'est pareil, que tu utilises, dans ta fonction appelante, une variable, un pointeur ou un pointeur de pointeur... chaque fois que tu appellerea une fonction, tu créera un variable ou un pointeur ou un pointeur de pointeur local à la fonction appelée (selon le type indiqué par la fonction appelée)

La fonction ne modifiera donc pas la valeur (de la variable, du pointeur, ou du pointeur de pointeur) d'origine...

Si tu veux qu'elle le fasse, tu dois lui passer un pointeur si tu veux modifier modifier une variable (en lui passant l'adresse de ta variable sous la forme de &variable) ou un pointeur de pointeur si tu veux qu'elle modifie un pointeur (en lui passant l'adresse de ton pointeur sous la forme de &pointeur).

Seulement, dans la fonction appelée, tu dois donc prendre en compte que tu dispose d'un élément qui "vise l'adresse mémoire à laquelle se trouve la valeur passée en argument)

donc, si tu veux réellement modifier la valeur dans la fonction appelante, tu dois signaler de modifier "l'adresse mémoire pointée par" (ton pointeur ou ton pointeur de pointeur)
23/08/2006, 16h05
stokastik

Bon ben c'est gentil de m'écrire tout ça mais ça ne m'avance pas d'un poil.
23/08/2006, 17h12
DaZumba

Citation:

Envoyé par stokastik

Bon ben c'est gentil de m'écrire tout ça mais ça ne m'avance pas d'un poil.

??? Ben, tu relis bien tout cela, tu ouvres ton livre de C ou tu lis un tutorial, et tu t'exerces a passer des tableaux a une fonction. D'abord a une dimension, puis deux, etc... Apprendre le C, c'est du boulot, ca ne se fait pas dans les forums.

On va donc reprendre...

Quand tu fais un code du genre

Code:

float tableau[100]

ton compilateur prévois de la place pour mettre 100 valeurs de type float statiquement.

C'est statique, c'est à dire que tu ne peux pas décider de redimentionner ton tableau (pour, par exemple, pouvoir mettre 200 valeurs)

Bien sur, tu peux décider d'écrire un code du genre de

Code:

tableau[150]=3.1415926

mais, si tu l'a prévu pour 100 valeurs, il la valeur se trouvera...en dehors de l'espace alloué à ton tableau, ce qui provoquera un comportement aléatoire, vu qu'on ne peut pas savoir ce qui se trouvera à cet endroit précis de la mémoire.

Donc, la solution quand tu veux pouvoir bénéficier d'un tableau dont tu ne connais pas la taille au départ, c'est de faire une "allocation dynamique".

Le résultat de l'allocation dynamique doit etre envoyé, non pas sur une variable, mais sur quelque chose qui est en mesure de prendre comme valeur une adresse mémoire.

Ce quelque chose s'appelle un pointeur.

Tu peux faire exactement les meme opérations arithmétique sur les pointeurs que sur une variable de type float, mais, il faut savoir que, si tu ne dis pas d'e travailler sur "l'élément pointé par" ton pointeur, tu modifiera en fait l'adresse mémoire sur laquelle il garde un oeil, avec tout les problèmes que cela peut comporter, à savoir qu'il ira "chatouiller" des adresses mémoires qui servent sans doute à autre chose.

un peu de code pour la compréhension
Code:

1 2 3 4 int mavar=10; //mavar est un entier, il est déclaré et on lui donne directement la valeur 10 int *ptr=NULL;//on déclare un pointeur de type entier, et, pour éviter les problème, on le fait pointer sur une adresse "safe" ptr=&mavar;//on assigne l'adresse à laquelle se trouve mavar à ptr
tu dispose toujours de ton entier, grace à mavar tu peux donc écrire

Code:

mavar+=15;

qui fera que mavar vaudra 25 maintenant

mais tu peux aussi utiliser le pointeur, pour cela il faut lui dire d'utiliser "ce qui est pointé" par l'adresse mémoire qu'il connait sous la forme de

Code:

*ptr=2;

ce qui fera que mavar (qui valait 25) vaut maintenant 2

Mais, ptr est également tout à fait indépendant de mavar...Simplement, il se fait qu'à un moment précis, l'adresse qu'il contient est celle de mavar.

Si tu écris un code

Code:

ptr++

ca aura pour effet que ptr contiendra l'adresse mémoire... qui est juste apres celle ou se trouve la valeur de mavar (et dont on ne sait à priori pas ce qu'elle contient)

Maintenant que nous avons une idée un peu claire de ce qu'est un pointeur, on peut voir comment lui faire allouer de la mémoire dynamiquement.

Si tu écris un code

Code:

ptr=malloc(100*sizeof(int));

ca "travaillera "en deux temps

L'ordinateur cherche un endroit en mémoire suffisemment grand pour contenir de manière contigue 100 valeurs de type entier différentes
ptr prend la valeur de l'adresse mémoire
(il y a un phénomene de réservation, mais, j'ai décidé de le laisser sur le coté ;))
Seulement, il peut arriver que... l'ordinateur ne trouve pas la place en mémoire demandée... c'est moche...

Si c'est le cas, il renverra une valeur NULL (que ptr prendra).

La première chose qu'il faut faire, pour éviter des catastrophes, c'est de vérifier si ptr est différent de NULL, et de ne travailler avec lui QUE s'il a effectivement une valeur différente de NULL sous la forme de
Code:

1 2 3 4 5 6 7 8 9 if(ptr!=NULL) { //ici, c'est bon } else { // aie... ici c'est pas bon }
Quand il s'agit de passer un argument à une fonction, ben... relis mes posts précédents ;)

Pour ce qui est enfin des pointeurs de pointeurs, il s'agit simplement de pointeurs qui pointent sur un autre pointeur, mais le raisonnement est identique...

EDIT==>Quand je met du code, ce n'est pas pour rien...

Lis surtout les commentaires qui sont ajoutés (ce qui suit //) C'est surtout cela qui t'aidera à comprendre ;)

23/08/2006, 17h45
Gamdwin

koala1, j'admire ta patience.
23/08/2006, 17h51
koala01

Citation:

Envoyé par Gamdwin

koala1, j'admire ta patience.

Merci :D
23/08/2006, 17h59
stokastik

Bravo aussi pour ta patience mais je ne comprends pas pourquoi tu m'écris ces tartines théoriques au lieu de répondre à ma question ce qui me permettrait de comprendre plus facilement.
23/08/2006, 18h16
koala01

sans une question précise, pas de réponse précise

Citation:

Envoyé par stokastik

Bravo aussi pour ta patience mais je ne comprends pas pourquoi tu m'écris ces tartines théoriques au lieu de répondre à ma question ce qui me permettrait de comprendre plus facilement.

Simplement parce que ce n'est pas sur deux lignes de code que l'on peut savoir exactement ce que tu demandes...

Et aussi, parce que la programmation c'est quelque chose qui nécessite de la rigueur...

Or, cette rigueur, tu ne pourra l'acquérir qu'en comprenant la théorie qui se rapporte à ce que tu fais.

Comme, en plus, le langage C est ainsi fait que l'utilisation de pointeurs et de pointeurs de pointeurs est incontournable, si tu veux pouvoir avancer en programmation C, il n'y a rien à faire, il faudra que tu aies pleinement assimilé la théorie qui s'y rapporte.

Il est donc, AMHA bien plus simple de te donner dés le départ toutes les explications sur la théorie que de te laisser "imaginer" des choses que tu croirais avoir comprises... de travers.

"Donne un poisson à un homme, il mangera un jour.
Apprend lui à pêcher, il mangera toute sa vie" ;)
23/08/2006, 18h22
GrandFather

Citation:

Envoyé par stokastik

Bravo aussi pour ta patience mais je ne comprends pas pourquoi tu m'écris ces tartines théoriques au lieu de répondre à ma question ce qui me permettrait de comprendre plus facilement.

Si tu n'es pas capable de faire la relation entre toutes les informations qui t'ont été aimablement données et ton problème, c'est que tu ne souhaites pas faire d'effort. Donc, ou bien tu prends ton courage à deux mains et tu tâches de comprendre ce qui t'est expliqué, ce qui est le comportement le plus sage quand on débute et qu'on sollicite l'aide de plus expérimentés que soi, et tu exposes clairement toutes les données de ton problème, ou bien on clotûre ce fil pour éviter de faire perdre son temps à tout le monde, à toi-même comme aux contributeurs qui prennent la peine de te répondre. Merci de ta compréhension.
23/08/2006, 18h29
Lucky-94

Peut-être doit-il rendre le devoir demain?
23/08/2006, 21h38
Médinoc

C'est vrai qu'il n'est pas forcément aisé d'expliquer le fonctionnement de malloc() à quelqu'un, mais on ne peut pas programmer décemment en C tant qu'on n'en a pas compris le fonctionnement.

"Donne une allumette à un homme, et il aura chaud pendant une minute.
Mets-lui le feu, et il aura chaud pour la vie."
23/08/2006, 21h57
stokastik

Bon excusez j'ai fait trop de C ces jours-ci, ça m'est sorti par les trous de nez. J'ai compris les pointeurs, ça doit être malloc() en effet qui me pose un blème. Je te relirai koala01, merci pour tes explications illustrées de code en exemple :king:
24/08/2006, 04h20
koala01

Ne t'en fais pas, il m'a aussi fallu pas mal de temps pour "percuter" sur les concepts de pointeurs et de pointeurs de pointeurs...

Ce n'est, à vrai dire, que dans un train, en relisant mes cours... juste apres un examen, que j'ai eu "l'illumination" qui m'a permis de concevoir pleinement comment ca fonctionnait...

Mais, les explications telles que je te les ai données me semblent bien plus claires que celles que j'ai moi meme recues :P :P

Si, apres m'avoir relu, tu ne comprend pas encore, ben, on essayera de trouver une autre manière d'expliquer, en passant par un petit dessin si nécessaire ;)

En attendant, j'ai écrit sur mon site une ==>une section entiere<== qui devrait peut etre t'aider à comprendre quelques concepts de base, en plus de te fournir une méthode d'algorithmie efficace...
24/08/2006, 10h38
Gamdwin

Tu as zieuté la vidéo dont j'ai posté l'adresse ?

C'est un peu "enfantin" (c'est à prendre au second degré :aie: ), mais c'est bien expliqué.
24/08/2006, 10h50
Médinoc

La vidéo explique les pointeurs, mais si je me souviens bien (pas de player au bureau), elle n'explique pas l'allocation dynamique...
24/08/2006, 11h41
Gamdwin

L'allocation dynamique consiste juste à définir à la volée des zones mémoires, et malloc()/calloc() retourne simplement un pointeur dessus.

Pas de différence, donc, sinon qu'il faut bien entendu libérer la zone que l'on a allouée lorsqu'on n'en a plus besoin. :D
24/08/2006, 12h43
Emmanuel Delahaye
Citation:

Envoyé par millie

Il me semblait (arrêtez moi si je me trompe) mais mes profs m'ont toujours dis ça :

Les profs 'généraux' ne connaissent généralement pas suffisamment le langage C pour donner un avis définitif sur les sujets pointus... Nous sommes là pour çà.
Citation:
par exemple dans le code :

Code:

1 2 3 4 5 6 7 8 9 10 11 int i; double *d; double c; d = malloc(10 *sizeof(double)); for(i=0; i<5;i++) { c= *d; d++; }

Le code n'a pas d'interêt mais c'est pour faire une exemple. Enfin bref, pour moi, le faire de pas faire de cast au retour de malloc fait qu'il y a un mauvais alignement mémoire au niveau des double. Lors du d++, on ne saute que d'un sizeof(void*) car malloc retourne normalement un void*.

Alors qu'en réalisant le cast, le saut est un bon saut.
Archi-faux.
1. malloc() retourne une adresse alignée. Toujours.
2. Le type n'a rien à voir.
3. Le cast n'a aucun effet sur l'alignement.
4. puisque d est du bon type, d++ s'incrémente correctement.
5. Un pointeur de type void n'est pas incrémentable en C standard.
http://emmanuel-delahaye.developpez....tes.htm#malloc

Merci de ne pas revenir éternellement sur des sujets rebattus et eclaircis depuis des lustres...

Lire la FAQ...
24/08/2006, 12h50
Emmanuel Delahaye

Citation:

Envoyé par koala01

Le résultat de l'allocation dynamique doit etre envoyé, non pas sur une variable, mais sur quelque chose qui est en mesure de prendre comme valeur une adresse mémoire.

Ce quelque chose s'appelle un pointeur.

Et c'est une variable !

http://emmanuel-delahaye.developpez.....htm#pointeurs
24/08/2006, 13h33
ciol2.6.12

c'est quoi une adresse alignée ? J'ai essayé de comprendre l'implémentation du malloc dans le K&R ben j'ai rien compris...
24/08/2006, 13h55
koala01
Citation:

Envoyé par ciol2.6.12

c'est quoi une adresse alignée ? J'ai essayé de comprendre l'implémentation du malloc dans le K&R ben j'ai rien compris...

C'est tout simplement le fait que le nombre d'octets utilisés par les différents types de base sont généralement différents..

Le fait que la mémoire soit alignée fait qu'à chaque fois que tu incrémentera la valeur de ton pointeur, tu passera bel et bien à l'adresse mémoire à laquelle commence l'élélement suivent du meme type, et non, à une adresse mémoire qui risquerait de faire prendre la fin de l'élément précédent et le début de l'élément suivant...

Un exemple de ce que ca ferait si la mémoire n'était pas alignée pourrait être obtenu ainsi
Code:

1 2 3 int *ptrint; char *ptrchar;
- les int font généralement 4 à 8 octets (parfois plus)
- les char font généralement seulement 1 octet
- les pointeurs, eux, ont une taille fixe leur permettant d'accéder à toutes les adresse mémoires
on alloue l'espace pour 10 entiers

Code:

ptrint=malloc(10*sizeof(int));

on peut très bien assigner un pointeur à un autre pointeur meme si leur type est différent (ce n'est pas conseillé, évidemment, mais on peut le faire ;))

Code:

ptrchar=ptrint;

pour l'instant, ptrchar pointe bel et bien sur la case mémoire à laquelle commence le premier élément de type entier mais si on fait
Code:

1 2 ptrchar++;
ptrchar pointera... sur le deuxieme octet du premier entier si, en plus, par la suite, on fait un
Code:

1 2 ptrint=ptrchar;
on "désaligne" le pointeur ptrint par rapport à la mémoire qui a été allouée pour les 10 pointeurs

Voir 40 message(s) de cette discussion en une page