eine kurze Frage:
wenn ich eine Variable in einer Schleife anlege wie hier:

for(int i=0; i < k; i++) {
   float foo = a[i] + ...;
   // benutze foo
}

ist das dann langsamer als wenn ich die Definition aus dem Rumpf ziehe:

float foo;
for(int i=0; i < k; i++) {
   foo = a[i] + ...;
   // benutze foo
}

??

Anders sieht die Sache aus, wenn der Typ einen Konstruktor hat. Der wird dann natürlich ausgeführt. Aber auch da kommt es darauf an, ob der Konstruktor überhaupt was substantielles macht.

#include <iostream>

class Test
{
    public:
        Test( int val=13 )
         : m_val(val)
        {
            std::cout << "Konstruktor mit " << m_val << std::endl;
        }
        Test( const Test& other )
        {
            if( &other != this ) {
                m_val = other.m_val;
                std::cout << "Kopierkonstruktor mit " << m_val << std::endl;
            }
        }
        const Test& operator=( const Test& other )
        {
            if( &other != this ) {
                m_val = other.m_val;
                std::cout << "Zuweisungsoperator mit " << m_val << std::endl;
            }
            return *this;
        }
    private:
        int m_val;
};

int main()
{
    std::cout << "Variable außerhalb von Schleife" << std::endl;
    Test t;
    for( int i=0; i<10; i++ ) {
        t = i;
    }

    std::cout << std::endl << "Variable innerhalb von Schleife" << std::endl;
    for( int i=0; i<10; i++ ) {
        Test t2(i);
    }
    return 0;
}

Ausgabe:

Variable außerhalb von Schleife
Konstruktor mit 13             
Konstruktor mit 0              
Zuweisungsoperator mit 0       
Konstruktor mit 1              
Zuweisungsoperator mit 1       
Konstruktor mit 2              
Zuweisungsoperator mit 2       
Konstruktor mit 3              
Zuweisungsoperator mit 3       
Konstruktor mit 4              
Zuweisungsoperator mit 4       
Konstruktor mit 5              
Zuweisungsoperator mit 5       
Konstruktor mit 6              
Zuweisungsoperator mit 6       
Konstruktor mit 7              
Zuweisungsoperator mit 7       
Konstruktor mit 8              
Zuweisungsoperator mit 8       
Konstruktor mit 9              
Zuweisungsoperator mit 9

Variable innerhalb von Schleife
Konstruktor mit 0
Konstruktor mit 1
Konstruktor mit 2
Konstruktor mit 3
Konstruktor mit 4
Konstruktor mit 5
Konstruktor mit 6
Konstruktor mit 7
Konstruktor mit 8
Konstruktor mit 9

Und auch "nichtige" Zuweisungen an Member sind Operationen, die bei großen Datenmengen ins Gewicht fallen.

@Knolle123: Wo hast du dein float versteckt?

Sry, dass ich das "float" unterschlagen hab und durch ein int ersetzt hab.
Aber das Beispiel war eher auf die Verwendung von Klassen gerichtet. Und sobald ich Klassen verwende, habe ich auch Daten zu kapseln, die dann beim Zuweisungsoperator/Kopierkonstruktor mit zugewiesen werden müssen. Und wenn dies 2n + 1 mal geschieht (Deklaration + (Konstruktor+Zuweisungsoperator)*n) fällt das schon irgendwann ins Gewicht.

Und dem Ausgangspost konnte ich nicht entnehmen, dass es sich nur um eine Frage bezügl. "float" dreht, sondern allgemein um "Variablendefinition in oder außerhalb Schleife".

Variable innerhalb der Schleife
n Konstruktoren + n Destruktoren

Wenn eine Zuweisung also teurer ist als einen Konstruktor und einen Destruktor zusammen, dann sollte die Variable ausserhalb der Schleife deklariert werden, erst recht wenn n eine sehr grosse Zahl annimmt.
Ansonsten sollte man die Variable innerhalb der Schleife deklarieren. Auch wenn man vielleicht ein wenig Performance verliert, sollte noch die innere Variante vorgezogen werden, da die Variable dann im richtigen Scope vorhanden ist, bzw. was wichtig ist, dass sie im Scope ausserhalb nicht mehr vorhanden ist. Man hält somit seinen Scope sauber. Auch kann ein Kompiler zum Teil die Variante mit der Variable in der Schleife besser optimieren.

Im grossen und ganzen wird der Unterschied allerdings wohl eher klein sein.

Grüssli

Und wie das nen Unterschied macht es nen Unterschied, da erst ein Konstruktor und dann ein Zuweisungsoperator aufgerufen wird:
Z.B.:
...

Ich habe Dein Beispiel mal um Zeitnahme und mehr Durchläufen durchgemessen. Bei beiden Fällen kommt (wie ich es erwartet habe) im Rahmen der Messgenauigkeit die gleiche Zeit raus. Natürlich habe ich die Ausgaben entfernt. Ich will ja nicht messen, wie schnell die Ausgabe auf cout läuft.

Bei solchen sehr einfachen Klassen, wo alles inline ist, hat der Compiler keine Probleme, jeglichen Overhead weg zu optimieren.

Das Resumee sollte sein: Traue deinem Compiler.

Wenn ich natürlich einen Konstruktor schreibe, der etwas signifikantes macht, dann ist das natürlich ein Unterschied, ob ich das ein mal oder mehrfach mache.

@Knolle123,
Auch noch zwei andere Dinge hast du hier falsch gemacht. Du hast hier nicht Objekte gleichen Typs einander zugewiesen, sondern von unterschiedlichen Typen. Dadurch wird natürlich ein cast fällig. Auch hast du den Destruktor vergessen.
Nimmst du allerdings diese Besonderheiten heraus, dann hast du das folgende:
Variable ausserhalb der Schleife
1 Konstruktor + 1 Destruktor + n Zuweisungen

Variable innerhalb der Schleife
n Konstruktoren + n Destruktoren

Ok, in diesem einfachen Fall, dass genau ein Konstruktor existiert, der genau einen Parameter besitzt, kann ich mir einen operator=(int val) definieren, dann hab ich 1 Konstruktor, 1 Destruktor und n Zuweisungen. Das ist aber ein recht simpler Fall, der garantiert sehr oft nicht zutrifft.
Da wird z.B. über einen Ergebnissatz eines SQL-Query iteriert, und aus den einzelnen Spalten die Argumente für den Konstruktor gezogen.
In dem Fall ist es dann nämlich noch schlimmer (oder irr ich mich?)
1 Konstruktor, 1 Destruktor, für temp. Objekte n Konstruktoren, n Zuweisungen, n Destruktoren. Oder überseh ich was?

Ok, in diesem einfachen Fall, dass genau ein Konstruktor existiert, der genau einen Parameter besitzt, kann ich mir einen operator=(int val) definieren, dann hab ich 1 Konstruktor, 1 Destruktor und n Zuweisungen. Das ist aber ein recht simpler Fall, der garantiert sehr oft nicht zutrifft.

Es geht nicht darum, dass du einen operator=(int) haben solltest, sondern dass du dem Objekt vom Typ Test nicht ein Objekt eines anderen Typs zuweist, sondern ebenfalle ein Objekt vom selben Typ. Die Konvertierung ist unüblich.

Knolle123 schrieb:

Da wird z.B. über einen Ergebnissatz eines SQL-Query iteriert, und aus den einzelnen Spalten die Argumente für den Konstruktor gezogen.

Und was machst du mit diesen Objekten? Das ist hier ein ganz spezieller Fall. Denn hier wirst du wahrscheinlich explizit Objekte konstruieren wollen und sie in einem Container abspeichern. Also ist die Schleife explizit für die Konvertierung und das Befüllen eines Containers gedacht. Sowas sind meistens eher Initialisierungsaufgaben und daher kommen sie seltener vor.

Knolle123 schrieb:

Oder überseh ich was?

Naja, wie gesagt, dass es eben ein spezieller Fall ist. Du willst nicht Objekte in einer Liste bearbeiten oder Objekte gleichen Typs behandeln, sondern eine Liste intialisieren und entsprechende Daten konvertieren. Es ist daher verständlich, dass nur der Aufruf eines Konstruktors, was auch eine Art von Konvertierung ist, bessere Ergebnisse erzielen kann, als wenn du die Daten konvertierst und noch temporär zwischenspeicherst.
Aber auch übersehen tust du, dass ein Kompiler durchaus in der Lage ist zu optimieren.

Und ich verweise nochmals auf meine letzten paar Sätze. Es ist zum Teil schon von der Aufgabe oder den Klassen abhängig, wie man die Schleife aufbaut. Aber in den meisten Fällen ist der Unterschied nicht all zu gross oder man kann schlecht im voraus sagen, was schneller oder langsamer sein wird.

Grüssli