wie verhällt es sich bei den Operatoren bei den Ausdrücken

Objekt.Element
Objekt.*PointerAufElement(hier Offsetpointer)

PointerAufObjekt->Element
PointerAufObjekt->*PointerAufElement(hier Offsetpointer)

&Element

Bei welchem Ausdruck wird nur das Element in den Cash geladen und nicht das ganze Objekt um auf das Element zuzugreifen? Wie z.B. mit &Element wobei das umstendlich ist...

Danke, KEN

Mal der Versuch einer Beantwortung:
C++ macht keine Annahmen über Caching und konkrete Speicherverwaltung - das ist Sache des Betriebssystems. Also hängt es auch von deinem System (und vermutlich von der Größe des Gesamtobjekts) ab, ob das Programm bei einem Member-Zugriff das komplette Objekt oder nur die benötigten Teile in den Cache lädt.

Ich habe die Klasse

class Objekt
{
float Element;
...
};

wobei sizeof(O) = 322

Ich möchte nun diverse solcher Objekte auf Grund ihres Elementwertes bestimmten Bereichen zuordnen.
Also:

// ------------------------------------------------------------------------------------------------
// Zugriff über Objekt
// ------------------------------------------------------------------------------------------------

class Objekt
{
float Element;
...
};

Objekt O1, 02;
if (O1.Element > O2.Element) ...

?? Lade ich hierfür den Vergleich die ganzen O1 und O2 in den Cash um Zugriff auf die Elemente zu haben oder werden lediglich die Elemente in den Cash geladen, da es nur diese für den Vergleich benötigt?

// ------------------------------------------------------------------------------------------------
// Zugriff über PointerAufElement
// ------------------------------------------------------------------------------------------------

class Objekt
{
float Element;
...
};
Objekt O1, 02;

float *e1 = &(O1.Element);
float *e2 = &(O2.Element);

if (*e1 > *e2)

?? Hier werden nur die Elemente für den Vergleich in den Cash geladen (so denke ich)

// ------------------------------------------------------------------------------------------------
// Zugriff über PointerAufObjekt und Elementzeiger
// ------------------------------------------------------------------------------------------------

class Objekt
{
float Element;
...
};
float Objekt :: *ElementZeiger = &Objekt::Element;
Objekt *O1, *02;

if ( (O1->* ElementZeiger ) > (O2->* ElementZeiger))

?? Werden hier auch nur die Elementwerte für den Vergleich in den Cash geladen? Wenn ja, wäre ja super...

Ich habe ca. 10'000 solcher Objekte die ich in 10'000(Fakultät) Schritten zuteilen muss.
Dabei kann ich nicht ein Objekt nehmen und dann alle Vergleiche bei diesem durchführen.
Sondern der Vergleich geschieht bei jedem Schritt zwischen zwei anderen Objekten.
Da ich aber jedes Objekt mit jedem anderen Objekt vergleichen muss (darum Fakultät), muss ich jedes Objekt öfters aufrufen.
Wenn ich jedes Mal 322 Byte verschieben muss ist der Aufwand enorm und dies möchte ich vermeiden.

Ken

PS: Mir ist zwar nicht ganz klar, was du vorhast - aber eventuell solltest du deine Objekte sortieren, dann mußt du im weiteren Programmverlauf überhaupt nicht mehr auf die Elementvergleiche zurückgreifen, sondern kannst Indizes in deinem Array vergleichen.