Discussion :

[Amroth]

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 :

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

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,

[jabbounet]

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

[Amroth]

Euh, Comme ca ?

Code :

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

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

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

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

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

[pfeuh]

Salut,

Quelque chose comme ça ferait l'affaire?

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

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

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

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 !