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.