Warum sind Klassen schneller?
-
Hallo,
Ich hatte mal ein Test druchgeführt bezüglich der Geschwindigkeit von Klassen und einer Variable. Ich dachte eig. immer, dass Klassen etwas langsamer sind als eine normale Variable.
Warum? Weil bei einer Varible mache ich z.B. einfach counter++ - um eine Variable in einer Klasse zu erhöhen, muss ich erst eine Funktion aufrufen (z.B. einen Setter), was für mich für einen höheren Aufwand steht.Ich hatte es mal mit folgendem Code probiert:
class CTest { public: CTest(); int GetC(){return CCounter;}; void SetC(){CCounter++;}; private: int CCounter; }; CTest::CTest(): CCounter(0) {} int main() { int counter=0; CTest CVar; DWORD lol = timeGetTime(); while (timeGetTime()-lol <= 100) CVar.SetC(); lol = timeGetTime(); while (timeGetTime()-lol <= 100) counter++; cout << counter << " " << CVar.GetC() << endl; system("PAUSE"); return 0; }
Dabei hatte ich die Klasse mal mit und ohne Pointer probiert, jeweils schneller als die Variable, wobei ohne Pointer noch etwas schneller ist.
Also warum sind Klassen denn etwas schneller? Für mich macht es keinen Sinn.
-
Messergebnisse, Kompiler und Optimierungseinstellungen posten!
-
Wenn du irgendeinen Unterschied misst, dann taugen deine Messmethoden oder dein Compiler nichts. Da muss das gleiche rauskommen.
-
Was genau soll es eigentlich bringen, alle Bezeichner, die mit Klassen zu tun haben, mit "C" zu verunstalten?
-
Im Schnitt hat die normale Variable bei mir 8,95Mio und die Klasse 9Mio Aufrufe, dass das natürlich bei jedem erneuten Versuch leichte Abweichungen gibt sollte klar sein.
Ansonsten Visual Studio 2010, Bei Code-Optimierung lediglich Geschwindigkeit Maximieren gewählt, sonst alles Standart.
@Nexus: Mach ich in der Regel auch anders aber ist doch nur ein Testprogramm, von daher sch**** drauf Wenn es danach geht kannst du auch in Frage stellen, warum die DWORD Variable für Zeit lol heißt
-
Und warum getter/setter verwenden und nicht die Operatoren = ++ usw. überladen, das würde eine viel natürlichere Nutzung im Programablauf ergeben.
-
Es produziert tatsächlich unterschiedlichen Code:
DWORD lol = clock(); 01191326 call edi 01191328 mov dword ptr [ebp-4],eax while (clock()-lol <= 100) 0119132B call edi 0119132D sub eax,dword ptr [ebp-4] 01191330 cmp eax,64h 01191333 ja main+37h (01191347h) 01191335 mov ebx,dword ptr [ebp-4] CVar.SetC(); 01191338 inc esi 01191339 call edi 0119133B sub eax,ebx 0119133D cmp eax,64h 01191340 jbe main+28h (01191338h) 01191342 mov dword ptr [ebp-8],esi 01191345 xor ebx,ebx
lol = clock(); 01191347 call edi 01191349 mov dword ptr [ebp-4],eax while (clock()-lol <= 100) 0119134C call edi 0119134E sub eax,dword ptr [ebp-4] 01191351 cmp eax,64h 01191354 ja main+5Dh (0119136Dh) 01191356 mov esi,dword ptr [ebp-4] 01191359 lea esp,[esp] counter++; 01191360 inc ebx 01191361 call edi 01191363 sub eax,esi 01191365 cmp eax,64h 01191368 jbe main+50h (01191360h) 0119136A mov esi,dword ptr [ebp-8]
Aber einen Unterschied macht das bei mir nicht. Zumal man das auch irgendwie kaum messen kann, zwischen einer clock() Zeiteinheit hatte man vermutlich um die 100 overflows im counter.
-
Soll das die Performance von timeGetTime messen?