Ma fonction memmove

Version imprimable

Ma fonction memmove

bonjour
J'ai fais une petite fonction memmove. Mais je ne sais pas ce qu'il cloche
si quelqu'un peut m'aider

Code:

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
33
34
35
36
37
38
39
#include <stdio.h>
void * memmove(void *,void * ,size_t );
 
int main()
{
char *s="abcdefghijklmnopqrstuvwxyz";
char d[26];
char *p=memmove(d,s,26);
printf("%s",d);
return (0);
}
 
void * memmove(void * dest,void * source ,size_t n)
{
	size_t i;
 
 
	if(&source!=&dest)
	{	if(&source>&dest)
		{
			for(i=0;i<n;i++)
			{
			dest[i]=dest[i];
 
			}
 
		}else
		{
 
			for((i=n-1);i>=0;i--)
			{
			dest[i]=source[i];
			}
 
 
		}
	}
	return dest;
}

d'avance merci.

Citation:

Envoyé par bird12358

d'avance merci.

Faut jamais remercier d'avance. Ca induit une obligation chez ton interlocuteur...
Citation:
Envoyé par bird12358
bonjour
J'ai fais une petite fonction memmove. Mais je ne sais pas ce qu'il cloche
si quelqu'un peut m'aider
Code:

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 33 34 35 36 37 38 39 #include <stdio.h> void * memmove(void *,void * ,size_t ); int main() { char *s="abcdefghijklmnopqrstuvwxyz"; char d[26]; char *p=memmove(d,s,26); printf("%s",d); return (0); } void * memmove(void * dest,void * source ,size_t n) { size_t i; if(&source!=&dest) { if(&source>&dest) { for(i=0;i<n;i++) { dest[i]=dest[i]; } }else { for((i=n-1);i>=0;i--) { dest[i]=source[i]; } } } return dest; }
:tagcode:

=> source et dest sont déjà des adresses. Faut pas de "&"
=> dest[i]=dest[i] => tu la sens bien cette instruction ???

Sinon pour plus de rapidité, vaut mieux éviter les [i] et passer par des pointeurs...

31/05/2008, 11h16
black_hole

re

merci de ta reponse mais ca me fait tjrs les meme erreur

mem.c:23: attention : dereferencing «void *" pointer
mem.c:23: attention : dereferencing «void *" pointer
mem.c:23: erreur: utilisation invalide d'expression void
mem.c:32: attention : dereferencing «void *" pointer
mem.c:32: attention : dereferencing «void *" pointer
mem.c:32: erreur: utilisation invalide d'expression void
make: *** [mem] Erreur 1
31/05/2008, 11h23
Sve@r

Citation:

Envoyé par bird12358

merci de ta reponse mais ca me fait tjrs les meme erreur

mem.c:23: attention : dereferencing «void *" pointer
mem.c:23: attention : dereferencing «void *" pointer
mem.c:23: erreur: utilisation invalide d'expression void
mem.c:32: attention : dereferencing «void *" pointer
mem.c:32: attention : dereferencing «void *" pointer
mem.c:32: erreur: utilisation invalide d'expression void
make: *** [mem] Erreur 1

Oui évidemment. J'aurais pu le remarquer (j'ai pas de compilo, je corrige juste à la lecture)
Etant donné que tu travailles avec des pointeurs void * donc des pointeurs universels, les éléments dest[i] sont de type "void" et ne sont pas manipulables. Le compilo ne sait pas que tu veux manipuler ici des octets. D'ailleurs l'opération[i] implique un déplacement d'éléments mais comme le compilo ne connait pas l'élément lui-même, il sait évidemment pas de combien d'octets faut décaler en mémoire pour atteindre l'élément [i].
Rappel de l'arithmétique des pointeurs: tab[i] => déplacement de i * sizeof(*tab) octets

Chaque fois que tu travailles sur var[i], vaut d'abord caster var en char * pour que var[i] soit vu comme char

Code:

((char*)dest)[i]=((char*)source)[i];

Ou alors tu utilises deux pointeurs de type char qui partent de source et dest et qui s'incrémentent (ou qui décrémentent selon le cas)

Il faut caster en char* pour pouvoir faire de l'arithmétique de pointeurs.
Essaie ce code corrigé:

Code:

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
33
34
35
36
37
38
39
40
#include <stdio.h>
 
void * memmove(void *,void const * ,size_t );
 
int main()
{
	char const *s="abcdefghijklmnopqrstuvwxyz";
	char d[27]; /* 26 lettres + caractère nul */
	char *p=memmove(d,s,27);
	printf("%s",d);
	return (0);
}
 
void * memmove(void * pvDest,void const * pcvSource, size_t n)
{
	char * pDest = pvDest;
	char const * pcSource = pcvSource;
	size_t i;
 
	if(pcSource!=pDest)
	{
		if(pcSource>pDest)
		{
			for(i=0 ; i<n ; i++)
			{
				pDest[i]=pcSource[i];
			}
		}
		else
		{
			/* Attention, un size_t est toujours >=0 
			for((i=n-1) ; i>=0 ; i--) */
			for(i=n ; i>0 ; i++)
			{
				pDest[i-1]=pcSource[i-1];
			}
		}
	}
	return dest;
}

31/05/2008, 12h20
black_hole

re

je vous remercie ma focntionne fonctionne lol

par contre la focntion memmove ne doit-elle pas deplacer une partie de la memoire (c 'est a dire n'importe quelle type de donnée)?
Dans ce cas ma fonction ne fait pas ce que memmove doit faire ?
31/05/2008, 13h33
gl

Citation:

Envoyé par Sve@r

Sinon pour plus de rapidité, vaut mieux éviter les [i] et passer par des pointeurs...

As-tu fait des mesures précises pour affirmer de telle chose ? Si oui dans quel contexte ?

Avec un compilateur à peu près potable, le code généré dans les deux cas devrait être grosso-modo le même et donc il ne devrait pas y avoir de différence en terme de rapidité.

Citation:

Envoyé par bird12358

par contre la focntion memmove ne doit-elle pas deplacer une partie de la memoire (c 'est a dire n'importe quelle type de donnée)?
Dans ce cas ma fonction ne fait pas ce que memmove doit faire ?

La fonction manipule bien n'importe quel type de donnée (en fait une zone mémoire), il n'y a pas de problème.
L'utilisation de char* permet juste de copier les byte de cette zone mémoire un par un sans interprétation particulière mais ne restreint pas l'utilisation de la fonction.
31/05/2008, 13h41
black_hole

re

je vous remercie de vos reponses .@++
31/05/2008, 16h34
souviron34

Citation:

Envoyé par gl

As-tu fait des mesures précises pour affirmer de telle chose ? Si oui dans quel contexte ?
.

Dés qu'il y a plus d'un indice

Si c'est tab[i], c'est équivalent

Si c'est tab[i*n+j] c'est incomparable. A chaque affectation on recalcule...

Donc si temps de calcul et nombre de données sont importants, beware :alerte:
31/05/2008, 18h42
gl

Citation:

Envoyé par souviron34

Si c'est tab[i], c'est équivalent

Si c'est tab[i*n+j] c'est incomparable. A chaque affectation on recalcule...

Déjà ici il n'y a qu'un indice "simple", donc pas de problème.

En outre même dans le cas d'indice complexe, l'éventuel souci ne sera pas lié à l'utilisation de [] plutôt que du pointeur mais au calcul des indices : tab[i*n+j] ne sera pas plus lent que *(tab+i*n+j).

Citation:

Envoyé par Médinoc

Essaie ce code corrigé:

Meuh ...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : D:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c:6: warning: function declaration isn't a prototype
main.c: In function `main':
main.c:9: warning: unused variable `p'
main.c: In function `memmove':
main.c:39: error: `dest' undeclared (first use in this function)
main.c:39: error: (Each undeclared identifier is reported only once
main.c:39: error: for each function it appears in.)
Process terminated with status 1 (0 minutes, 0 seconds)
3 errors, 2 warnings

Citation:
Envoyé par bird12358
J'ai fais une petite fonction memmove. Mais je ne sais pas ce qu'il cloche
si quelqu'un peut m'aider
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <stdio.h> void * memmove(void *,void * ,size_t ); int main() { char *s="abcdefghijklmnopqrstuvwxyz"; char d[26]; char *p=memmove(d,s,26); printf("%s",d); return (0); } void * memmove(void * dest,void * source ,size_t n) { size_t i; if(&source!=&dest) { if(&source>&dest) {
Je t'arrête toute de suite. Bug majeur de conception.

1 - On a pas le droit de donner à une fonction le nom d'une fonction existante (comportement indéfini). my_memmove() est OK.

2 - On ne peut comparer des pointeurs que si ils appartiennent au même objet. Il faut donc passer UNE adresse, un ou des indices et une longueur. Point.

Code:

void * my_memmove (void const* buffer, size_t from, size_t to, size_t n)

mais c'est une autre fonction

Pour memmove(), je ne sais pas si on peut la coder en C standard sans passer par un buffer relais alloué, ce qui n'est pas du tout efficace.

31/05/2008, 21h53
Sve@r
Citation:

Envoyé par gl

As-tu fait des mesures précises pour affirmer de telle chose ? Si oui dans quel contexte ?
...

En outre même dans le cas d'indice complexe, l'éventuel souci ne sera pas lié à l'utilisation de [] plutôt que du pointeur mais au calcul des indices : tab[i*n+j] ne sera pas plus lent que *(tab+i*n+j).

Moi je parlais de la différence qu'il y a entre
Code:

1 2 for (i=0; i < n; i++) <traitement de tab[i]>
Et
Code:

1 2 for (i=0, pt=tab; i < n; i++, pt++) <traitement de *pt>
:traine:

Citation:

Envoyé par Emmanuel Delahaye

2 - On ne peut comparer des pointeurs que si ils appartiennent au même objet

Ca je ne savais pas. Mais si on caste les pointeurs en char* lors de la comparaison ???
31/05/2008, 21h57
gl
Citation:
Envoyé par Sve@r

Moi je parlais de la différence qu'il y a entre

Code:

1 2 for (i=0; i < n; i++) <traitement de tab[i]>

Et

Code:

1 2 for (i=0, pt=tab; i < n; i++, pt++) <traitement de *pt>

:traine:

Ca je ne savais pas. Mais si on caste les pointeurs en char* lors de la comparaison ???
Et as-tu fait des mesures ?
C'est possible que ce soit, dans un contexte donne, plus rapide mais ce n'est pas du tout certain.
31/05/2008, 22h02
Sve@r

Citation:

Envoyé par gl

Et as-tu fait des mesures ?

Non. Je me base simplement sur certaines lectures faites dans certains bouquins. Mais je ne peux pas te citer le bouquin parce que pour moi ça fait partie de la masse inerte de "petits" trucs lus et marquants, accumulés au fil du temps...

Citation:

Envoyé par gl

C'est possible que ce soit, dans un contexte donne, plus rapide mais ce n'est pas du tout certain.

Nous pouvons essayer si tu veux. Lundi je suis au bureau et je ferai quelques tests sur une Fedora Core 7
31/05/2008, 23h19
orfix

Salut,

Concernant cette histoire de rapidité, ça me paraît assez logique !
l'accès séquentiel aux éléments d'un tableaux via un pointeur est plus rapide vu que :

Citation:

i++, tab[i] => adresse de tab + i * taille d'un élément
p_tab++, *p_tab => adresse contenu dans p + taille d'un élément

Il est clair qu'avec le tab[i] on se retrouve avec une multiplication de plus et ceux à chaque itération ...
mais je n'affirme rien ceci reste à prouver :oops:
@++
01/06/2008, 02h44
Emmanuel Delahaye

Citation:

Envoyé par Sve@r

Ca je ne savais pas. Mais si on caste les pointeurs en char* lors de la comparaison ???

Ca n'a aucun rapport. C'est pas un problème de type mais de bon sens. Une comparaison de pointeurs n'a de sens que si les pointeurs pointent sur le même objet (et ça, c'est invérifiable).

C'est pourquoi si on tien à faire ça, il faut passer une adresse et des indices. (et éventuellement une taille, une longueur...). mais UN SEUL pointeur. Si il y en a deux, on ne sait pas dire si ils pointent sur le même objet (j'ai utilisé le mot 'appartiennent', qui n'est pas très clair...)

Citation:

Envoyé par ssmario2

Salut,

Concernant cette histoire de rapidité, ça me paraît assez logique !
l'accès séquentiel aux éléments d'un tableaux via un pointeur est plus rapide vu que :

Il est clair qu'avec le tab[i] on se retrouve avec une multiplication de plus et ceux à chaque itération ...
mais je n'affirme rien ceci reste à prouver :oops:
@++

La technique consistant à remplacer une multiplication par un indice de boucle par une nouvelle variable incrémentée de manière adéquate est une optimisation bien connue ("strength reduction").
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 long double s1(long double* t, int c) { long double r = 0; int i; for (i = 0; i < c; ++i) { r += t[i]; } return r; } long double s2(long double* t, int c) { long double r = 0; int i; for (i = 0; i < c; ++i, ++t) { r += *t; } return r; }
génère
Code:

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 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 .globl s1 .type s1, @function s1: pushl %ebp movl %esp, %ebp movl 12(%ebp), %ecx testl %ecx, %ecx jle .L9 movl 8(%ebp), %eax fldz xorl %edx, %edx .p2align 4,,7 .L5: fldt (%eax) addl $1, %edx addl $12, %eax cmpl %ecx, %edx faddp %st, %st(1) jne .L5 popl %ebp ret .L9: popl %ebp fldz ret .size s1, .-s1 .p2align 4,,15 .globl s2 .type s2, @function s2: pushl %ebp movl %esp, %ebp movl 12(%ebp), %ecx movl 8(%ebp), %eax testl %ecx, %ecx jle .L17 fldz xorl %edx, %edx .p2align 4,,7 .L14: fldt (%eax) addl $1, %edx addl $12, %eax cmpl %ecx, %edx faddp %st, %st(1) jne .L14 popl %ebp ret .L17: popl %ebp fldz ret
et il n'y a pas de différence de code généré dans le corps de la boucle. J'utilise des long double, parce qu'avec des types de taille 4 ou 8, gcc a tendance à utiliser le mode d'adressage indexé avec facteur de mise à l'échelle pour les accès avec indice et donc le code généré n'est pas le même, mais je n'ai aucune idée a priori du meilleur.

01/06/2008, 17h15
Sve@r

Citation:

Envoyé par Emmanuel Delahaye

Ca n'a aucun rapport. C'est pas un problème de type mais de bon sens. Une comparaison de pointeurs n'a de sens que si les pointeurs pointent sur le même objet (et ça, c'est invérifiable).

Mais si on considère le but de la fonction écrite ? En lisant son code, on sent bien que c'est une fonction destinée à copier une zone mémoire dans une autre zone mémoire octet par octet et ce, sans se préoccuper de l'objet situé au bout de la source. Et pour éviter l'effet de bord dû à un chevauchement, il teste si la zone n° 1 commence avant ou après la zone n° 2. En fait, on pourrait écrire cette fonction avec des char *, cela semblerait presque plus logique (et reviendrait aux bons vieux char * utilisés comme pointeurs universels de nos débuts)