Frage zu Parameterliste

ich hab ne frage
kann ich wenn ich irgendwie beim aufruf vom konstruktor eines objektes schon eingegebene werte benutzen ohne sie ein zweitesmal berechnen zu müssen?

ich dachte im prinzip so
erstmal die klasse

class klasse
{
public:
    klasse() {}
    klasse(float _f,float _g) : f(_f),g(_g) {}
    float f,g;
};

und jetzt diese funktion

klasse foo(klasse &k)
{
    klasse ret;
    ret.f=k.f*sqrt(k.g*k.f+3.5F)*sqrt(k.g+)/(kg.sqrt*(2.F));
    ret.g=k.g*sqrt(ret.f+ret.f)/ret.f+ret.f*sqrt(ret.f);
    return(ret);
}

ich dachte ich kann foo beschleunugen wenn ich mit dem konstruktor arbeite
gut neue funktion

klasse foo(klasse &k)
{
    return( //f
            k.f*sqrt(k.g*k.f+3.5F)*sqrt(k.g+)/(kg.sqrt*(2.F)),
            //aber wie soll ich g berechnen ohne f mehrmals zu berechnen

gibt es eine möglichkeit schon berechnete member einer klasse während des konstruktoraufrufs schon zu benutzen?
also

klasse foo(klasse &k)
{
    return( //f
            k.f*sqrt(k.g*k.f+3.5F)*sqrt(k.g+)/(kg.sqrt*(2.F)),
            //g
            k.g*sqrt(f+g)/f+f*sqrt(f); //FEHLER!
}

Wie kann ich den Fehler beheben und damit wirkliech foo zu beschleunigen?

Kannst du mal ein einfaches beispiel machen? ich hab keine ahnung was du willst.

klasse foo(klasse &k) 
{ 
    return( //f 
            k.f*sqrt(k.g*k.f+3.5F)*sqrt(k.g+)/(kg.sqrt*(2.F)), 
            //g 
            k.g*sqrt(f+g)/f+=f*sqrt(f); //FEHLER! 
}

Es wird eine Klasse (die nichts mit der eigentlichen berechnung zu tun hat sondern nur variablen speichert und über konstruktor übernimmt) definiert
es gibt eine funktion, die eine referenz auf ein objekt der obigen klassen erwartet und ein objekt der klasse zurückgibt, beschleunigt werden soll und deshalb nicht erst ein objekt erzeugt und dann die einzelnen werte berechnet, sondern im parameter von return wird ein neues objekt erzeugt und die werte im konstruktor berechnet
Wie kann ich hier beim aufruf des konstruktors den nächsten parameter berechnen, der aber vom vorhergehenden parameter abhängt, ohne doppelt zu berechnen

bsp

return( CEineKlasseMitKonstruktor( //Das ist eine Klasse deren Konstruktor 2 floats übernimmt die berechnet werden sollen
fParameterFuerKonstruktor1*2, //Die komplizierte langdauernde Berechnung
fParameterFuerKonstruktor2 *... //Hier soll der 2. Parameter berechnet werden, der mit dem 1. Parameter zb addiert werden soll
//ohne dass ich parameter1 zweimal berechnet wird (1x bei Parameter1 und dann bei parameter2 mehrmals)

im Prinzip muss ich irgendwie im Konstruktorparameter auf die Member (die schon früher in der parameteliste berechnet wurden) der neuen klasse in der parameterliste zugreifen können

Konkret gehts mir dabei um die Funktion zu beschleunigen die eine Matrix invertiert (Funktion von David Scherfgen (Autor von "3D-Spieleprogrammierung mit C++ und DirectX"))
Da wird jede komponente der matrix einzeln berechnet und die letzten 4 hängen von den ersten ab. Die genaue Funktion kann ich wegen urheberrechtlichen blablabla nicht preisgeben

Th

Sorry, aber deine Beispiele sind voller Syntaxfehler. Da findet kein Mensch durch (und du anscheinend selber noch nicht einmal)!

Wenn du einen Ausdruck nicht doppelt berechnen willst, dann speicherst du diesen halt in eine lokale Variable.

Wenn ich das mit der lokalen Variable mache hab ich den gleichen effekt wie wenn ich die funktion so lasse und in der funktion, des zurückzugebenden objektes jedes member einzeln berechne

ich will ja die konstruktorparameter berechnen während er aufgerufen wird
aber dabei muss ich zur berechnung auf die member zugreifen können, die schon als parameter übergeben wurden, denn ich brauche für die letzten berechnungen alle vorhergehenden also lohnt es sich nicht mit lokalen variablen

gibts da eine möglichkeit?

thordk

int a = wahnsinnigteureberechnung();
int b = nochvielteurerefunc(a);
Foo f(a, b);

was ist daran nicht praktikabel?

Das hat am ende den gleichen Effekt als wenn ich die member einzeln berechne

Ich geb's auf

thordk

du hast da nen eklatantes verständnisproblem

Michael E.

Das macht dein Compiler meist automatisch für dich.

http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=Optimize#Answ

Vorden

naja, ums zu beschleunigen, fällt mir höchstens ne numerische berechnung der wurzel ein, weiß nicht genau, wie sqrt die wurzel berechnet, aber die numerische berechnung lohnt sich meistens nur, wenn man in ner schleife häufiger sqrt verwenden würde und sich dann lieber die größe iterativ besorgt

zu 99,9999999999999% wird hier an der falschen stelle optimiert.

CStoll

abc123 schrieb:

und jetzt diese funktion

klasse foo(klasse &k)
{
    klasse ret;
    ret.f=k.f*sqrt(k.g*k.f+3.5F)*sqrt(k.g+)/(kg.sqrt*(2.F));
    ret.g=k.g*sqrt(ret.f+ret.f)/ret.f+ret.f*sqrt(ret.f);
    return(ret);
}

Und diese Formel geht ohne Murren durch den Compiler? Die Berechnung von ret.f ist ja ein einziger Syntax-Fehler.

Ansonsten: Bevor du von Hand optimierst, solltest du erstmal feststellen, ob diese Funktion überhaupt der Engpass ist. Wenn ja, ist es vielleicht einfacher/sinnvoller, den umliegenden Algorithmus auseinanderzunehmen - so daß sie etwas seltener aufgerufen wird.