Discussion :

[black_hole]

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

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
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.

[Sve@r]

d'avance merci.

Faut jamais remercier d'avance. Ca induit une obligation chez ton interlocuteur...

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

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
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;
}

=> 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...

[black_hole]

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

[Sve@r]

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 :

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

((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)

[Médinoc]

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

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
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;
}

[black_hole]

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 ?

[gl]

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é.

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.

[black_hole]

je vous remercie de vos reponses .@++

[souviron34]

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

[gl]

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).

[Emmanuel Delahaye]

Essaie ce code corrigé:

Meuh ...

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
 
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

[Emmanuel Delahaye]

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

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
#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 :

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

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.

[Sve@r]

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 :

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

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

Et

Code :

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

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

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 ???

[gl]

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

Code :

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

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

Et

Code :

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

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

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.

[Sve@r]

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...

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

[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 :

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
@++

[Emmanuel Delahaye]

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...)

[Jean-Marc.Bourguet]

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
@++

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 :

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
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 :

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
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.

[Sve@r]

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)