malloc(); et visual studio

**Spike Spiegel** · 02/10/2005, 16h00

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 :

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

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

**Spike Spiegel** · 02/10/2005, 16h05

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

Code :

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

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

**Mayhem** · 02/10/2005, 16h07

Envoyé par Spike Spiegel

Code :

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

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+

**bigquick** · 02/10/2005, 16h08

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 :

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

*ptab = 1;

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

**Spike Spiegel** · 02/10/2005, 16h08

merci mayhem.

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

Code :

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

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.

**bigquick** · 02/10/2005, 16h12

Ah, j'ai été trop lent pour répondre

Euh, tu es sur que ce code ne compile pas ?

Code :

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

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

**Spike Spiegel** · 02/10/2005, 16h14

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

Code :

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

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

**Mayhem** · 02/10/2005, 16h15

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 :

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

int *ptab = malloc(sizeof(int))

ne passe pas sur Visual 6

alors que

Code :

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

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

**Spike Spiegel** · 02/10/2005, 16h15

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

Code :

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

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

**Spike Spiegel** · 02/10/2005, 16h16

le retour du malloc est casté.

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

**Mayhem** · 02/10/2005, 16h22

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 *'

**bigquick** · 02/10/2005, 16h23

Ah oui c'est vrai que des compilateurs font les difficiles

Sinon, "caster", c'est changer de type.
Par exemple:

Code :

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

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

**Spike Spiegel** · 02/10/2005, 16h23

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

Code :

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

int *ptab;

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

Code :

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

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. (?)

**Spike Spiegel** · 02/10/2005, 16h26

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?

**bigquick** · 02/10/2005, 16h27

Voilà

Enfin plus précisement:

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

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

**bigquick** · 02/10/2005, 16h29

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

**Spike Spiegel** · 02/10/2005, 16h32

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?

**Mayhem** · 02/10/2005, 16h33

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

**Spike Spiegel** · 02/10/2005, 16h33

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.