C Funktion mit Parametern unterschiedlichen Datentyps

[Michael L. (eagle87)]

Hallo zusammen,
gibt es in C die Möglichkeit eine Funktion mit unterschiedlichen 
Datentypen auszuführen?

Beispiel:

uint8_t inc(uint16_t *var, uint16_t bottom, uint16_t top)
{
  if(*var<top)
  {
    ++(*var);
    return 0;
  }
  else
  {
    *var=bottom;
    return 1;
  }
}

Diese Funktion will ich mit uint8_t und uint16_t Variablen als 
Übergabeparameter ausführen können.

Gruß
Michael

[Peter II (Gast)]

Michael L. schrieb:
> gibt es in C die Möglichkeit eine Funktion mit unterschiedlichen
> Datentypen auszuführen?

für diesen zweck nicht wirklich. Hier könnte man sogar über ein Makro 
nachdenken, dann ist der type egal.

[Michael L. (eagle87)]

Hallo Peter,
wie würde das mit dem Makro gehen? Ich brauch nämlich einen 
Rückgabewert.

#define  inc(var, bottom, top)  ({if( (var) < (top) ){++(var); return 0;}  else{(var) = (bottom); return 1;} })

liefert

warning: ‘return’ with a value, in function returning void

und

error: lvalue required as left operand of assignment

Gruß
Michael

[Peter II (Gast)]

#define inc(var, bottom, top) ( (var) < (top) ? ++var, 0 : var = bottom, 
1 )

ungetestet

[Michael L. (eagle87)]

Geht leider auch nicht.

games/X01.c:135:5: error: lvalue required as left operand of assignment
games/X01.c:135:8: warning: left-hand operand of comma expression has no effect
games/X01.c:135:5: error: lvalue required as left operand of assignment
games/X01.c:135:41: warning: left-hand operand of comma expression has no effect
games/X01.c:135:41: warning: statement with no effect

Der Aufruf sieht übrigens so aus:

if(inc(player, 1, numberofplayers)) inc(lap, 1, 99);

[Peter II (Gast)]

so geht es bei mir durch den Compiler, ob es geht habe ich nicht 
getestet

#define inc(var, bottom, top) ( (var) < (top) ? var++, 0 : (var=bottom, 
1) )

[Dr. Sommer (Gast)]

Und deswegen gibt es C++ und Meta-Programmierung:

template <typename T>
bool inc (T& var, T bottom, T top) {
  if (var < top) {
    var++;
    return false;
  } else {
    var = bottom;
    return true;
  }
}

Aufzurufen z.B. so:

uint8_t bla;
if (inc (bla, 2, 27)) {
}

oder:

uint16_t bla;
if (inc (bla, 2, 2217)) {
}

Oder beliebigen anderen Integer-Typen. Im Endeffekt wird für jeden 
angebenen Typ eine eigene Funktion speziell für diesen Typ erzeugt, die 
dann auch entsprechend effizient ist.

Dies ist dann auch typsicher, d.h. so etwas wird vom Compiler 
angemeckert:

uint8_t bla;
if (inc (bla, 2, 2217)) {
}

und hat einen eigenen Scope und Typ, im Gegensatz zum Makro, und ist 
deswegen vorzuziehen.

[Peter II (Gast)]

Dr. Sommer schrieb:
> Und deswegen gibt es C++ und Meta-Programmierung:

er wollte aber

> gibt es in C die Möglichkeit

[Dr. Sommer (Gast)]

Peter II schrieb:
> er wollte aber
>
>> gibt es in C die Möglichkeit
Diese Anforderung hat er vermutlich nur angegeben weil er kein C++ 
kannte; er kann mit großer Wahrscheinlichkeit einfach seinen Code mit 
einem C++ Compiler compilen und die C-Kompatibilität von C++ nutzen.

[Michael L. (eagle87)]

@Peter:
Jetzt kompilierts bei mir auch ohne Fehler und Warnung. Die Klammer um 
"var=bottom, 1" hat geholfen. Testen werd ichs aber heute nicht mehr. 
Vielen Dank für die Hilfe.

@Dr. Sommer:
Dass es in C++ mehr Möglichkeiten gibt war schon bekannt. Es ging 
wirklich explizit um C. Dennoch danke für den Post.

[Rosa-Kleidchen (Gast)]

Ich wuerde einen void-pointer verwenden (void *var).
Rosa

[Peter II (Gast)]

Rosa-Kleidchen schrieb:
> Ich wuerde einen void-pointer verwenden (void *var).
> Rosa

und dann weiter? wie willst du mit einen void inrement machen?

[Rosa-Kleidchen (Gast)]

Übergebe einen Void-Pointer und carste das dann in der Funktion abhängig 
von dem, was Du erwartest:

int8 var8;
int16 var16;

void myFunction (void *var, int kind) {
  if (0 == kind) {
    int8 var8 = (int8) *var;
    ...
  } else {
    int16 var16 = (int16) *var;
    ...
  }
  ...
}


myFunction ((void *) &var8, 0);
myFunction ((void *) &var16, 1);

Rosa

[type cast (Gast)]

Rosa-Kleidchen schrieb:
> carste

Grüße an Cartsen ...

[Sven P. (Gast)]

Rosa-Kleidchen schrieb:
> int8 var8;
> int16 var16;
>
> void myFunction (void *var, int kind) {
>   if (0 == kind) {
>     int8 var8 = (int8) *var;
>     ...
>   } else {
>     int16 var16 = (int16) *var;
>     ...
>   }
>   ...
> }

Das geht in die Hose.

[Peter II (Gast)]

Rosa-Kleidchen schrieb:
> Übergebe einen Void-Pointer und carste das dann in der Funktion abhängig
> von dem, was Du erwartest:

naja, aber dann kann man auch gleich 2 Funktionen schreiben.

[Rosa-Kleidchen (Gast)]

>Das geht in die Hose.
Jau, ist nur exemplarisch. Ich vergass den rechtlichen Hinweis.

[Dr. Sommer (Gast)]

Rosa-Kleidchen schrieb:
> Übergebe einen Void-Pointer und carste das dann in der Funktion abhängig
> von dem, was Du erwartest:
Diese C-Ineffizienz... Langsamer und am Ende auch noch größer als die 
C++ Template Version... Typunsicher sowieso.

Michael L. schrieb:
> Es ging
> wirklich explizit um C. Dennoch danke für den Post.
Wenn das nicht gerade eine Hausaufgabe ist in der steht "schreiben Sie 
in C..." gibt es eigentlich kaum einen Grund nicht einfach mit C++ zu 
compilen, die template-Funktion reinzuschreiben und den ganzen 
restlichen Code zu lassen wie er ist...

[Andreas B. (andreas_b77)]

Rosa-Kleidchen schrieb:
>     int8 var8 = (int8) *var;

Einen void* kann man nicht dereferenzieren. Wenn schon, dann

int8_t var8 = *(int8_t *)var;

> myFunction ((void *) &var8, 0);

Casts sind hier unnötig. Umwandlungen zwischen void* und anderen 
Pointern funktioneren auch ohne.