C - shared structs

[Gast]

Hallo,

ich hab ein kleines C Problem:


struct testStruct;

int sharedFunction( struct testStruct *eingabe ) {
/* mach was mit eingabe */
}


int oans() {

struct testStruct {
int einInt;
} testStruct1;
return sharedFunction( &testStruct1 );
}


int zwoa() {
struct testStruct {
char einChar;
} testStruct2;

return sharedFunction( &testStruct2 );
}

int main( void ) {
oans();
zwoa();
return 0;
}

Der Compiler meckert natürlich das die Zeigertypen nicht übereinstimmen.
Wie kann man so etwas am Besten in C implementieren?
Varianten (unions) sind mir zu "häßlich".

[Xmas]

Inwiefern sind unions "hässlich" (bzw. hässlicher als das was du versuchst)? Und wie soll sharedFunction mit testStruct irgendwas anfangen ohne zu wissen wie die struct aussieht?

[Trap]

int sharedFunction( char* eingabe, size_t size ) {
/* mach was mit eingabe */
}

In sharedFuntion darf man auf eingabe nur über char* zugreifen, das ist im C-Standard der einzige Typ mit dem man typfalsch auf Speicher zugreifen darf.

[Gast]

Inwiefern sind unions "hässlich" (bzw. hässlicher als das was du versuchst)?
Wenn ich nun viele Daten in den structs habe, werden die unions ziemlich groß. Außerdem müssen unions global an einer Stelle im Code deklariert werden.
z.B.

union testStruct {
int einInt;
char einChar;
struct test{
/* ...*/
}
struct nochEins {
/* ... */
}
/* ... */
}



[QUOTE=Xmas;6791980]
Und wie soll sharedFunction mit testStruct irgendwas anfangen ohne zu wissen wie die struct aussieht?
Genau das ist ja meine Frage :-)
void* Zeiger wären vielleicht noch eine Option?
Vielleicht kann man die structs irgendwie vorwärts deklarieren?

[Trap]

In unions darf man auch nur auf das Element lesend zugreifen, das zuletzt geschrieben wurden.

Was willst du eigentlich genau machen? Es gibt nicht so viele sinnvolle Sachen, die man mit allen Datentypen exakt gleich implementiert.

[Gast]

In unions darf man auch nur auf das Element lesend zugreifen, das zuletzt geschrieben wurden.

Was willst du eigentlich genau machen? Es gibt nicht so viele sinnvolle Sachen, die man mit allen Datentypen exakt gleich implementiert.

Also sharedFunction (hat eigentlich 7 Parameter) berechnet einen Funktionszeiger.
Die Funktion auf die der berechnete Funktionszeiger zeigt, hat (hoffentlich) einen Parameter vom Typ der übergebenen Struktur.

Übrigens, wenn ich das nach (void*) caste meckert wenigstens der Compiler nicht.

sharedFunction( (void*) &testStruct2 )

Kann man das so machen?

[Trap]

Ja, void* ist der übliche Typ, wenn man sowas macht.

[Xmas]

Außerdem müssen unions global an einer Stelle im Code deklariert werden.
Das kann auch nicht anders funktionieren, schließlich muss der Compiler wissen wie die struct aussieht wenn er den Code für die Funktion generiert.

Also sharedFunction (hat eigentlich 7 Parameter) berechnet einen Funktionszeiger.
Die Funktion auf die der berechnete Funktionszeiger zeigt, hat (hoffentlich) einen Parameter vom Typ der übergebenen Struktur.
Es scheint mir dass du eine Funktion willst die sich je nach übergebenem Typ anders verhält. In dem Fall wären Templates (C++) eine Möglichkeit.

[Gast]

Ja, void* ist der übliche Typ, wenn man sowas macht.
Gabs/gibts da keine Nachteile beim (void*)-casting?
Ich meine mich dunkel an etwas zu erinnern?

Das kann auch nicht anders funktionieren, schließlich muss der Compiler wissen wie die struct aussieht wenn er den Code für die Funktion generiert.
Es scheint mir dass du eine Funktion willst die sich je nach übergebenem Typ anders verhält. In dem Fall wären Templates (C++) eine Möglichkeit.
Könnte man so sagen! C++ fällt leider raus. Das wird vom Compiler für die Zielplattform nicht unterstützt.

[Xmas]

Könnte man so sagen! C++ fällt leider raus. Das wird vom Compiler für die Zielplattform nicht unterstützt.
Dann wird dir kaum eine andere Möglichkeit bleiben als eine eindeutige Typ-ID als Parameter zu übergeben.

[Gast]

Dann wird dir kaum eine andere Möglichkeit bleiben als eine eindeutige Typ-ID als Parameter zu übergeben.
Typ-ID? Wie würde das denn aussehen?

[Gauß]

Typ-ID? Wie würde das denn aussehen?Du uebergibst einfach typneutrale Daten(-zeiger) und eine irgendwie geartete Information ueber den Datentyp. Den typbedingten Programmcode verzweigst du dann entsprechend.

void MeineFunktion(const void* daten, unsigned short meinTyp)
{
...
if(meinTyp == TYP1) ...
else ...
}