#include <stdio.h>
#include <stdarg.h>

class foo
{
  public:
    int operator () (targument const &first_argument, ...){};
};

um die liste einzulesen nutze ich jetzt die ganzen va_* macros. aber wie bekomme ich da mit, dass ich das ende der argumente liste erreicht habe?

va_arg() schiebt den pointer der liste ja immer weiter und gibt das aktuelle argument zurück, gibts da irgendwie ein flag oder so was mir sagt jetzt bin ich am ende der liste?

f(x,y,z) := x^2 + y + z
g(x,y) := x + y^2

allg:

f(x_1, ..., x_n) = ...

alles sind polynome, die dann wiefolgt gelöst werden

f(x,y,z); //für bestimmte werte x,y,z
g(x,y); //für bestimmte werte x,y

allg:

f(x_1, ..., x_n; //für bestimmte x_1 bis x_n

ansonsten müsste ich ja für jede möglichkeit eine eigene solvefunktion schreiben und das würde ich gerne umgehen

Als mögliche Lösungsansätze in C++ könnte man Präprozessormetaprogrammierung (bei boost sehr häufig zu finden) oder ab C++09 variadic Templates heranziehen.

Als mögliche Lösungsansätze in C++ könnte man Präprozessormetaprogrammierung (bei boost sehr häufig zu finden) oder ab C++09 variadic Templates heranziehen.

Bitte was?

f(x,y) = 2.5x^2+3x+5+1.2y3

5  3  2.5   //3 koeffizienten fuer den x-polynom 2ten grades
       1.2  0  0   0    //4 koeff fuer den y-polynom 3ten grades

Oder du uebergibst die funktionen im Klartext als String und schreibst dir einen Parser dafuer.

Auf jeden Fall kannst du aber immer einen vector uebergeben und size() aufrufen um die Zahl der ARgumente zu erfahren.

Bitte was?

Man kann mit dem Präprozessor Funktionen mit wachsenden Parameterlisten erzeugen lassen. Sieht aber fürchterlich hässlich aus und erzeugt Unmengen an Code. Außerdem muss man die höchste Anzahl der Parameter zuvor festlegen.

Alle drei Nachteile werden in C++09 durch ein elegantes Sprachmittel ausgeglichen: Variadic Templates (gegen das hilft hier Google und der Artikel im Magazin dieses Forums)

...polynome haben bei mir 3 verschiedene typen, nämlichen ergebnis, koeffizienten und argumente typ. mal abgesehen davon müssen die monome des polynoms nicht nur aus einer variable bestehen.

Ich möchte mal sehen wie du verschiedene Typen etc. relativ sicher in einer variablen Argumentenliste übergibst... Nur ein Parameter falsch übergeben wirst du sicherlich in Abstürze geraten können.

Kontainer haben auf jedenfall den Vorteil das sie typsicher und weitgehend unproblematisch sind. Falls dir das Füllen von Kontainern zu aufwendig erscheint, solltest du dir mal die Boostbibliothek anschauen, die hat dafür eine verkürzte Schreibweise (dank überladung des ","-operators ...).

cu André

polynom<float, int, char> p;
char x = 'a', y = 'b', z = 'c';
//allg.: char x_1, ..., x_n
float f, g;
g = p(x,y);
f = p(x,y,z);
//allg.: f = p(x_1, ..., x_n);

so ist das gemeint, ich hoffe das es jetzt halbwegs verständlich ist. somit haben alle argumente den gleichen typ, der auch von anfang an feststeht.

...somit haben alle argumente den gleichen typ, der auch von anfang an feststeht.

...aber nicht durch das Typsystem von C++ gewährleistet ist. Korrigiert mich bitte, aber soviel ich von Elipsen weiß können die Parameter beliebigen Typs sein (oder anders formuliert: es wird keine Typüberprüfung für variable Parameter gemacht).

cu André

bei printf funktioniert das ja auch, wenn ich zuwenig zusätzliche parameter angebe, dann meckert er rum.

printf liefert die Anzahl indirekt über den Formatstring. Die Kontroller führt aber der Compiler nur so durch, im Standard ist sie nicht enthalten. Ein kostenloser Service.

Deshalb muss in C jedesmal der Caller den Stack aufräumen. Was du willst ist technisch nicht sauber möglich.

ich verstehe nicht, was ein Buchstabe ("char") in einem Polynom zu suchen hat.
Insgesamt scheint mir, dass Du noch nicht wirklich weißt, was Du da implementieren willst ...
Für variable Parameterlisten gibt's immer noch prima den std::vector - der ist prima.
und wenn Du pro Term mehrere Angaben machen möchtest (Parametername, exponent, Wert, ...) kannst Du die gut in einen struct packen, der dann in den vector wandert.

Gruß,

Simon2.

Letztendlich ist es nur Schönheitskorrektur und wäre schön gewesen wenn es ginge.

sicher geht das. variable anzahl von argumenten kann man als zeiger übergeben.
oder du übergibst eine zeichenkette der form "a0*x^0 + a1*x^1 + a2*x^2 + ... + an*x^n"
die du dann parsen kannst.
der vorteil bei der zeichenkette ist ganz klar:
es können mehrere xn an unterschiedlichen positionen auftauchen.
variabler geht es nicht.
der aufwand fürs parsen ist relativ gering, du hast nur zwei operatoren und zahlenwerte.

"a0*x^0 + a1*x^1 + a2*x^2 + ... + an*x^n"

wenn die Polynome denn so einfach wären
ein allg. Polynom besteht aus einer endlichen Summe von Termen, die wiederum das Produkt eines Koeffizienten und endlich vielen Variablen sind.
Die Parameter bestimmen dann den Wert den die jeweiligen Variablen annehmen sollen.
Da als Parameter wie gesagt potentiell beliebige Klassen möglich sind, fällt da meines erachtens ein String als Parameter raus.

polynomial p;
//...
p(1,2);
p(0,7,3);
p(2,25, ...);

also nochmal ich möchte etwas folgender art machen können

Und nochmal:
das geht so nicht.

Man kann nur etwas aehnliches erreichen.

FreakyBKA schrieb:

ich hab eine polynomklasse, mit beliebig vielen variablen. und da möchte ich jetzt per übergabe von argumenten, den wert des polynoms ausrechnen.
Idee:
f(x,y,z) := x^2 + y + z
g(x,y) := x + y^2

das ist in meinen augen ein string, den man parsen kann. die geparsten elemente kann man dann in klassen speichern.
oder wie willst du die eingabe realisieren.

FreakyBKA schrieb:

agga ugga schrieb:

"a0*x^0 + a1*x^1 + a2*x^2 + ... + an*x^n"

wenn die Polynome denn so einfach wären
ein allg. Polynom besteht aus einer endlichen Summe von Termen, die wiederum das Produkt eines Koeffizienten und endlich vielen Variablen sind.
Die Parameter bestimmen dann den Wert den die jeweiligen Variablen annehmen sollen.

das ist ein allgemeines polynom vom grad n

[quote="agga ugga"]

FreakyBKA schrieb:

agga ugga schrieb:

"a0*x^0 + a1*x^1 + a2*x^2 + ... + an*x^n"

wenn die Polynome denn so einfach wären
ein allg. Polynom besteht aus einer endlichen Summe von Termen, die wiederum das Produkt eines Koeffizienten und endlich vielen Variablen sind.
Die Parameter bestimmen dann den Wert den die jeweiligen Variablen annehmen sollen.

das ist ein allgemeines polynom vom grad n

ist es nicht denn es hat nur eine variable, nämlich x. ein allgemeines polynom hat beliebig viele variablen x1,...,x_n bzw x,y,z,usw.
ich will ja nicht die polynome parsen, das hab ich shcon längst.