Discussion :

[Fooshi]

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 :

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

void * write_buffer = NULL;

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

Code :

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

write_buffer = data;

je passe en parametre le pointeur write_buffer dans une fonction :

Code :

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

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 :

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

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 !

[diogene]

Ton histoire n'est pas claire :
-

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 :

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

write_buffer = data;

qui devrait être

Code :

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

write_buffer = &data;

-

Code :

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

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 :

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

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

[Fooshi]

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 :

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

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 :

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

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

me met une erreur "illegal indirection"

[diogene]

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

-2

Code :

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

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 !

[Fooshi]

1 - write_buffer est initialisé comme ca :

Code :

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

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

[Fooshi]

J'ai simplifié mon code :

Code :

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

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

[gl]

1 - write_buffer est initialisé comme ca :

Code :

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

void * write_buffer = NULL;

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

Si tu le modifies, peux tu montrer comment ?

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.

en tout ca

Code :

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

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 :

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

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

Mais dans tous les cas,

Code :

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

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

n'est pas correct.

[gl]

J'ai simplifié mon code :

Code :

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

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.

[Fooshi]

Merci pour ces précisions :

Code :

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

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