Discussion :

[m0ul3sh0t]

Bonjour,

j'aurais besoin d'explication quant à la différence entre memcpy et memmove.
J'ai lu les man et il est dit que memmove gère le cas de deux strings qui se chevauchent alors que memcpy non. J'ai donc fait un main de test ressemblant à ceci:

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     main(void)
{
  char foo[] = "hello world";
 
  printf("Avant: (%s)\n", foo);
  memcpy( &foo[0], &foo[5], 10 );
  printf("Apres: (%s)\n", foo);
 
  strcpy(foo, "hello world");
  printf("Avant: (%s)\n", foo);
  memmove( &foo[0], &foo[5], 10 );
  printf("Apres: (%s)\n", foo);
 
  strcpy(foo, "hello world");
  printf("Avant: (%s)\n", foo);
  memcpy( &foo[5], &foo[0], 10 );
  printf("Apres: (%s)\n", foo);
 
  strcpy(foo, "hello world");
  printf("Avant: (%s)\n", foo);
  memmove( &foo[5], &foo[0], 10 );
  printf("Apres: (%s)\n", foo);
 
  return (0);
}

Le seul soucis est que j'obtiens dans les deux cas le même résultat, c'est-à-dire:
Avant: (hello world)
Apres: ( world)
Avant: (hello world)
Apres: ( world)Avant: (hello world)
Apres: (hellohello worl(ìë¿¿ôë¿¿äë¿¿É )
Avant: (hello world)
Apres: (hellohello worl(ìë¿¿ôë¿¿äë¿¿É )


Est-ce qu'une personne serait en capacité de m'éclairer un peu plus?

Merci d'avance

[Médinoc]

Ça marche dans un sens (foo+5 vers foo), mais il y a fort à parier que memcpy() ne marche pas dans l'autre sens.
memmove() est garantie marcher dans les deux sens.

[m0ul3sh0t]

dans ce cas la, est ce que j'ai eut de la "chance" que les deux cas fonctionnent ici?
j'ai volontairement mis les deux possibilites avec memcpy ET memmove

[Médinoc]

Tu as édité ton post ou bien c'est moi qui ai de la merde dans les yeux?

En tout cas, oui, c'est de la "chance".

[m0ul3sh0t]

Tu as édité ton post ou bien c'est moi qui ai de la merde dans les yeux?

En tout cas, oui, c'est de la "chance".

je l'ai edite mais avant que tu ne repondes, mais apparament apres que tu ais chargé la page (désolé )

[Médinoc]

Je viens de tester ce code sous Visual C++ 2005 et sous MinGW (via Dev-C++) :

Code C :

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
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
void TestMemMove(void)
{
	char chn1[] = "abcdefghijklmno";
	char chn2[] = "abcdefghijklmno";
	char chn3[] = "abcdefghijklmno";
	char chn4[] = "abcdefghijklmno";
 
	memcpy(chn1, chn1+5, 10); /*Décalage de 5 vers la gauche*/
	memcpy(chn2+5, chn2, 10); /*Décalage de 5 vers la droite*/
	memmove(chn3, chn3+5, 10); /*Décalage de 5 vers la gauche*/
	memmove(chn4+5, chn4, 10); /*Décalage de 5 vers la droite*/
 
	puts(chn1);
	puts(chn2);
	puts(chn3);
	puts(chn4);
}
 
int main(void)
{
	TestMemMove();
	system("pause"); /*Merci Dev-C++*/
	return EXIT_SUCCESS;
}

Sous Visual, "chance".
Sous MinGW par contre, la différence apparait:

Code X :

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

1
2
3
4
5
fghijklmnoklmno
abcdeabcdeabcde
fghijklmnoklmno
abcdeabcdefghij
Press any key to continue . . .

Tu peux voir que le memcpy() vers la droite n'a fait qu'écrire "abcde" en boucle, alors que le memmove() a fait le décalage correctement.

[m0ul3sh0t]

ok ok merci pour l'exemple

EDIT: j'ai l'impression que le memcpy de freebsd fonctionne exactement comme memmove. J'ai cp/cc ton exemple et j'ai le meme resultat pour les deux ^_^
fghijklmnoklmno
abcdeabcdefghij
fghijklmnoklmno
abcdeabcdefghij

en tout cas merci encore

[Médinoc]

Ça peut aussi être une question de taille, avec les optimisations et les trucs vectoriels.

Ce qui marche avec 10 octets ne marche pas forcément avec 3Mo.

[Emmanuel Delahaye]

Évitions de perdre notre temps à expliquer l'inexplicable. Le comportement est indéfini. Point.

Lire les docs respectives de memcpy() et memmove().

http://www.opengroup.org/onlinepubs/...ns/memcpy.html
http://www.opengroup.org/onlinepubs/...s/memmove.html

Nota : le seul comportement visible n'est pas une preuve de bon fonctionnement. Ca passe d'abord par l'absence de comportement indéterminé.

[James_]

Suite à memcpy et à memmove j'ai deux questions:
- est-ce utilisation prévue que pour des chaînes (appartient à la lib string.h)?
- est-ce qu'on peut copier complètement des structures avec plusieurs tableaux de type char même si ces tableaux ont des '0' car j'ai vu que:

n size_t The maximum length to move

Ce qui signifie qu'il y a un minimum et alors comment est-il calculé ce minimum?

[Médinoc]

Il n'y a pas de minimum.
memcpy() et memmove() copient toujours exactement n octets (à moins qu'elles ne plantent en cours de route pour paramètres invalides).

[ram-0000]

Il n'y a pas de minimum.

Heu si 0 mais cela n'a pas trop de sens (je ne sais pas d'ailleurs si c'est considéré comme un mauvais paramètres par ces 2 fonctions).
Alors 1 me semble être le minimum

[J4e8a16n]

Évitions de perdre notre temps à expliquer l'inexplicable. Le comportement est indéfini. Point.

Quid? Pour les structutes on ne s'en sert point ?

est-ce qu'on peut copier complètement des structures avec plusieurs tableaux de type char même si ces tableaux ont des '0'

Ou, on ne s'en sert point. Point.

[Franck.H]

Si tu veux une étude un peu plus détaillée et voir le fonctionnement interne pour peut-être mieux comprendre ces deux fonctions tu peux lire ca:

http://franckh.developpez.com/articl...ge=page_memcpy
http://franckh.developpez.com/articl...e=page_memmove