malloc : je ne comprends pas

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)

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

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

1. L'ordinateur cherche un endroit en mémoire suffisemment grand pour contenir de manière contigue 100 valeurs de type entier différentes
2. 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 ;)

koala1, j'admire ta patience.

Citation:

---

Envoyé par Gamdwin

koala1, j'admire ta patience.

---

Merci :D

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.

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" ;)

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.

Peut-être doit-il rendre le devoir demain?

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."

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:

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...

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é.

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

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

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...

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

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...

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