habe einen vector welche Zustände darstellt.

std::vector<int> vState;

diese zustände will ich iterieren (was schnell gehen muss).

nun wollte ich die Zustände in einer klasse Kapseln:

class States{

std::vector<int> m_vState;
.
.
.
const int& operator[](const &size_t iIndex){
 return m_vState[iIndex];
}
}

Dadurch das ich in dem []operator den index bzw. den wert als referenz zurückgebe, dürfte die iteration über die klasse nich langsamer sein oder?

//edit:
Im Prinzip wäre es bei int langsamer, da du eine 4-bytes-große Adresse auf ein 4-bytes-großes int zurück geben würdest, genauso wie du eine Adresse auf ein vermutlich 4-bytes-großes size_t übergeben würdest.

Aber alles egal, wegen inline!

aber recht hast du: implizites inline -> völlig egal.

States oS;

int i= oS[5];

wird inline so optimiert:

States oS;

int i=oS.m_vStates[5];

aber es gibt 64bit compiler, die ein 32bit int definiert haben.

MSVC zum bleistift

size_t sollte nicht so groß wie int sondern wie der systemübliche zeiger sein. das ist auf den meisten systemen haarspalterei, aber es gibt 64bit compiler, die ein 32bit int definiert haben.

Ich dachte, das wäre so definiert, also Integer-Grösse:

typedef unsigned int size_t;

diese zustände will ich iterieren (was schnell gehen muss).

Woher weißt du, dass das scnellgehen muss? hast du das gemessen oder geschätzt?

@nexus so kann es definiert werden, wenn int und die größe des zeigers zusammenfallen. aber bei einem compiler, der eine unterschiedliche größen für ints und zeiger hat (wie der von hustbaer erwähnte 64bit-compiler von ms), wird er normalerweise über die größe des zeigers realisiert, damit bspw vector<char> auch den kompletten speicher nutzen kann.

Aber ist das nicht irgendwo festgelegt? Denn wenn ich im VC++ 2008 mit dem Cursor über size_t fahre, kommt ein Tipp mit typedef unsigned int size_t. Aber die Deklaration konnte ich nicht finden, ist sie in einer Bibliothek? Oder ist das vom Compiler selbst abhängig?

hustbaer schrieb:

aber es gibt 64bit compiler, die ein 32bit int definiert haben.

MSVC zum bleistift

Ist mir erst jetzt aufgefallen

Aber ist das nicht irgendwo festgelegt?

leider nein.

Nexus schrieb:

Oder ist das vom Compiler selbst abhängig?

ja. jeder compiler darf selber entscheiden, wie er das realisiert. er muss nur die c/c++-regeln aus dem standard einhalten.

size_t sollte nicht so groß wie int sondern wie der systemübliche zeiger sein. das ist auf den meisten systemen haarspalterei, aber es gibt 64bit compiler, die ein 32bit int definiert haben.

Gibt es denn 64 bit compiler, bei denen int 64 bit hat?

wie ich schon schrieb: der gcc nutzt meines wissen nach int mit 64bit.

nein
gcc mit x64 target:

int 32bit
long 64bit
long long 64bit

cl mit x64 target:

int 32bit
long 32bit
long long 64bit

meiner Meinung nach sind das keine Kriterien über die du dir Gedanken machen
mußt. Wenn es allerdings wirklich so zeitkritisch ist, würde ich eine
Funktion:

const std::vector<int>& getStates() const;

machen und dann so drüber iterieren:

const std::vector<int>& vec = obj->getStates();
std::vector<int>::const_iterator end = vec.end();
for(std::vector<int>::const_iterator it = vec.begin(); it!=end; ++it){
int j = *it;
}

Das ist glaube ich einen Zeiger-Zugriff schneller als die Adressierung per
Index. Lasse mich aber auch gerne vom Gegenteil überzeugen ^^
Alternativ kannst du natürlich auch zwei Methoden in deiner Klasse zur
Verfügung stellen:

typedef std::vector<int>::const_iterator const_iterator;

const_iterator begin() const;
const_iterator end() const;

States::const_iterator end = obj->end();
for(States::const_iterator it = obj->begin(); it!=end; ++it){
int j = *it;
}

EDIT: obj->end() vor for-Schleife gezogen.

Gruß,
CSpille