Comment faire une fonction générique en utilisant void * dans c?

Vous pouvez mettre en œuvre la première comme une macro:

#define incr(x) (++(x))

Bien sûr, cela peut avoir des effets secondaires désagréables si vous ne faites pas attention. Il s'agit de la seule méthode C, pour la même opération pour toute une variété de types. En particulier, depuis la macro est mis en œuvre à l'aide du texte de substitution, le temps que le compilateur voit, il vous suffit de le littéral code ++whatever;et elle peut s'appliquer à ++ correctement pour le type d'élément que vous avez fournis. Avec un pointeur sur void, vous ne savez pas beaucoup (le cas échéant) sur le type réel, de sorte que vous ne pouvez pas faire beaucoup de manipulation directe sur les données).

void * est normalement utilisée lorsque la fonction en question n'a pas vraiment besoin de connaître le type exact des données en cause. Dans certains cas (par exemple, qsort), il utilise une fonction de rappel pour éviter d'avoir à connaître tous les détails des données.

Depuis qu'il fait à la fois de tri et de swap, regardons qsort un peu plus en détail. Sa signature est:

void qsort(void *base, size_t nmemb, size_t size,
           int(*cmp)(void const *, void const *));

Donc, la première est la void * vous m'avez demandé -- un pointeur vers les données à trier. Le second raconte qsort le nombre d'éléments dans le tableau. La troisième, la taille de chaque élément dans le tableau. Le dernier est un pointeur vers une fonction qui permet de comparer des éléments individuels, de sorte qsort n'a pas besoin de savoir comment le faire. Par exemple, quelque part à l'intérieur de qsort sera un peu de code quelque chose comme:

//if (base[j] < base[i]) ...
if (cmp((char *)base+i, (char *)base+j) == -1)

De même, pour échanger deux éléments, il va normalement avoir un tableau pour le stockage temporaire. Il va ensuite copier les octets de array[i] à son temp, puis à partir de array[j] à array[i] et enfin à partir de temp à array[j]:

char temp[size];

memcpy(temp, (char *)base+i, size);              //temp = base[i]
memcpy((char *)base+i, (char *)base+j, size);    //base[i] = base[j]
memcpy((char *)base+j, temp, size);              //base[j] = temp

Vous ne pouvez pas faire exactement ce que vous demandez - opérateurs comme incrément besoin de travailler avec un type spécifique. Donc, vous pourrait faire quelque chose comme ceci:

enum type { 
    TYPE_CHAR,
    TYPE_INT,
    TYPE_FLOAT
};

void incr(enum type t, void *vp)
{
    switch (t) {
        case TYPE_CHAR:
        (*(char *)vp)++;
        break;

        case TYPE_INT:
        (*(int *)vp)++;
        break;

        case TYPE_FLOAT:
        (*(float *)vp)++;
        break;
    }
}

Alors il faudrait l'appeler comme:

int i=5;
float f=5.6f;
char c='a';

incr(TYPE_INT, &i);
incr(TYPE_FLOAT, &f);
incr(TYPE_CHAR, &c);

Bien sûr, ce n'est pas vraiment vous donner quelque chose de plus juste définition distincte incr_int()incr_float() et incr_char() fonctions - ce n'est pas le but de la void *.

Le but de void * est réalisée que lorsque l'algorithme que vous avez écrit n'est pas le type réel de l'objet. Un bon exemple est le standard de la fonction de tri qsort()qui est déclarée comme:

void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *));

Ceci peut être utilisé pour trier des tableaux de n'importe quel type d'objet - l'appelant a juste besoin de fournir une fonction de comparaison qui permet de comparer deux objets.

À la fois votre swap() et sort() fonctions entrent dans cette catégorie. swap() est encore plus facile - l'algorithme n'a pas besoin de savoir autre chose que de la taille des objets à échanger:

void swap(void *a, void *b, size_t size)
{
    unsigned char *ap = a;
    unsigned char *bp = b;
    size_t i;

    for (i = 0; i < size; i++) {
        unsigned char tmp = ap[i];

        ap[i] = bp[i];
        bp[i] = tmp;
    }
}

Maintenant, compte tenu de tout réseau, vous pouvez échanger les deux éléments dans ce tableau:

int ai[];
double ad[];

swap(&ai[x], &ai[y], sizeof(int));
swap(&di[x], &di[y], sizeof(double));

Vous devriez jeter votre pointeur de type de béton avant d'être déréférencé. Donc, vous devriez également ajouter du code pour passer quel est le type de pointeur de variable.

Vous pouvez utiliser le type générique installations (C11 standard). Si vous avez l'intention d'utiliser plus avancés des fonctions mathématiques (plus avancé que la ++ opérateur), vous pouvez aller à <tgmath.h>qui est de type générique définitions de fonctions dans <math.h> et <complex.h>.

Vous pouvez également utiliser le _Generic mot clé pour définir un type générique de la fonction macro. Ci-dessous un exemple:

#include <stdio.h>

#define add1(x) _Generic((x), int: ++(x), float: ++(x), char: ++(x), default: ++(x))

int main(){
  int i = 0;
  float f = 0;
  char c = 0;

  add1(i);
  add1(f);
  add1(c);

  printf("i = %d\tf = %g\tc = %d", i, f, c);
}

Vous pouvez trouver plus d'informations sur le la langue standard et plus soffisticated exemples dans ce post de Rob programmation du blog.

Comme pour le * voidd'échanger et de tri des questions, mieux de se référer à Jerry Cercueil's réponse.