Die übergabe von Parametern dynamisch zu variadischen Funktionen

Ich Frage mich, ob es irgendeinen Weg, um Parameter dynamisch zu variadischen Funktionen. d.h. Wenn ich eine Funktion

int some_function (int a, int b, ...){/*blah*/}

und ich bin der Annahme einer Reihe von Werten vom Benutzer, ich will Weg dar, diese Werte in der Funktion: 

some_function (a,b, val1,val2,...,valn)

Möchte ich nicht schreiben, verschiedene Versionen von all diese Funktionen, aber ich vermute, es gibt keine andere option?

  • wenn alle Werte vom selben Typ (wie deine Frage scheint zu implizieren - korrigieren Sie mich, wenn ich falsch Liege), würde ich vorschlagen, nicht zu verwenden, eine Variable Funktion, und übergeben Sie ein array statt; siehe hier für einige makro-Magie pretty it up, wenn Sie wollen, zu passieren, in eine Feste Anzahl von Argumenten: stackoverflow.com/questions/1375474/variable-arity-in-c/...
  • Nein, Sie sind von verschiedenen Arten.
  • der array-Ansatz kann weiterhin funktionieren, wenn Sie wickeln Sie Ihre Werte in einer Gewerkschaft oder übergeben in einem array von void * um die Werte statt der Werte selbst, aber es werden weniger elegant
  • Übergeben Sie ein array von void* klingt wie die ideale Lösung eigentlich, ich glaube nicht, dass das funktionieren würde.
InformationsquelleAutor tommobh | 2009-11-12
  1. 11

    Variadic-Funktionen verwendet eine Aufrufkonvention, wo der Aufrufer ist dafür verantwortlich knallen der Funktion Parameter aus dem stack, also ja, es ist möglich dies dynamisch. Es ist nicht standardisiert in C, und normalerweise würde erfordern einige Montage manuell drücken Sie den gewünschten Parameter, und rufen Sie die Variable Funktion korrekt.

    Den cdecl Aufruf-Konvention verlangt, dass die Argumente, die geschoben werden, in der richtigen Reihenfolge, und nach dem Aufruf werden die bytes geschoben als Argumente vor dem Aufruf geholt werden. Auf diese Weise wird die aufgerufene Funktion empfangen kann eine beliebige Anzahl von Parametern, wie der Aufrufer behandelt zurücksetzen der stack-pointer um es in den pre-call-state. Der belegte Speicherplatz durch die Argumente vor der ... ist die sichere untere Schranke für die Anzahl der bytes geschoben. Zusätzliche Variable Argumente interpretiert zur Laufzeit.

    FFCALL ist eine Bibliothek, die mit wrappers zur übergabe von Parametern dynamisch zu variadischen Funktionen. Die Gruppe der Funktionen, die Sie interessiert, ist,avcall. Hier ist ein Beispiel für den Aufruf der Funktionen, die Sie gab oben:

    #include <avcall.h>

av_alist argList;
int retVal;
av_start_int(argList, some_function, retval);
av_int(argList, a);
av_int(argList, b);
av_type(argList, val1);
...
av_type(argList, valn);
av_call(argList);

    Vielleicht finden Sie auch dieser link diskutieren Generierung von Wrapper variadischen Funktionen in C, zum des Interesses zu rechtfertigen, warum dies ist nicht Teil von standard-C.

    • Was meinst du mit "und rufen Sie die varargs call entsprechend."? Die Funktion befasst sich mit den varargs.
    • ich habe bearbeitet zu erklären
    • Dank, sehr geschätzt.
    • Ich denke, es ist wichtig zu erwähnen, dass die Bibliothek GPL 3, das es no go für viele Fälle.
    InformationsquelleAutor Matt Joiner
  2. 2

    Standard-Ansatz wird jede Variable Funktion begleitet von einem va_list-Einnahme Gegenstück (wie bei printf und Funktionen vprintf). Die variadic version nur konvertiert ... zu einem va_list (mit Makros aus stdarg.h) und nennt seine va_list-Einnahme Schwester, die nicht die eigentliche Arbeit.

    • Danke, ich schau mal in dieses Konzept.
    • Gleiche problem obwohl. Ich muss noch hinzufügen, die Parameter dynamisch an die Funktion, ob er fordert seine va_list-Einnahme Schwester oder nicht. Meinst du ich konvertieren Sie die Werte in eine va_list und dann verwenden Sie einfach die va_list-Einnahme Schwester-Funktion statt?
    • Ich denke, interpretierte ich Ihre Frage falsch. Vom Lesen der Kommentare, ich nehme es, dass Sie ein Mittel zur Erlangung von Werten verschiedener Typen (z.B. in der gui) und die Notwendigkeit, Sie zu übergeben an eine Funktion; ist das korrekt? In diesem Fall, va_list nicht viel helfen. Wenn Sie nicht möchten, verlassen Sie sich auf hacks, müssen Sie die Einstellungen ändern...
    InformationsquelleAutor atzz
  3. 1

    Könnte es interessant sein, zu versuchen, einfach ein array übergeben, und verwenden Sie dann die vararg-Makros sowieso. Je nach stack-Ausrichtung, könnte es Nur die Arbeit (tm).

    Dies ist wahrscheinlich nicht die optimale Lösung, habe ich hauptsächlich gepostet, weil ich fand die Idee interessant.
    Nach dem Versuch es heraus, dieser Ansatz funktioniert auf meinem linux-x86, aber nicht auf x86-64 - es kann wahrscheinlich verbessert werden. Diese Methode hängt vom Stapel Ausrichtung, Struktur, Ausrichtung und wahrscheinlich noch mehr.

    void varprint(int count, ...)
{
    va_list ap;
    int32_t i;

    va_start(ap, count);
    while(count-- ) {
        i = va_arg(ap, int32_t);
        printf("Argument: %d\n", i);
    }
    va_end(ap); 
}

struct intstack
{
    int32_t pos[99];
};

int main(int argc, char** argv)
{
    struct intstack *args = malloc(sizeof(struct intstack));
    args->pos[0] = 1;
    args->pos[1] = 2;
    args->pos[2] = 3;
    args->pos[3] = 4;
    args->pos[4] = 5;

    varprint(5, *args);
    return 0;
}
    • es wird nicht funktionieren, da arrays nicht durch Wert übergeben, sondern als Zeiger
    • True - wenn ich dachte, es heraus, dass ich dachte, irgendwie schieben die Arrays auf dem stack. Aber C nicht, dass, wenn Sie übergeben Sie den array an eine Funktion - Sie hätte es selbst zu tun.
    • Bei Verwendung eines struct wickeln Sie das array, hat er die Möglichkeit, zu arbeiten, mindestens 🙂 Siehe Beispiel
    InformationsquelleAutor gnud
  4. 0

    Je nachdem, was es ist, du bist vorbei, es könnte sein, diskriminiert union sind Sie nach hier (wie schon angedeutet, in den Kommentaren). Das wäre zu vermeiden die Notwendigkeit für variadic functions oder arrays von void* und beantwortet die Frage "wie funktioniert some_function wissen, was Sie eigentlich ging es". Haben Sie vielleicht etwas code wie dieser:

    enum thing_code { INTEGER, DOUBLE, LONG };

struct thing
{
 enum thing_code code;
 union
 {
    int a;
    double b;
    long c;
 };
};

void some_function(size_t n_things, struct thing *things)
{
    /* ... for each thing ... */
    switch(things[i].code)
    {
      case INTEGER:
      /* ... */
    }
}

    Können Sie noch einen Schritt weiter und vermeiden Sie die Schalter durch den Austausch der code mit einem oder mehreren Zeigern auf Funktionen, die etwas nützliches tun mit jedem thing. Zum Beispiel, wenn das, was Sie tun wollte, war zu einfach drucken Sie jede Sache, die Sie haben könnten dieser:

    struct thing
{
 void (*print)(struct thing*);
 union
 {
   ...
 };
}

void some_function(size_t n_things, struct thing *things)
{
  /* .. for each thing .. */
  things[i]->print(things[i]);
  /* ... */
}
    • Die Variable Funktion die ich verwende, ist in einer Bibliothek, würde ich idealerweise nicht ändern möchten (D. H. ich will nicht ändern 'some_function()'). Der Benutzer kann ein beliebiger Betrag beliebiger Art, die Sie möchten (innerhalb Grund), so definieren ein strenges union scheint nicht, wie es funktionieren wird. Ein array von void* oder Anacrolix s Vorschlag scheint, wie meine beste Wette. Entweder das, oder ich Schreibe ein paar inline-Bestückung :S.
    • Aber wenn Sie nicht ändern können some_function, wie können Sie übergeben Sie ein array von void*? Durch user die hier sind, sprechen wir von einem Entwickler Ihren code verwenden, oder ein end-user von dem Programm?
    • User=Endbenutzer. Ja, ich sehe, was Sie tatsächlich bedeuten. Ich will nicht, um die Funktion zu ändern, weil die Funktion sich selbst aufruft, eine andere Variable Funktion und ich würde das auch umstellen. Es wäre nur Schneeball. Ich habe das Gefühl, ich bin wieder da wo ich angefangen habe.
    InformationsquelleAutor Ned
Schreibe einen Kommentar