3. Variable in Schleife definieren

Variable in Schleife definieren

  • ?

    Irgendwie widersprechen sich HighLigerBiMBams und volkards Antworten?

    0
  • Mod

    wurst0r schrieb:

    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.

    0
  • H

    wurst0r schrieb:

    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;
}
    0
  • Mod

    HighLigerBiMBam schrieb:

    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.

    0
  • H

    Der Unterschied ist sehr minimal jedoch ist innen deutlich häufiger schneller. Ich habe keine Optimierungen benutzt. Die Rechenzeit beträgt bei meiner Klapperkiste über 20 Sekunden...

    0
  • V

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

    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;
}
    0
  • H

    volkard schrieb:

    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...

    0
  • V

    Vielleicht besser sowas messen:

    #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).

    0
  • V

    Das hier macht der Compiler draus. Sowohl aus innen als auch aus aussen.

    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. 👍

    0
  • H

    Der Compiler ist einfach unfehlbar 🤡

    0
Anmelden zum Antworten