Généricité : manipulation de void *

Version imprimable

Bonjour,
J'aimerai savoir comment peut on manipuler des pointeurs pour en faire une utilisation générique.
Je voudrai par exemple, inverse la case 1 et la case 2 d'un tableau d'entier (sans le savoir, évidemment).
Code:

1 2 3 4 5 6 7 8 9 10 void inverse(void *tab, int nb_membre, int size){ // Inverser la case 1 et la case 2, par exemple // tab += size est impossible car pointeur de type void * } int main(){ int tab[] = {1,2,3}; inverser(tab,3,sizeof(int)); return 0; }
Merci d'avance pour vos réponses,

04/11/2009, 15h05
jabbounet

tu peux caster dans un type dont tu connais la taille est qui est un sous multiple de size.

Euh, Comme ca ?

Code:

1
2
3
4
5
6
7
 
char *temp = (char*)tab;
  char *temp2;
  temp+=size;
  temp2 = temp;
  temp+=size;
  *temp2 = *temp;

04/11/2009, 15h54
Médinoc
Dans ce genre de cas, pour être simple, je conseillerais de faire ta propre fonction avec un prototype similaire à memcpy().

Du genre:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 void MemSwap(void* pva, void *pvb, size_t n) { char *pa = pva; char *pb = pvb; while(n != 0) { char tmp = *pa; *pa = *pb; *pb = tmp; pa++; pb++; n--; } }
Et ensuite, appeler cette fonction avec les bons paramètres...

Salut,

Quelque chose comme ça ferait l'affaire?

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
int inverser(void* tab, size_t index1 , size_t index2, size_t size)
{
    void* temp_bloc = malloc(size);
    if(temp_bloc == NULL)
        return 1;
    memcpy(temp_bloc, tab + size * index1, size);
    memcpy(tab + size * index1, tab + size * index2, size);
    memcpy(tab + size * index2, temp_bloc, size);
    free(temp_bloc);
    return 0;
}
 
int main(void)
{
    int tab[] = {712, 314, -19};
    if(inverser(tab, 2 , 0, sizeof(int)) != 0)
        return 1;
    assert(tab[0] == -19);
    assert(tab[1] == 314);
    assert(tab[2] == 712);
    puts("P A S S E D !");
    return 0;
}

C'est vrai que c'est plus élégant avec la fonction de medinoc.

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
void MemSwap(void* pva, void *pvb, size_t n)
{
	char *pa = pva;
	char *pb = pvb;
	while(n != 0)
	{
		char tmp = *pa;
		*pa = *pb;
		*pb = tmp;
		pa++;
		pb++;
		n--;
	}
 
}
 
void inverser2(void* tab, size_t index1 , size_t index2, size_t size)
{
    MemSwap(tab + size * index1, tab + size * index2, size);
}
 
int main(void)
{
    int tab[] = {712, 314, -19};
    inverser2(tab, 2 , 0, sizeof(int));
    assert(tab[0] == -19);
    assert(tab[1] == 314);
    assert(tab[2] == 712);
    puts("P A S S E D !");
    return 0;
}

05/11/2009, 00h33
Amroth

Merci bien pour vos réponses !
Donc si j'ai bien compris, l'intérêt d'utiliser char * est qu'un char a pour taille un octet et que l'on peut donc manipuler tous les octets d'un type.
Je ne connaissais pas memcpy mais je n'ai pas le droit de l'utiliser, désolé.
Je n'ai pas le temps de coder tout ça ce soir (cette nuit) mais je pense que les informations que vous m'avez apporté feront l'affaire :D !

Note : Je ne connaissais ni assert ni puts non plus et ces fonctions ont l'air bien pratiques pour vérifier l'exécution d'un programme ! :D