Wie kann ich eine Funktion erstellen, die einen parameter nimmt, unbekannter Typ in C?

Sagen, ich habe den folgenden code:

struct test* t1;
t1 = get_t(1);

... wo get_t ist:

struct test* get_t(int);

Wie kann ich umgestalten, den obigen code, und legte es in eine Funktion? So etwas wie die folgenden:

void r1(?* t, ?* (fn*)(int)) {
    t = fn(1);
}

/* ... */

struct test* t1;
r1(t1, &get_t);

Nun könnte man verwenden void r1(struct test* t, struct test* (fn*)(int))... warum ist der parameter der unbekannten geben?
Da möchte ich die gleiche Funktion für einen, sagen wir, struct another_test. Ebenso habe ich struct test* t1 und verwenden r1(t1, &get_t), ich möchte in der Lage sein, auch struct another_test* t2 und verwenden r1(t2, &get_at), wo get_at zurück struct another_test*, und die gleichen Dinge tut, um es zu erhalten.

InformationsquelleAutor rid | 2011-05-17

c types

4

verwenden void *param ein Zeiger auf etwas ... Häufig in der glib als gpointer
- Wenn ich definieren r1 als void r1(void* t, void* (fn*)(int)), und der compiler beschwert sich, dass ich gebe es nicht die richtige Funktion, da mein get_t - Funktion gibt eine struct test*.
- get_t muss zurück void * als gut.
- Sie müssen Ihre get_t Funktion entsprechend zu. Muss die Signatur zu ändern, aber Ihre Implementierung kann davon ausgehen, dass die Parameter sind der Typ, den Sie benötigt.
- Aha, also ist der einzige Weg, dies zu tun ist, um get_t Gegenzug eine void*?
- Das ist die einzige Möglichkeit, die ich kenne und die ich immer sehen, dass dieses Problem gelöst werden.
- Void-Zeiger ist in der Tat der einzige Weg, um schreiben kompletten generischen code in C. Es sollte auch darauf hingewiesen werden, dass der einzige Fall, wo Sie wirklich brauchen, zu schreiben, wie generische code, ist bei der Gestaltung abstrakter code-Module, wie ADTs und suchen/Sortieren algoritms. Wenn Sie feststellen, selbst benötigen völlig generischen code in jeder anderen situation sind, sollten Sie vielleicht überdenken Sie Ihre Programm-Entwurf.
- Sollte void **t argument und *t = fn(1); Zuordnung. Die Nutzung ist dann r1(&t1,&get_t) so dass t1 zugeordnet ist.
- fühlen Sie sich frei zu Bearbeiten, zu beantworten und zu verbessern. Prost !
- Ich fand mich zu wiederholen, den gleichen code in vielen Funktionen, und ich brauche, um zu TROCKNEN es. Also wollte ich entpacken Sie es in einer anderen Funktion. Wenn das war OOP, ich würde erweitert haben und eine Klasse, in der ich definieren würde, eine Methode, dies zu tun. Eine alternative wäre ein makro, das ist aber eine sehr hässliche Lösung.
- Ich bezweifele sehr, dass es tatsächlich "trocken" nichts. Nie vorstellen void-Zeiger aus Gründen der besseren Lesbarkeit! Ich kann fast cerntainly garantieren, dass es Ihren code zu verschleiern und machen es weniger lesbar.
- es würde entfernen Sie code-Wiederholungen (TROCKEN), und das ist es, was ich meinte TROCKEN. Es ist nicht für die Lesbarkeit, aber für die Wartbarkeit. Aber ich Stimme mit Ihnen überein, wenn es das erfordert die Verwendung von void-Zeigern, dann ist es wahrscheinlich nicht Wert.
InformationsquelleAutor Manuel Salvadores

Habe ich zwei Ideen:

[1] Pass void Zeiger auf die variable/Objekt-und Typ-cast in der Funktion.

[2] eine Vereinigung aller Datentypen zusammen mit einem integer-Datentyp, die identifizieren, welcher Datentyp die variable in der union hält die eigentlichen Daten. Pass diese union als Wert oder als void *

struct _unknown {
   union {
      int a;
      float b;
      char c;
      double d;
   } data;
   int type;
} unknown;
.
.
.
if (unknown.type == FLOAT)
{
  /* Process variable b */ 
}
else if (unknown.type == INT)
{
 /* Process variable a */
}
.
. 
.

Etwas wie dieses.

Können Sie hash definieren, die FLOAT und INT und andere als eindeutige Werte.

Oder einfach

struct _unknown {
  void *data;
  int type;
} unknown;
.
.
.
if (unknown == FLOAT)
{
  /* process (float *) data */
}
else if (unknown == INT)
{
  /* process (int *) data */
}
else if (unknown == MY_DATA_TYPE)
{
  /* process (my_data_type *) data */
  /* where my_data_type could be a typedef, or struct */
}

InformationsquelleAutor phoxis

1

Wenn Sie gcc verwenden, können Sie diese mehr typesafe-version:
```
#define r1(varp,func) ({ \
    typeof(**varp)* (*_func_)(int); \
    typeof(**varp)* _varp_ = (varp); \
    _func_ = (func); \
    r1_((void**)(_varp_),(void*(*)(int))_func_); \
    })

void r1_(void** varp,void*(*func)(int))
    {
    *varp = func(1);
    }
```
Rufen wie:
```
struct test* get_t(int);
struct test* t1;
r1(&t,get_t);
```
(Sie brauchen nicht zu verwenden & auf Funktionen, Sie zerfallen zu Zeigern automatisch, wie arrays). Dies überprüft, ob t ist ein Zeiger, und dass get_t ist eine Funktion zurückgeben, die Zeiger. _varp_ ist technisch unnötige, aber hält das argument der Auswertung in die richtige Reihenfolge.

Edit:

Wenn Sie den gcc nicht besitzen, können Sie das weiterhin tun, aber Sie haben, um den Typ explizit:
```
#define r1(T,varp,func) do { \
    T*(*_func_)(int); \
    T* _varp_ = (varp); \
    _func_ = (func); \
    r1_((void**)(_varp_),(void*(*)(int))_func_); \
    } while(0)

void r1_(void** varp,void*(*func)(int))
    {
    *varp = func(1);
    }
```
Rufen wie:
```
struct test* get_t(int);
struct test* t1;
r1(struct test*,&t,get_t);
```
nicht ganz so sicher, und mehr überflüssig, aber immer noch ziemlich gut.
- Danke, aber der code muss tragbar sein.
- gut, es gibt nur sehr wenige Maschinen, für die gcc ist nicht verfügbar, aber ich werde sehen was ich tun kann.
InformationsquelleAutor David X

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Edit: