Discussion :

[mitsein]

bonjour,

j'ai une structure :

Code :

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

1
2
 
struct x *a_recopier

et je veux..la recopier dans une autre.
Pour cela, j'instancie une nouvelle structure

Code :

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

1
2
 
struct x *temp = malloc(sizeof(struct x));

puis j'utilise memmove

Code :

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

1
2
 
memmove(tmp, a_recopier, sizeof(a_recopier));

mais qd j'affiche le contenu de tmp, il n'y a rien ?!
(l'affichage de a_recopier lui est correct )

Une deuxieme question :
pourquoi preferer strcpy(char *dest, char *src) plutot que faire dest = src ?

d'avance merci.

[ShootDX]

1) Je penses qu'il faudrait utiliser memcpy à la place de memmove.
2) lorsque tu fais dest = src, tu recopie l'addresse que pointe src dans dest, mais tu ne recopies pas l'objet pointé. Ainsi, tu te retrouves avec deux pointeurs qui en fait désigne exactement la même chose en mémoire.

[pipin]

Bonjour,

Vous declarez

Code :

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

struct x *a_recopier;

en faisant

Code :

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

sizeof(a_recopier)

vous obtenez la taille d'un pointeur et pas la taille de la structure

Cordialement

[Emmanuel Delahaye]

j'ai une structure :

Code :

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

1
2
 
struct x *a_recopier

et je veux..la recopier dans une autre.
Pour cela, j'instancie une nouvelle structure

Code :

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

1
2
 
struct x *temp = malloc(sizeof(struct x));

puis j'utilise memmove

Code :

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

1
2
 
memmove(tmp, a_recopier, sizeof(a_recopier));

mais qd j'affiche le contenu de tmp, il n'y a rien ?!
(l'affichage de a_recopier lui est correct )

Une deuxieme question :
pourquoi preferer strcpy(char *dest, char *src) plutot que faire dest = src ?

d'avance merci.

Pourquoi memmove() ? Les objets sont distincts, alors memcpy(),

Code :

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

memcpy (tmp, a_recopier, sizeof (*a_recopier));

ou mieux l'opérateur '=' font l'affaire.

Code :

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

*tmp, = *a_recopier;

Penser à tester le retour de malloc() et à libérer la zone allouée après utilisation.

[mitsein]

c'est quoi exactement la difference entre memmove() et memcpy() ?

cela veut il dire qu'avec memmove je deplace une zone memoire vers une autre zone ? est ce que la zone src est vide puisque je viens de la deplacer ds dest ?

pour memcpy, on recopie une zone memoire src ds une zone memoire dest, et on a là 2 zones memoire distinctes avec un contenu identique (?)

est que je suis ds le vrai ? sinon qu'elle est la difference entre les 2, exceptée que les zones de mémoire puissent se chevauchées ?

j'utilise juste memmove() pour coder "proprement"

[D[r]eadLock]

c'est quoi exactement la difference entre memmove() et memcpy() ?

DESCRIPTION
La fonction memcpy() copie n octets depuis la zone mémoire src vers la
zone mémoire dest. Les deux zones ne doivent pas se chevaucher. Si
c'est le cas, utilisez plutôt memmove(3).

Conclusion, memmove marche dans tous les cas, memcpy, uniquement si les zones ne se recouvrent pas ! Et donc, à priori, memcpy est plus rapide (ou égal) que memmove.

cela veut il dire qu'avec memmove je deplace une zone memoire vers une autre zone ? est ce que la zone src est vide puisque je viens de la deplacer ds dest ?

DESCRIPTION
La fonction memmove() copie n octets de la zone de mémoire src vers la
zone dest. Les deux zones peuvent se chevaucher.

Non, memmove garde src entier (sauf si src et dst se chevauchent). Vu que tu alloue une nouvelle zone, ça ne va pas se chevauché, donc utilise memcpy, c'est plus "propre" (sinon, ça veut dire que tu penses que les zones peuvent se chevaucher).

Si tu n'as plus besoin de src, et que tu l'as alloué, tu peux le libérer (rq: une seule fois si tu fais plusieurs copies, et si tu ne fait qu'une seule copie, je ne vois pas l'intéret ???).

mais qd j'affiche le contenu de tmp, il n'y a rien ?!
(l'affichage de a_recopier lui est correct )

Tu mets desfois temp, et d'autre tmp, je pense (espère) que ce n'est qu'une faute de frappe.

Sinon, comme l'as dit pipin, utilise sizeof(struct x) plutôt que sizeof(a_recopier) dans ton memcpy.

pourquoi preferer strcpy(char *dest, char *src) plutot que faire dest = src

(Compléments de ShootDX) strcpy marche avec les chaines de caractères, donc s'arrete avec le caractère '\0'. Or si dans ton struct x, tu as des nombres/pointeur, avec un octet qui vaut '\0', il va s'arreter. Il faut donc l'utiliser qu'avec des chaînes de caractères.


Enfin, si ton struct x contient des pointeurs (i.e. char * ou xxx *), vois s'il ne faut pas aussi les recopier (et donc malloc+copie) aussi. Ça, ça dépend de ton "algo", c'est-à-dire si tes "objets" pointés sont "partagés".

[farscape]

salut,
memcpy ne gere pas le recouvrement des zones
exemple extraits de MSDN:

char string1[60] = "The quick brown dog jumps over the lazy fox";
char string2[60] = "The quick brown fox jumps over the lazy dog";
/* 1 2 3 4 5
* 12345678901234567890123456789012345678901234567890
*/
void main( void )
{
printf( "Function:\tmemcpy without overlap\n" );
printf( "Source:\t\t%s\n", string1 + 40 );
printf( "Destination:\t%s\n", string1 + 16 );
memcpy( string1 + 16, string1 + 40, 3 );
printf( "Result:\t\t%s\n", string1 );
printf( "Length:\t\t%d characters\n\n", strlen( string1 ) );

/* Restore string1 to original contents */
memcpy( string1 + 16, string2 + 40, 3 );

printf( "Function:\tmemmove with overlap\n" );
printf( "Source:\t\t%s\n", string2 + 4 );
printf( "Destination:\t%s\n", string2 + 10 );
memmove( string2 + 10, string2 + 4, 40 );
printf( "Result:\t\t%s\n", string2 );
printf( "Length:\t\t%d characters\n\n", strlen( string2 ) );

printf( "Function:\tmemcpy with overlap\n" );
printf( "Source:\t\t%s\n", string1 + 4 );
printf( "Destination:\t%s\n", string1 + 10 );
memcpy( string1 + 10, string1 + 4, 40 );
printf( "Result:\t\t%s\n", string1 );
printf( "Length:\t\t%d characters\n\n", strlen( string1 ) );
}


Output

Function: memcpy without overlap
Source: fox
Destination: dog jumps over the lazy fox
Result: The quick brown fox jumps over the lazy fox
Length: 43 characters

Function: memmove with overlap
Source: quick brown fox jumps over the lazy dog
Destination: brown fox jumps over the lazy dog
Result: The quick quick brown fox jumps over the lazy dog
Length: 49 characters

Function: memcpy with overlap
Source: quick brown dog jumps over the lazy fox
Destination: brown dog jumps over the lazy fox
Result: The quick quick brown dog jumps over the lazy fox
Length: 49 characters

[Emmanuel Delahaye]

Vous declarez

Code :

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

struct x *a_recopier;

C'est une définition et non une déclaration.

en faisant

Code :

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

sizeof(a_recopier)

vous obtenez la taille d'un pointeur et pas la taille de la structure

Comme le pointeur est typé, pour avoir la taille de l'objet pointé, il suffit de faire:

Code :

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

sizeof(*a_recopier)

[mitsein]

Enfin, si ton struct x contient des pointeurs (i.e. char * ou xxx *), vois s'il ne faut pas aussi les recopier (et donc malloc+copie) aussi. Ça, ça dépend de ton "algo", c'est-à-dire si tes "objets" pointés sont "partagés".

si j'ai

Code :

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

1
2
3
4
5
 
struct x{
char * toto;
struct * suivant;
}

qd je fais un memcpy de ma structure, ca me recopie pas le contenu de toto ? ou alors ta remarque ne concernait pas le memcpy() ?

[Emmanuel Delahaye]

Code :

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

1
2
3
4
5
 
struct x{
char * toto;
struct * suivant;
}

qd je fais un memcpy de ma structure, ca me recopie pas le contenu de toto ? ou alors ta remarque ne concernait pas le memcpy() ?

Si, le contenu des objets est recopié, mais je rappelle que le contenu d'un pointeur est une adresse. Donc recopier un pointeur ne fait que créer un nouveau pointeur qui pointe sur la même zone mémoire que le précedant (même adresse).

La zone pointée n'est évidemment pas recopiée comme par miracle..

[mitsein]

ok merci !