unbestimmte anzahl an funktionsparametern

Hullo

ich will einer funktion parameter übergeben, jedoch ist die anzahl und der typ
der parameter unbestimmt. (wie bei printf) das problem mit dem typ kann ich über void pointer loesen, jedoch weiss ich nicht wie ich das mit der unbestimmten anzahl an parametern mache kann. weiss jemand wie das vielleicht bei printf funktioniert? ich habs jetzt einmal mit standartwerden probiert.
(void funktion(para1=0,para2=0,para3=0,...)

aber was mich daran stoert ist das ich auf die einzelnen paramter nur über die namen zugreifen kann, und nicht über zb einen array platz. Dann hab ich mir überlegt das ich einen pointer array bilden kann aus den verschieden paramtern, der muesste aber dann wieder "per hand" aufgebaut werden, und die anzahl der parameter ist immer noch fix.

hat jemand eine idee was ich da machen koennte?

ps: ich will beim funktionaufruf einzelne paramter übergeben, nicht einen pointer auf einen array in de die parameter stehen.

thx 4 reading

PeterTheMaster

void funktion(...);

sollte aber vermieden werden (genau wie printf), was genau willst du damit machen?

HumeSikkins

Hallo,
wirf mal einen Blick in die C-FAQs:
Dynamische Parameterübergabe

hmm, ich hab jetzt mal in meiner bc31 hilfe nach geschaut und va_start und so gefunden. es steht dabei das dies ansi c kompatiebel sein soll, stimmt das?
das kommt mir mehr wie so ein mit augen zu und durch gepachte borland funktion vor.

danke fuer die hilfe

davie

ja, stimmt

TGGC

Mhh, das ist doch hier das C++ Board (bin ja nicht so oft hier ). Darum würde ich gern mal eine dazu passende Lösung vorschlagen. Erstmal machst du einen Basisklasse für dein Parameter. Dann leitestet du alle Parameter davon ab. Die Basisklasse könnte eine virtuelle Funktion GetType haben, damit man den Typ leicht (und ohne RTTI erkennen kann). Jetzt packst du alle Parameter in einen std::vector und übergibst den. Das müsste alle Schwachstellen der Lösung mit der Ellipse umgehen.

Bashar

lol

TGGC schrieb:

Mhh, das ist doch hier das C++ Board (bin ja nicht so oft hier ). Darum würde ich gern mal eine dazu passende Lösung vorschlagen. Erstmal machst du einen Basisklasse für dein Parameter. Dann leitestet du alle Parameter davon ab. Die Basisklasse könnte eine virtuelle Funktion GetType haben, damit man den Typ leicht (und ohne RTTI erkennen kann). Jetzt packst du alle Parameter in einen std::vector und übergibst den. Das müsste alle Schwachstellen der Lösung mit der Ellipse umgehen.

lol, hat jemand noch ernsthafte Vorschläge?

Hast du dir den Link von HumeSikkins angekuckt?? Da stehts doch drin wie es geht.

Hier für Faule:

int mysprintf(char* text, ...)
{
  va_list arglist;
  va_start(arglist, text);
  int n = vsprintf(text, arglist);
  va_end(text);
  return n;
}
/**************************************/
int summe(int s, ...)
{
  int s=0;
  va_list arglist;
  va_start(arglist, n);
  for (int i=0; i<n; i++)
    s += va_arg(arglist, int);
  va_end(arglist);
  return s;
}

Ansonsten bleibt dir nur ein Dynamisches Array. Hab sowas mal als Template gemacht, für meine eigene Tool-Lib, bei Bedarf kann ichs hier reinstellen.
Was anderes wird dir nicht überbleiben ;).
edit: und ja, das is ansi-c kompatibel.
http://www.cppreference.com/stdio/vprintf_vfprintf_vsprintf.html
rya.

mm-motn schrieb:

TGGC schrieb:

Mhh, das ist doch hier das C++ Board (bin ja nicht so oft hier ). Darum würde ich gern mal eine dazu passende Lösung vorschlagen. Erstmal machst du einen Basisklasse für dein Parameter. Dann leitestet du alle Parameter davon ab. Die Basisklasse könnte eine virtuelle Funktion GetType haben, damit man den Typ leicht (und ohne RTTI erkennen kann). Jetzt packst du alle Parameter in einen std::vector und übergibst den. Das müsste alle Schwachstellen der Lösung mit der Ellipse umgehen.

lol, hat jemand noch ernsthafte Vorschläge?

Entspricht von der Idee her dem Standartverfahren von C#. Da sieht das z.B. ca so aus:

void MassigVieleParameter(new string[] { "Wer", "zuletzt", "lacht", "usw" } );

Von der Idee her also das gleiche wie die Idee mit dem Vector... In C++ vielleicht etwas komplizierter, aber dadurch noch lange keine schlechte Idee.

pumuckl

Die Lösung mit dem vector von Pointern auf ne gemeinsame Basisklasse halte ich für die sinnvollste Lösung. In meinem aktuellen Kleinprojekt baue ich Funktoren dynamisch zusammen, und zwar aus einer Liste von anderen Funktoren. Da man im Vorneherein nicht wissen kann wie die Rückgabetypen und Parameterlisten der einzelnen Funktoren aussehen, greife ich da auf genau diese Möglichkeit mit dem Vector des allgemeinen Basistyps zurück.