Übergeben Void-Typ-parameter in C

Erste, den Sie übergeben, in einen Zeiger auf void, das ist ein Gültiger Ansatz für die unbekannten Typen, aber Sie müssen auch übergeben Zeiger auf die verschiedenen Objekt-Typen.

C ist nicht eine dynamische Sprache ist also symbolischer Art von Informationen ist weitgehend gelöscht, bevor Sie laufen der Zeit so, wenn Sie sagen, dass Ihr alle drei Arten haben ein Mitglied Count dies nicht helfen, mit Ihrer Funktion design.

Nur so können Sie den Zugriff Count ist durch Gießen Ihre void* parameter den richtigen Typ Zeiger vor derefencing mit -> oder (*element).Count (d.h. nicht nur .).

Es sei denn, Sie verlassen sich auf Ihre Typen mit einem kompatiblen layout (das ist wahrscheinlich implementierungsabhängig), werden Sie auch brauchen, um passieren etwas, das hilft, Ihre Funktion zu bestimmen, die richtige Besetzung zu führen. An dieser Stelle sollten Sie vielleicht besser mit drei separaten Funktionen und bessere Art Sicherheit.

Wenn die .Count element des gleichen Typs für jede dieser 3 Arten, dann kannst du auch ein makro verwenden. Vorausgesetzt, es ist eine int, die Sie dies tun können:

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

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

Dies funktionieren wird, weil die a.Count - Adresse aufgelöst werden kann, wenn Sie die Funktion aufrufen, nicht nach (wenn Sie nicht wissen, den Typ nicht mehr). Ich gehe davon aus, dass Sie den richtigen Typ aus, wenn Sie die Funktion aufrufen, obwohl. So Sometype x; changeCount(x); funktioniert, sondern übergeben Sie in etwas, das schon ein (void*) nicht.

Auch Ihrem ursprünglichen Ausdruck element.Count = element.Count++; ist eher Bizarr. Wenn Sie erhöhen wollen, verwenden Sie element.Count++ oder element.Count = element.Count + 1.

Beim kompilieren, C verwirft[1] die meisten Typ-Informationen, so dass nur offsets. So, Ihrer Funktion kompilieren, um so etwas wie dieses, in pseudocode:

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

Den stack_ptr ist die Lage des stack-Frames, die erstellt wurde, wenn Sie anrufen, changeCount, die offset_element ist der Speicherort des Elements argument, relativ zu der stack_ptr, aber was ist offset_Count? Denken Sie daran, alle der compiler kennt dein code ist genau das, was Sie gezeigt haben in Ihrem Beispiel; element ist ein generischer Zeiger, nicht wirklich ein Zeiger auf etwas. Sie sagen dem compiler mit, welche element verweist, durch Gießen oder durch zuweisen an eine variable[2]:

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

Diese Funktion erzeugt im wesentlichen die gleiche (pseudo -) code wie oben, aber der compiler jetzt weiß, was die offset-Zählung sein sollten.

Du erwähnen, dass es drei Möglichkeiten für die Art von was-element verweist. Es gibt ein paar Möglichkeiten, handling: entweder ein angesehener union oder eines "vererbt" - Struktur. Für eine definierte union verwenden, sagen wir, eine Struktur mit einem element einer Enumeration ermitteln, welche der drei Möglichkeiten und ein anderes element eine union der drei möglichen Strukturen; dies ist ungefähr das, was die ML-Sprachen (OCaml, Haskell, etc.) rufen Sie einen algebraischen Datentyp oder was eine Gewerkschaft ist in Pascal. Für die "Vererbung", könnten Sie Typ-Definitionen:

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;

In diesem Fall könnten Sie die changeCount die oben beschriebene Funktion auf und übergeben Sie einen Zeiger auf eine counted_int_t, counted_double_t, oder counted_charptr_t.

Was passiert, ist, dass der compiler legt die drei Strukturen mit der Anzahl element in der "Nachkomme" Strukturen an der gleichen Stelle solange die counted_t element ist erste. (Zumindest in alle compiler, die ich je benutzt habe, und in jedem bit der code, den ich gesehen habe. Ich denke, das es in der C-standard an einem gewissen Punkt, aber es ist eine ganz normale Redewendung.)

[1] Außer für die debugging-Informationen, wenn Sie gesagt haben, der compiler emittiert es. Ihr Programm keinen Zugriff auf diese Informationen, aber es würde nicht helfen in diesem Fall.

[2] x++ (post-Inkrement) operation inkrementiert die variable (gut, lvalue), dass es angewendet wird; die Abtretung im original-code ist nicht notwendig.