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.

knivil

Messergebnisse, Kompiler und Optimierungseinstellungen posten!

SeppJ

Wenn du irgendeinen Unterschied misst, dann taugen deine Messmethoden oder dein Compiler nichts. Da muss das gleiche rauskommen.

Nexus

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

Videonauth

Und warum getter/setter verwenden und nicht die Operatoren = ++ usw. überladen, das würde eine viel natürlichere Nutzung im Programablauf ergeben.

cooky451

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?