Ist es effizienter, wenn ich Variablen ausserhalb einer Schleife definiere?\
Sprich: Ist das hier:

double a;
double b;
for(int i=0; i < 100; i++) {
   a = foo * ...
   b = array[i] + ...
}

effizienter als das:

for(int i=0; i < 100; i++) {
   double a = foo * ...
   double b = array[i] + ...
}

? Oder is das Wurst?

EDIT: Bei innerhalb hast du halt immer noch zusätzlich den konstruktor-call und den destruktor-call in jedem Durchlauf. Bei Außerhalb schleppst du nicht benötigten Speicher mit. Wenn du pure geschwindigkeit willst und dir der Speicher egal ist, dann außerhalb die Variablen initialisieren.

int main()
{
    int foo;
    // ... berechnungen
    {
         double a, b;
         for(int i = 0; i < 10000; ++i)
         {
              // berechnungen
              a = 5.0;
              b = a;
         }
    } // hier werden a und b zerstört
    return 0;
}

Irgendwie widersprechen sich HighLigerBiMBams und volkards Antworten?

Ja. Aber beide haben Recht. volkard bei einfachen Datentypen: Diese werden nicht konstruiert oder zerstört. Bei komplizierten eigenen Klassen in denen der Konstrukotr/Destruktor nicht leer ist, würde ich es aber nochmal ausprobieren, da dürfte HighLigerBiMBams richtig liegen.

Irgendwie widersprechen sich HighLigerBiMBams und volkards Antworten?

Ja... Ich habe es mir gerade angeschaut... Volkard hat bei einfachen Datentypen recht. Innen ist minimal schneller.

#include <iostream>
#include <time.h>               // contains clock()

using namespace std;

clock_t innen()
{
	clock_t startzeit = clock ();

	long long a; 
	long long b;
	long long c;
	for(long long i=0; i < 1000000000; i++) { 
		a = i * 2;
		b = i * 3;
		c = a + b;
	}

	return clock() - startzeit;
}

clock_t aussen()
{
	clock_t startzeit = clock ();

	for(long long i=0; i < 1000000000; i++) { 
		long long a = i * 2;
		long long b = i * 3;
		long long c = a + b;
	}

	return clock() - startzeit;
}

int main()
{
	clock_t cl_aussen = aussen();
	clock_t cl_innen = innen();

	cout << "aussen: " << cl_aussen << endl;
	cout << "innen : " << cl_innen << endl;

	cin.get();
	return 0;
}

Ja... Ich habe es mir gerade angeschaut... Volkard hat bei einfachen Datentypen recht. Innen ist minimal schneller.

Irgendwie mag ich nicht glauben, dass du bei diesem Beispiel einen Unterschied misst. Hast du keine Optimierungen benutzt?

edit: Du hast sogar offensichtlich keine Optimierungen benutzt, weil dann einfach in beiden Fällen 0 rausgekommen wäre.

int main()
{
//volkard hat natürlich recht
    clock_t cl_aussen = aussen();
    clock_t cl_innen = innen();

    cout << "aussen: " << cl_aussen << endl;
    cout << "innen : " << cl_innen << endl;

    cin.get();
    return 0;
}

int main()
{
//volkard hat natürlich unrecht
    clock_t cl_innen = innen();
    clock_t cl_aussen = aussen();

    cout << "innen : " << cl_innen << endl;
    cout << "aussen: " << cl_aussen << endl;

    cin.get();
    return 0;
}

Bei solchen Messungen habe ich auch schon erlebt, daß meistens die erste Messung klitzebißchen lahmer ist.

Ist wohl der Fall -.- ich möchte mich auch gerade beerdigen...

#include <iostream>
#include <time.h>               // contains clock()

using namespace std;

long long innen()
{
    long long result=0;
    long long a;
    long long b;
    long long c;
    for(long long i=0; i < 1000000000; i++) {
        a = i * 2;
        b = i * 3;
        c = a + b;
        result += 3 * result + c;
    }
    return result;
}

long long aussen()
{
    long long result=0;
    for(long long i=0; i < 1000000000; i++) {
        long long a = i * 2;
        long long b = i * 3;
        long long c = a + b;
        result += 3 * result + c;
    }
    return result;
}

int main()
{
    clock_t begin = clock();
    long long r = aussen();
    clock_t end = clock();

    cout << "ergebnis : " << r << '\n';
    cout << "zeit : " << (end-begin)/double(CLOCKS_PER_SEC) << '\n';

    cin.get();
    return 0;
}

Also immer was ausrechnen, was dann auch ausgegeben wird. Anderenfalls optimiert der Compiler das komplett weg. Und Summenformeln kann er. Also noch nicht mal result+=c ist sicher vor Optimierung auf 0s. Außerdem wenn möglich für faire Bedingungen sorgen, bei nur einmaliger Messung wir der erste oft benachteiligt. Und unbedingt mit -O3 messen, eigentlich auch mit -march=native (falls GCC, für MS weiß ich die Schalter nicht. Halt alle Optimierungen an und auf den Zielprozessor einstellen).

xorl    %edx, %edx            //d=0
        xorl    %eax, %eax            //a=0
        movabsq $5000000000, %rcx     //c=5000000000
.L7:
        leaq    (%rdx,%rax,4), %rax   //a=r+4*a
        addq    $5, %rdx              //d+=5
        cmpq    %rcx, %rdx            //if(d==c)
        jne     .L7                   //  goto L7
        rep //hier unwichtig, "to avoid making the ret instruction be target of a conditional jump instruction"
        ret                           //return a

Oh, das ist aber gemein! Innen oder außen ist vollig jenseits sinnvoller Betrachtung. Der Compiler ist einfach ein Schlauberger.