Discussion :

[P.N.J]

Bonjour / bonsoir,

Je reviens avec une nouvelles question mais cette fois sur le fonctionnement des cast en C et leurs impact sur la manipulation de la mémoire. Je m'explique :

Je dois reproduire le fonctionnement de memcpy. Et il se trouve que j'ai une implémentation qui semble fonctionner mais je ne comprend pas pourquoi elle fonctionne. Si je passe en paramètre les adresses de deux int et que je ne souhaite copier qu'un octet alors memcpy va effectivement modifier uniquement le premier octet.

Exemple :

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
int main()
{
	int 	*i_dst;
	int 	dst;
	int		i_src;
 
	i_dst = malloc(sizeof(int) * 1);
	dst = 23;
	i_dst = &dst;
 
	i_src = 1200;
	i_dst = ft_memcpy(((void*)i_dst), &i_src, 1);
	ft_putnbr(*i_dst);
 
	return (0);
}

23 --> 00010111

1200 --> 100 10110000

résultat de ce programme : 176

176 --> 10110000

donc on a bien pris que le premier octet de l'int.

Mon implementation est la suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
void	*ft_memcpy(void *dst, const void *src, size_t n)
{
	size_t	index;
 
	index = 0;
	while (index < n)
	{
		((unsigned char *)dst)[index] = ((unsigned char *)src)[index];
		index += 1;
	}
	return (dst);
}

Ma question est la suivante : pourquoi est ce que mon programme ne prend que le premier octet d'un int ? Quelle partie de mon code permet cela ?
En réfléchissant un peu, j'ai émis l'hypothèse suivante :
Un unsigned char est codé sur un octet, puisque j'ai casté mon int en unsigned char, le compilateur pense que je joue avec des variables qui ne font qu'un octet et donc il s'arrête la.

Mais alors si je veux écrire sur deux octets ou plus, je vais boucler deux fois ou plus et que signifieras alors src[1 ou +] ?

Je pense que mon intérrogation provient de ma faible connaissance sur les void* mais même en cherchant je n'arrive pas à trouver ce que je cherche.

Merci en tout cas d'avoir lu jusqu'ici et au plaisir de vous lire rapidement.

[Matt_Houston]

Un pointeur C est l'association d'une adresse et d'un type, type qui sert principalement à déterminer la taille de l'objet situé à cette adresse. Lorsque l'on effectue l'addition d'un pointeur et d'une valeur entière, l'adresse est toujours « décalée » d'un multiple de la taille de l'objet pointé. Autrement formulé, étant donné p un pointeur vers un type quelconque et n une valeur entière alors p + n == &p[n] == (unsigned char *)p + n * sizeof *p.

C'est la raison pour laquelle on ne peut pas faire d'arithmétique sur un void *, puisque la taille de void est une notion dénuée de sens, et que tu dois cast les paramètres de ton memcpy vers unsigned char * afin de pouvoir adresser tes buffers plus loin que leur premier byte.

void * permet ainsi d'implémenter des traitements génériques (indépendants du type des données).

[P.N.J]

Merci beaucoup, je comprend mieux !

T'as formule est super claire et utile !