class ST;//ST ist eine Klasse mit vielen Elementen
ST *pST;
pST = new ST[numST];

//hier kommts
//Nummer 1
for(int i=0; i < numST ; i++)
  {
  ST[i].Objekt = IRGENDWAS;
  }

//Nummer 2
ST *DurchlaufST;
for(int i=0, DurchlaufST = pST[0]; i < numST; i++,DurchlaufST++)
  {
  DurchlaufST->Objekt = IRGENDWAS;
  }

Teste es doch mal

Dann müsste bei dem hier doch Nummer 2 schneller sein, oder?

class Data
{
float Elements[NUM_ELEMENTS];
...
}

class ST
{
Data Datas[7];
...
}

ST *pST = new ST[numST];

//Nummer 1
for(int i=0; i<numST; i++)
  for(int j=0; j < 7; j++)
    {
    Funktion1(pST[i].Datas[j].Elements[0]);
    Funktion2(pST[i].Datas[j].Elements[4]);
    }

//Nummer 2
Data TempData;

for(int i=0; i<numST; i++)
  for(int j=0; j < 7; j++)
    {
    TempData = pST[i].Datas[j];

    Funktion1(TempData.Elements[0]);
    Funktion2(TempData.Elements[4]);
    }

//Nummer 1
for(int i=0; i<numST; i++)
  for(int j=0; j < 7; j++) //Quadratisches Wachstum durch 2 schleifen
    {
    Funktion1(pST[i].Datas[j].Elements[0]); //Ein Aufruf 2mal per . zugreifen
    Funktion2(pST[i].Datas[j].Elements[4]); // ""
    }

//Gesamt n² 2 aufrufe und 4 . zugriffe

//Nummer 2
Data TempData;

for(int i=0; i<numST; i++)
  for(int j=0; j < 7; j++) //n²
    {
    TempData = pST[i].Datas[j]; //  2 zuweisungen ....

    Funktion1(TempData.Elements[0]); //
    Funktion2(TempData.Elements[4]); // 3 . zugriffe und 2 mal Array
    }

ist nicht alles -.- hatte keine lust mehr xD
je mehr zuweisungen, aufrufe außerhalb der schleife stehen desto schneller wird die schleife, und schleifen erzeugen die programmlaufzeit

Funktion1(pST[i].Datas[j].Elements[0]); //Ein Aufruf 2mal per . zugreifen

Das hat doch nichts mit der Laufzeit zu tun, oder? Es könnte da auch stehen:

Funktion1(pST[i].Datas[j].Blablas.Extras.Irgendwas.Lalala.Elements[0]);

Im Maschinencode findet man dann doch nur den endgültigen Wert eben von Elements[0], oder?

MfG

dennoch ändert es nichts an der sache dass nr1 schneller sein müsste
da es nur 2 zuweisen beinhaltet

Edit:
Funktion1(pST[i].Datas[j].Blablas.Extras.Irgendwas.Lalala.Elements[0]);

ich glaub die auswärtung würde länger dauern

BigClass Class;
BigClass *pClass = new BigClass;
int a;

//1
Class.Object.Data.Element = 0;
//2
*pClass->Object->Data->Element = 0;
//3
a = 0;

Müsste doch alles gleich schnell sein, weil es im Maschinencode keine Klassen gibt.

#include <ctime>
...
clock_t a = clock();

Class.Object.Data.Element = 0;

clock_t b = clock();

dauer = b-a;

cout << dauer<<endl;

//1
Class.Object.Data.Element = 0;
//2
*pClass->Object->Data->Element = 0;

Seit wann werden, wenn man ein Object auf dem Heap anlegt, aus den Membern auch Pointer?
Und wenn pClass schon n Zeiger ist was soll dann das Dereferenzieren (*).

Meiner Meinung nach ist die Arraynotation in manchen Fällen schneller, da der Compiler Zuriffe per Zeiger nicht so gut optimieren kann. Ein Zeiger kann quasi überall hin zeigen. Bei Zugriff über [] in einer Schleife kann der Compiler annehmen, dass es sich um im Speicher zusammenhängende Blöcke handelt und dementsprechend optimieren.

Am besten man testet in jedem Fall was die schnellste Methode ist.

Verge

Edit:
Funktion1(pST[i].Datas[j].Blablas.Extras.Irgendwas.Lalala.Elements[0]);

ich glaub die auswärtung würde länger dauern

nein, würde sie nicht. aus ".Blablas.Extras.Irgendwas.Lalala.Elements" wird der compiler eine relative addresse berechnen können. am ende bleibt dann sowas stehen wie:

*(&(pST[i].Datas[j])+Offset)

und dann ist es egal, wielang diese Kette ist. sobald allerdings zeiger ins spiel kommen, wirds komplizierter.

@stelfer du weist schon, dass du clock() vergessen kannst, sobald das betriebssystem nebenbei noch irgendnen andren thread laufen lässt? mal davon ab, dass der compiler das einfach rausoptimieren würde, so wie es jetzt da steht.

Stelfer schrieb:

@stelfer du weist schon, dass du clock() vergessen kannst, sobald das betriebssystem nebenbei noch irgendnen andren thread laufen lässt? mal davon ab, dass der compiler das einfach rausoptimieren würde, so wie es jetzt da steht.

Falsch. Clock misst die Zeit die der Prozess verbraucht hat. Wenn der Prozess z.B. 5 sekunden arbeitet und zwischendrin 20sekunden vom Betriebssystem suspended wurde, zeigt clock tatsächlich nur 5 Sekunden an.

Anders ist das mit time() weil hier die absolute Zeit zwischen zwei Messungen angegeben wird.

hoffe es beschwert sich nun niemand

otze schrieb:

Stelfer schrieb:

@stelfer du weist schon, dass du clock() vergessen kannst, sobald das betriebssystem nebenbei noch irgendnen andren thread laufen lässt? mal davon ab, dass der compiler das einfach rausoptimieren würde, so wie es jetzt da steht.

Falsch. Clock misst die Zeit die der Prozess verbraucht hat. Wenn der Prozess z.B. 5 sekunden arbeitet und zwischendrin 20sekunden vom Betriebssystem suspended wurde, zeigt clock tatsächlich nur 5 Sekunden an.

Anders ist das mit time() weil hier die absolute Zeit zwischen zwei Messungen angegeben wird.

Ja, laut Doku/Standard ist das so. Laut Realität ist das zumindest auf Windows anders.