Probleme de pointeur générique

Version imprimable

Bonjour,
j'ai un probleme de pointeur générique (je debute dans les pointeurs génériques et je maitrise pas encore entierement les pointeurs) , je m'explique :

soit un pointeur de type

Code:

void * write_buffer = NULL;

je le fais pointer sur l'adresse de data qui est un entier :

Code:

write_buffer = data;

je passe en parametre le pointeur write_buffer dans une fonction :

Code:

block_list_write_buffer(head,write_buffer,size);

a l'interieur de cette fonction j'ai une ligne qui me retourne un pointeur de type void * , je voudrais que ce pointeur pointe sur l'adresse de la donnée initiale data donc, write_buffer donc.

ci joins le code de cette fonction :
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 int block_list_write_buffer( struct block_list_head * head, void * buffer, unsigned int size ) { fprintf(stdout,"\n\n-- Write --"); if (check(head != NULL, "Argument head is NULL")&& check(buffer != NULL, "Argument buffer is NULL")&& check(size != 0, "Argument size = 0")) { void * ptr_data = NULL; unsigned int free_size = 0; ptr_data = block_list_write_begin(head,&free_size); fprintf(stdout,"\n Free Size = %d",free_size); if (size <= free_size) { fprintf(stdout,"\nP ptr_data : %p",ptr_data); // affiche adresse X ptr_data = buffer; fprintf(stdout,"\n ptr_data : %d",ptr_data); // Affiche la valeur Data fprintf(stdout,"\nP ptr_data : %p",ptr_data); // Affiche une valeur Y !! (d'ou le probleme) block_list_write_end(head,size); return 0; } return -1; } return -1; }
le probleme est que ptr_data contiens bien la valeur data mais son adresse change !
je bloque la dessus est ce qu'une ame charitable pourrais m'aider ? :(
merci d'avance !

21/05/2010, 11h54
diogene
Ton histoire n'est pas claire :
-

Citation:

je le fais pointer sur l'adresse de data qui est un entier :

Qu'est ce qui est un entier ? data je suppose, pas l'adresse de data (qui ne peut être un entier). Alors, le compilateur doit râler sur cette ligne :

Code:

write_buffer = data;

qui devrait être

Code:

write_buffer = &data;

-
Code:

1 2 fprintf(stdout,"\n ptr_data : %d",ptr_data); // Affiche la valeur Data fprintf(stdout,"\nP ptr_data : %p",ptr_data); // Affiche une valeur Y !! (d'ou le probleme)
Ou ptr_data est un entier et la première ligne se justifie mais pas la seconde, ou c'est un pointeur et la deuxième ligne est justifiée mais pas la première ! Comme ici c'est un pointeur, ...

Peut-être souhaitais-tu afficher l'adresse et la valeur (à cette adresse) :
Code:

1 2 fprintf(stdout,"\n data : %d",*ptr_data); // Affiche la valeur fprintf(stdout,"\n ptr_data : %p",ptr_data); // Affiche l'adresse

Dans mon cas ptr_data est un pointeur générique :

La fonction block_list_write_begin retourne un pointeur void * dont la fonction pour retourner le pointeur se trouve ici :
Code:

1 2 3 4 5 6 7 8 void * block_list_get_write( struct block_list_head * head ) { struct block_list_elem * elem = NULL; elem = linked_list_last_as( block_list_elem, head ); return (void *)((char *)(elem+1) + elem->write); }
en tout ca

Code:

fprintf(stdout,"\n data : %d",*ptr_data); // Affiche la valeur

me met une erreur "illegal indirection"

-1 La question est de savoir comment est initialisé write_buffer.

-2
Code:

1 2 3 4 5 6 ptr_data = block_list_write_begin(head,&free_size); .... fprintf(stdout,"\nP ptr_data : %p",ptr_data); // affiche adresse X ptr_data = buffer; .... fprintf(stdout,"\nP ptr_data : %p",ptr_data); // Affiche une valeur Y !! (d'ou le probleme)
Pourquoi la valeur de retour de block_list_write_begin(head,&free_size) devrait-elle être égale à buffer ? Toi seul le sait !

21/05/2010, 14h16
Fooshi
1 - write_buffer est initialisé comme ca :
Code:

1 2 void * write_buffer = NULL;
2 - la valeur retournée par block_list_get_write est une adresse ou il faut que j'ecrive mes données soit ptr_data = buffer

J'ai simplifié mon code :
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 int block_list_write_buffer( struct block_list_head * head, void *const buffer, unsigned int size ) { fprintf(stdout,"\n\n-- Write --"); if (check(head != NULL, "Argument head is NULL")&& check(buffer != NULL, "Argument buffer is NULL")&& check(size != 0, "Argument size = 0")) { unsigned int free_size = 0; void * ptr_data = malloc(size); if (ptr_data == NULL) { return -1; } ptr_data = block_list_write_begin(head,&free_size); fprintf(stdout,"\n Free Size = %d",free_size); if (size <= free_size) { fprintf(stdout,"\n Buffer : %p",buffer); memcpy(ptr_data, buffer, size); fprintf(stdout,"\n Ptr_data : %p",ptr_data); fprintf(stdout,"\n Ptr_data : %d",ptr_data); block_list_write_end(head,size); return 0; } return -1; } return -1; }
je passe l'adresse d'une donnée (void *const buffer) en paramètre et sa taille (unsigned int size)
et je la recopie dans ptr_data avec un memcpy.
le probleme est comment afficher la valeur de ma donnée pointée puisque
fprintf(stdout,"\n Ptr_data : %d",ptr_data); me renvoie un donnée fausse
et que fprintf(stdout,"\n Ptr_data : %d",*ptr_data); ne compile pas :?

21/05/2010, 14h57
gl

Citation:

Envoyé par Fooshi

1 - write_buffer est initialisé comme ca :

Code:

void * write_buffer = NULL;

Tu passe NULL à ta fonction ? Ou tu modifies write_buffer ensuite ?

Si tu le modifies, peux tu montrer comment ?

Citation:

Envoyé par Fooshi

2 - la valeur retournée par block_list_get_write est une adresse ou il faut que j'ecrive mes données soit ptr_data = buffer

Mais ptr_data = buffer n'écrit pas les valeurs contenus dans buffer dans ptr_data mais copie l'adresse de buffer dans ptr_data qui ne contient donc plus l'adresse retourné par block_list_get_write.

Si tu veux copier les données et non les adresses, il faut utiliser memcpy() (ou une autre fonction de copie selon ce que tu copies vraiment) ou déréférencer les pointeurs pour copier les valeurs et non les adresses.

Citation:

Envoyé par Fooshi

en tout ca

Code:

fprintf(stdout,"\n data : %d",*ptr_data); // Affiche la valeur

me met une erreur "illegal indirection"

Normal, ptr_data est un void*, il ne peut pas être déréférencé. Il faut écrire (si on souhaite traiter un entier) :

Code:

fprintf(stdout,"\n data : %d",*(int*)ptr_data);

Mais dans tous les cas,

Code:

fprintf(stdout,"\n data : %d",ptr_data);

n'est pas correct.
21/05/2010, 15h01
gl
Citation:
Envoyé par Fooshi

J'ai simplifié mon code :

Code:

1 2 3 4 5 6 7 void * ptr_data = malloc(size); if (ptr_data == NULL) { return -1; } ptr_data = block_list_write_begin(head,&free_size);
L'adresse retourné par malloc est écrasé par celle retourné par block_list_write_begin. Tu as donc une fuite mémoire (tu ne peux plus libérer ce qui est alloué. D'un autre côté mais sans ça tu avais une fuite puisque tu ne cherchais pas à libérer) et tu n'écris pas dans ce que tu as alloué avec malloc mais dans ce qui est fournie par block_list_write_begin.
L'appel à malloc est à priori inutile.

Merci pour ces précisions :

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
 
int
block_list_write_buffer( struct block_list_head * head, void *const buffer, unsigned int size )
{
	fprintf(stdout,"\n\n-- Write --");
	if (check(head != NULL, "Argument head is NULL")&&
		check(buffer != NULL, "Argument buffer is NULL")&&
		check(size != 0, "Argument size = 0"))
	{	
		void * ptr_data = NULL;
		unsigned int free_size = 0;
 
		ptr_data = block_list_write_begin(head,&free_size);
 
		fprintf(stdout,"\n  Free Size = %d",free_size);
		if (size <= free_size)
		{
			fprintf(stdout,"\n  @ Buffer : %p",buffer);
			memcpy(ptr_data, buffer, size);
			fprintf(stdout,"\n  Ptr_data : %p",ptr_data);
			fprintf(stdout,"\n  Ptr_data : %d",*(unsigned int *)ptr_data);
 
			block_list_write_end(head,size);
			return 0;
		}
		return -1;
	}
	return -1;
}

maintenant ce code me semble bon :zoubi: