Wann soll std :: size_t verwendet werden?

Ich frage mich nur, ob ich std::size_tstattdessen für Loops und andere Dinge verwenden soll int. Zum Beispiel:

#include <cstdint>

int main()
{
    for (std::size_t i = 0; i < 10; ++i) {
        // std::size_t OK here? Or should I use, say, unsigned int instead?
    }
}

Was ist im Allgemeinen die beste Vorgehensweise hinsichtlich des Verwendungszwecks std::size_t?

Eine gute Faustregel gilt für alles, was Sie in der Schleifenbedingung mit etwas vergleichen müssen, das natürlich ein std::size_tSelbst ist.

std::size_tist der Typ eines beliebigen sizeofAusdrucks und kann garantiert die maximale Größe eines Objekts (einschließlich eines Arrays) in C ++ ausdrücken. Durch die Erweiterung ist es auch garantiert groß genug für jeden Array-Index, so dass es ein natürlicher Typ für eine Schleife nach Index über ein Array ist.

Wenn Sie nur bis zu einer Zahl zählen, ist es möglicherweise natürlicher, entweder den Typ der Variablen zu verwenden, die diese Zahl enthält, oder ein intoder unsigned int(falls groß genug), da dies eine natürliche Größe für die Maschine sein sollte.

size_tist der Ergebnistyp des sizeofOperators.

Verwenden Sie diese Option size_tfür Variablen, die die Größe oder den Index in einem Array modellieren. size_tvermittelt Semantik: Sie wissen sofort, dass es sich um eine Größe in Bytes oder einen Index handelt und nicht nur um eine andere Ganzzahl.

Die Verwendung size_tzur Darstellung einer Größe in Bytes hilft außerdem dabei, den Code portabel zu machen.

Der size_tTyp soll die Größe von etwas angeben , so dass es natürlich ist, es zu verwenden, z. B. die Länge einer Zeichenfolge abzurufen und dann jedes Zeichen zu verarbeiten:

for (size_t i = 0, max = strlen (str); i < max; i++)
    doSomethingWith (str[i]);

Sie müssen natürlich auf Randbedingungen achten, da es sich um einen vorzeichenlosen Typ handelt. Die Grenze am oberen Ende ist in der Regel nicht so wichtig , da die maximalen in der Regel groß ist (obwohl es ist möglich , es zu bekommen). Die meisten Leute verwenden nur eine intfür solche Dinge, weil sie selten Strukturen oder Arrays haben, die groß genug werden, um die Kapazität davon zu überschreiten int.

Aber achten Sie auf Dinge wie:

for (size_t i = strlen (str) - 1; i >= 0; i--)

Dies führt aufgrund des Umbruchverhaltens vorzeichenloser Werte zu einer Endlosschleife (obwohl ich gesehen habe, dass Compiler davor warnen). Dies kann auch gelindert werden durch: (etwas schwerer zu verstehen, aber zumindest immun gegen Verpackungsprobleme):

for (size_t i = strlen (str); i-- > 0; )

Durch Verschieben des Dekrements in einen Nebeneffekt der Fortsetzungsbedingung nach der Überprüfung wird der Wert vor dem Dekrementieren auf Fortsetzung überprüft , es wird jedoch weiterhin der dekrementierte Wert innerhalb der Schleife verwendet (weshalb die Schleife len .. 1nicht ausgeführt wird len-1 .. 0).

Per Definition size_tist das Ergebnis des sizeofOperators. size_twurde erstellt, um sich auf Größen zu beziehen.

Bei der Häufigkeit, mit der Sie etwas tun (in Ihrem Beispiel 10), geht es nicht um Größen. Warum also verwenden size_t? int, oder unsigned intsollte in Ordnung sein.

Natürlich ist es auch relevant, was Sie iinnerhalb der Schleife tun . Wenn Sie es an eine Funktion übergeben, die unsigned intbeispielsweise eine Auswahl übernimmt unsigned int.

In jedem Fall empfehle ich, implizite Typkonvertierungen zu vermeiden. Machen Sie alle Typkonvertierungen explizit.

size_tist eine sehr lesenswerte Methode, um die Größe eines Elements anzugeben - Länge einer Zeichenfolge, Anzahl der Bytes, die ein Zeiger benötigt usw. Es ist auch plattformübergreifend portierbar - Sie werden feststellen, dass sich 64-Bit und 32-Bit gut mit Systemfunktionen verhalten und size_t- etwas, das unsigned intmöglicherweise nicht funktioniert (z. B. wann sollten Sie verwendenunsigned long

kurze Antwort:

fast nie

lange Antwort:

Wann immer Sie einen Zeichenvektor benötigen, der größer als 2 GB auf einem 32-Bit-System ist. In jedem anderen Anwendungsfall ist die Verwendung eines signierten Typs viel sicherer als die Verwendung eines nicht signierten Typs.

Beispiel:

std::vector<A> data;
[...]
// calculate the index that should be used;
size_t i = calc_index(param1, param2);
// doing calculations close to the underflow of an integer is already dangerous

// do some bounds checking
if( i - 1 < 0 ) {
    // always false, because 0-1 on unsigned creates an underflow
    return LEFT_BORDER;
} else if( i >= data.size() - 1 ) {
    // if i already had an underflow, this becomes true
    return RIGHT_BORDER;
}

// now you have a bug that is very hard to track, because you never 
// get an exception or anything anymore, to detect that you actually 
// return the false border case.

return calc_something(data[i-1], data[i], data[i+1]);

Das signierte Äquivalent von size_tist ptrdiff_tnicht int. intIn den meisten Fällen ist die Verwendung jedoch immer noch viel besser als size_t. ptrdiff_tist longauf 32- und 64-Bit-Systemen.

Dies bedeutet, dass Sie immer zu und von size_t konvertieren müssen, wenn Sie mit einem std :: -Container interagieren, der nicht sehr schön ist. Auf einer laufenden nativen Konferenz erwähnten die Autoren von c ++ jedoch, dass das Entwerfen von std :: vector mit einer vorzeichenlosen Größe_t ein Fehler war.

Wenn Ihr Compiler Sie bei impliziten Konvertierungen von ptrdiff_t nach size_t warnt, können Sie dies mit der Konstruktorsyntax explizit machen:

calc_something(data[size_t(i-1)], data[size_t(i)], data[size_t(i+1)]);

Wenn Sie nur eine Sammlung iterieren möchten, ohne Grenzen zu überschreiten, verwenden Sie den Bereich basierend auf:

for(const auto& d : data) {
    [...]
}

Hier einige Worte von Bjarne Stroustrup (C ++ - Autor), wie man einheimisch wird

Für einige Leute ist dieser signierte / nicht signierte Designfehler in der STL Grund genug, nicht den std :: vector zu verwenden, sondern eine eigene Implementierung.

Verwenden Sie std :: size_t zum Indizieren / Zählen von Arrays im C-Stil.

Für STL-Container haben Sie (zum Beispiel) vector<int>::size_type, die zum Indizieren und Zählen von Vektorelementen verwendet werden sollten.

In der Praxis handelt es sich normalerweise um nicht signierte Ints, dies kann jedoch nicht garantiert werden, insbesondere wenn benutzerdefinierte Allokatoren verwendet werden.

Bald werden die meisten Computer 64-Bit-Architekturen mit 64-Bit-Betriebssystemen sein: Es werden Programme ausgeführt, die auf Containern mit Milliarden von Elementen ausgeführt werden. Dann Sie müssen verwenden , size_tanstatt intals Schleifenindex, sonst wird Ihr Index wird umschlingen am 2 ^ 32: te Element auf beiden 32- und 64-Bit - Systeme.

Bereite dich auf die Zukunft vor!

Seien Sie bei der Verwendung von size_t vorsichtig mit dem folgenden Ausdruck

size_t i = containner.find("mytoken");
size_t x = 99;
if (i-x>-1 && i+x < containner.size()) {
    cout << containner[i-x] << " " << containner[i+x] << endl;
}

Sie werden im if-Ausdruck falsch, unabhängig davon, welchen Wert Sie für x haben. Ich habe mehrere Tage gebraucht, um dies zu realisieren (der Code ist so einfach, dass ich keinen Komponententest durchgeführt habe), obwohl es nur wenige Minuten dauerte, um die Ursache des Problems herauszufinden. Ich bin mir nicht sicher, ob es besser ist, einen Cast zu machen oder Null zu verwenden.

if ((int)(i-x) > -1 or (i-x) >= 0)

Beide Wege sollten funktionieren. Hier ist mein Testlauf

size_t i = 5;
cerr << "i-7=" << i-7 << " (int)(i-7)=" << (int)(i-7) << endl;

Die Ausgabe: i-7 = 18446744073709551614 (int) (i-7) = - 2

Ich hätte gerne die Kommentare anderer.

size_t wird von verschiedenen Bibliotheken zurückgegeben, um anzuzeigen, dass die Größe dieses Containers ungleich Null ist. Sie verwenden es, wenn Sie einmal zurück sind: 0

In Ihrem obigen Beispiel ist das Schleifen eines size_t jedoch ein potenzieller Fehler. Folgendes berücksichtigen:

for (size_t i = thing.size(); i >= 0; --i) {
  // this will never terminate because size_t is a typedef for
  // unsigned int which can not be negative by definition
  // therefore i will always be >= 0
  printf("the never ending story. la la la la");
}

Die Verwendung von Ganzzahlen ohne Vorzeichen kann zu solchen subtilen Problemen führen. Daher bevorzuge ich es, size_t nur zu verwenden, wenn ich mit Containern / Typen interagiere, die dies erfordern.

size_tist ein vorzeichenloser Typ, der den maximalen ganzzahligen Wert für Ihre Architektur enthalten kann. Er ist daher vor ganzzahligen Überläufen aufgrund von Vorzeichen (vorzeichenbehaftetes int, 0x7FFFFFFFerhöht um 1 ergibt -1) oder kurzer Größe (vorzeichenloses kurzes int 0xFFFF, erhöht um 1) geschützt 0).

Es wird hauptsächlich in der Array-Indizierung / Schleifen / Adress-Arithmetik usw. verwendet. Funktionen wie memset()und werden size_tnur akzeptiert , da Sie theoretisch möglicherweise einen Speicherblock mit einer Größe haben 2^32-1(auf einer 32-Bit-Plattform).

Für solche einfachen Schleifen stören Sie nicht und verwenden Sie nur int.

size_t ist ein vorzeichenloser Integraltyp, der die größte Ganzzahl auf Ihrem System darstellen kann. Verwenden Sie es nur, wenn Sie sehr große Arrays, Matrizen usw. benötigen.

Einige Funktionen geben ein size_t zurück und Ihr Compiler warnt Sie, wenn Sie versuchen, Vergleiche durchzuführen.

Vermeiden Sie dies, indem Sie einen geeigneten signierten / nicht signierten Datentyp verwenden oder einfach für einen schnellen Hack typisieren.

size_t ist int ohne Vorzeichen int. Wann immer Sie unsigned int möchten, können Sie es verwenden.

Ich benutze es, wenn ich die Größe des Arrays angeben möchte, Zähler ect ...

void * operator new (size_t size); is a good use of it.