Passage de paramètre de type Void en C

Tout d'abord, vous êtes de passage dans un pointeur sur void, qui est une approche valable pour les types inconnus, mais vous avez besoin de passer des pointeurs à vos différents types d'objet.

C n'est pas un langage de programmation dynamique, de type symbolique de l'information est en grande partie supprimés avant l'exécution quand vous dites que vos trois types ont tous un membre Count ce n'est pas vous aider avec votre fonction de conception.

La seule façon vous pouvez accéder à Count est par moulage de votre void* paramètre pour le bon type de pointeur avant derefencing avec -> ou (*element).Count (c'est à dire pas seulement .).

Moins que vous ne comptiez sur votre types ayant un compatible de mise en page (ce qui est susceptible d'être dépendant de l'implémentation), vous devrez également passer quelque chose qui aide votre fonction de déterminer la fonte à effectuer. À ce stade, vous pourriez être mieux avec trois séparée des fonctions et une meilleure sécurité de type.

OriginalL'auteur CB Bailey

Si le .Count élément est du même type pour chacun de ces 3 types, alors vous pouvez également utiliser une macro. En supposant que c'est int, vous pouvez le faire:

#define changeCount(a) _changeCount((a), &(a)->Count)

int _changeCount(void* element, int *count)
{
  (*count)++;
  return 1;
}

Cela va fonctionner, parce que le a.Count la résolution de l'adresse lorsque vous appelez la fonction, pas après (quand vous ne connaissez pas le type plus). Je suppose que vous avez le bon type lorsque vous appelez la fonction si. Donc Sometype x; changeCount(x); de travail, mais en passant dans quelque chose qui est déjà un (void*) ne sera pas.

Aussi l'expression originale element.Count = element.Count++; est plutôt bizarre. Si vous voulez incrémenter, utilisez element.Count++, ou element.Count = element.Count + 1.

OriginalL'auteur viraptor

Lors de la compilation, C rejets[1] la plupart des informations de type, ne laissant que des décalages. Donc, votre fonction serait de compiler quelque chose comme cela, en pseudo-code:

changeCount:
  assign *(*(stack_ptr + offset_element) + offset_Count) + 1
    to *(stack_ptr + offset_element) + offset_Count;
  assign 1 to return_value;
  pop

La stack_ptr est l'emplacement du cadre de la pile qui a été créé lorsque vous appelez changeCount, le offset_element est l'emplacement de l'argument de l'élément, par rapport à la stack_ptr, mais qu'est-ce que offset_Count? Gardez à l'esprit, tout le compilateur sait au sujet de votre code est exactement ce que vous avez indiqué dans votre exemple; l'élément est un pointeur générique, pas vraiment un pointeur vers quoi que ce soit. Vous devrez dire au compilateur quel élément pointant vers, par moulage ou de l'affecter à une variable[2]:

typedef struct { int Count; } counted_t;
int changeCount(void* element)
{
    counted_t* counted = element;
    counted.Count++;
    return 1;
}

Cette fonction génère essentiellement le même (pseudo -) code comme ci-dessus, mais le compilateur sait maintenant ce que le décalage de Comptage doit être.

Vous mentionner qu'il y a trois possibilités pour le type de ce que l'élément de pointe. Il ya un couple de façons de traiter le que: soit distingué de l'union ou d'un "hérité" de la structure. Pour un distingué de l'union de l'utilisation, de dire, une structure avec un élément d'une énumération de déterminer laquelle de ces trois possibilités et un autre élément d'une union des trois structures possibles; c'est à peu près ce que le ML langues (OCaml, Haskell, etc.) l'appel d'un type de données algébrique ou ce qu'un syndicat est en Pascal. Pour "l'héritage", vous pouvez utiliser les définitions de type:

typedef struct { counted_t counted; int i; } counted_int_t;
typedef struct { counted_t counted; double d; } counted_double_t;
typedef struct { counted_t counted; char* s; } counted_charptr_t;

Dans ce cas, vous pouvez utiliser le changeCount fonction ci-dessus et de passer un pointeur vers une counted_int_t, counted_double_t, ou counted_charptr_t.

Ce qui se passe est que le compilateur va poser les trois structures avec le nombre d'élément dans le "descendant" des structures dans le même endroit tant que le counted_t élément est d'abord. (Au moins, dans chaque compilateur, je n'ai jamais utilisé et dans tous les bits de code que j'ai vu. Je pense que ce qu'il fait dans la norme C à un certain point, mais il est tout à fait normal idiom.)

[1], Sauf pour les informations de débogage, si vous avez dit au compilateur de l'émettre. Votre programme n'auront pas accès à cette information, bien que, de sorte qu'il ne serait pas utile dans ce cas.

[2] Le x++ (post-incrémentation) opération d'incrémentation de la variable (bien, lvalue) qu'elle est appliquée; l'affectation dans le code d'origine est inutile.

OriginalL'auteur Tommy McGuire