malloc(); et visual studio

bonjour !

Encore une question sur une fonction en C!!

On vient de voir les pointeurs en cours, et chez moi, sous visual studio c++, lorsque j'essaye de compiler :

Code:

---

1 2 3 4 5 6 7

void main() { int *ptab; *ptab = (int *)malloc(sizeof(int)); //printf("%d\n",*(ptab+1)); system("pause"); }

---

j'ai l'erreur suivante: error C2440: '=' : cannot convert from 'int *' to 'int'
This conversion requires a reinterpret_cast, a C-style cast or function-style cast

Je n'arrive pas à comprendre l'erreur...

je viens de voir que si par contre je l'ecris comme ça:

Code:

---

1 2 3 4 5 6 7

void main() { int *ptab; ptab = (int *)malloc(sizeof(int)); //printf("%d\n",*(ptab+1)); system("pause"); }

---

La compilation ne trouve aucune erreur...

Citation:

---

Envoyé par Spike Spiegel

Code:

---

1 2 3 4 5 6 7

void main() { int *ptab; *ptab = (int *)malloc(sizeof(int)); <----------------- //printf("%d\n",*(ptab+1)); system("pause"); }

---

---

Sur la ligne flechée, tu déréférences ta variable ptab en mettant l'étoile devant. Tu désignes donc la valeur de ce pointeur, or malloc renvoie un pointeur.
Il faut donc enlever l'étoile.

*ptab = valeur de ton entier
ptab = adresse de ton entier

a+

Salut !

Rien à voir avec Visual Studio, c'est juste qu'il y a mélangeage de pinceau :)

int *ptab; est un pointeur sur un entier.
(int *)malloc(sizeof(int)); alloue de la mémoire, et te retourne l'adresse de celle-ci. C'est donc à ton pointeur (ptab) que tu dois l'affecter, comme tu l'as remarqué dans ton 2ème message :)

Comme le dit le compilateur, *ptab est un entier (tu déréférence le pointeur sur entier, donc tu obtiens un entier). Tu ne peux pas lui affecter une adresse mémoire ... Par contre, tu pourrais écrire:

Code:

---

*ptab = 1;

---

A condition bien sûr d'avoir alloué la mémoire avant ;)

merci mayhem.

Pourtant sur un cours de C présent sur en lien sur ce site, il y a ça comme exemple:

Code:

---

1 2 3 4 5 6 7

int *p = malloc(10*sizeof(int)); if(p) { p[0] = 5; printf("%d",p[0]); free(p); }

---

et ce code ne passe pas non plus.

Ah, j'ai été trop lent pour répondre :)
Euh, tu es sur que ce code ne compile pas ?

Code:

---

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

---

Sinon, cette fois ci il y a une étoile à gauche du malloc, car la déclaration du pointeur et l'affectation sont sur la même ligne: tu déclares un int*, et tu l'affectes par la même occasion

c'est sûr que ça ne passe pas...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

#include<stdio.h> #include<stdlib.h>   void main() { int *p = malloc(10*sizeof(int)); if(p) { p[0] = 5; printf("%d",p[0]); free(p); } }

---

renvoi l'erreur: error C2440: 'initializing' : cannot convert from 'void *' to 'int *'
Conversion from 'void*' to pointer to non-'void' requires an explicit cast :roll:

Il me semble que certains compilateurs font le cast sur le retour de malloc implicitement en fonction du type de donnée auquel on les associe.

ainsi

Code:

---

int *ptab = malloc(sizeof(int))

---

ne passe pas sur Visual 6

alors que

Code:

---

int *ptab = (int *)malloc(sizeof(int))

---

passe puisque le retour du malloc est casté vers le bon type.

A confirmer, c'est peut-être d'anciens compilateurs qui acceptaient cette écriture...

sinon, merci je viens de comprendre que ces deux formes:

Code:

---

1 2 3 4

int *p = malloc(10*sizeof(int)) et int *p; p = malloc(10*sizeof(int));

---

veulent dire la même chose sauf que sur la deuxième on déclare et on allou la mémoire en une seule ligne :)

Citation:

---

le retour du malloc est casté.

---

désolè mais je ne comprends pas encore ce que signifie caster. :oops:

le cast te permet de convertir un type de donnée vers un autre explicitement.
Dans ton exemple, la fonction malloc renvoie un pointeur sur le type 'void' or tu lui affectes un pointeur vers un tableau d'entier.
Il faut donc convertir le retour du malloc vers le type dont tu as besoin, c'est à dire un pointeur vers un entier.
celà se fait en préfixant la fonction par le type voulu entre parenthèse :

(int *)malloc(sizeof(int))

Ceci va donc convertir le 'void *' retourné par la fonction malloc en 'int *'

Ah oui c'est vrai que des compilateurs font les difficiles :)
Sinon, "caster", c'est changer de type.
Par exemple:

Code:

---

1 2 3

float f = 2.653; int i = (int) f;

---

Ici tu "castes" f en entier, et i vaudra donc 2. Ici le cast n'était pas nécessaire, il aurait été fait par le compilateur (dans ce cas, on appelle ca un cast implicite).

Et donc ici, comme le disait Mayhem, malloc renvoie un (void*). C'est un type générique un peu particulier. Il faut donc le "caster" en ce que tu veux, donc dans ton cas un (int*).

Bon, comme je souhaiterai vraiment comprendre les pointeurs et rien oublier, vous allez me dire si c'est faux:

Code:

---

int *ptab;

---

On déclare un pointeur qui pointe vers un entier (qui contient l'adresse d'une variable qui contient un entier.

Code:

---

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

---

celle ligne signifie que l'on allou un espace mémoire de 10 fois 1 entier au pointeur ptab. C'est à dire, que le pointeur va contenir l'adresse mémoire de 10 entiers. (?)

Citation:

---

t donc ici, comme le disait Mayhem, malloc renvoie un (void*).

---

comprends pas pk?

Dans malloc(10*sizeof(int)) => 10*sizeof(int) n'est pas un entier?

Voilà :)

Enfin plus précisement:

Citation:

---

qui contient l'adresse d'une variable qui contient un entier.

---

je dirais "qui contiendra" puisque tant que tu ne l'as pas affecté, il contient une valeur quelconque, et pointe vers n'importe quoi ;)

Citation:

---

C'est à dire, que le pointeur va contenir l'adresse mémoire de 10 entiers.

---

en fait il pointe vers le 1er des 10, et il n'y a aucun moyen de savoir combien d'entiers sont dans cette suite de nombres, à part garder ce "10" quelquepart sous le coude (un #define, une constante, une variable, ...)

Citation:

---

Dans malloc(10*sizeof(int)) => 10*sizeof(int) n'est pas un entier?

---

Si si, il prend en parametre un entier: la taille de ce qu'il doit allouer. Par contre, il ne sait pas ce que tu vas faire de cette mémoire, donc il te renvoie un (void*) et c'est à toi de le convertir vers le type qui t'intéresse ...

Je sais, tu précises sizeof(int) donc il pourrait deviner tout seul que tu vas caster ça en (int*), mais c'est comme ça :)

Citation:

---

Envoyé par bigquick

en fait il pointe vers le 1er des 10, et il n'y a aucun moyen de savoir combien d'entiers sont dans cette suite de nombres, à part garder ce "10" quelquepart sous le coude (un #define, une constante, une variable, ...)

---

donc le pointeur va contenir l'adresse mémoire du 1er des 10?

Prend également soin de tester le retour de la fonction malloc pour savoir si celle-ci a échoué.
Elle renvoie la valeur NULL si le bloc mémoire n'ai pu être alloué (mémoire insuffisante ou autre problème) sinon elle retourne l'adresse du début du bloc alloué.

Citation:

---

Envoyé par bigquick

Si si, il prend en parametre un entier: la taille de ce qu'il doit allouer. Par contre, il ne sait pas ce que tu vas faire de cette mémoire, donc il te renvoie un (void*) et c'est à toi de le convertir vers le type qui t'intéresse ...

Je sais, tu précises sizeof(int) donc il pourrait deviner tout seul que tu vas caster ça en (int*), mais c'est comme ça Smile

---

LooL !

Ok merci j'ai l'impression d'y voir un peu plus clair.

exactement !

et tu peux "passer" au suivant en faisant

Code:

---

pointeur = pointeur + 1

---

, pour que ton pointeur contienne l'adresse du suivant

ou encore y accéder avec la notation "tableau"

Code:

---

pointeur[i]

---

où "i" est le numéro de l'élément qui t'intéresse :)