Was ist size_t in C?

Ich bin verwirrt mit size_tin C. Ich weiß, dass es vom sizeofBediener zurückgegeben wird. Aber was genau ist das? Ist es ein Datentyp?

Angenommen, ich habe eine forSchleife:

for(i = 0; i < some_size; i++)

Soll ich verwenden int i;oder size_t i;?

Aus Wikipedia :

Gemäß der ISO C-Norm von 1999 (C99) size_thandelt es sich um einen vorzeichenlosen Integer-Typ von mindestens 16 Bit (siehe Abschnitte 7.17 und 7.18.3).

size_tist ein vorzeichenloser Datentyp, der durch mehrere C / C ++ - Standards definiert ist, z. B. den C99 ISO / IEC 9899-Standard, der in definiert ist stddef.h. 1 Es kann weiter importiert werden, indem stdlib.hdiese Datei intern untergeordnet wird stddef.h.

Dieser Typ wird verwendet, um die Größe eines Objekts darzustellen. Bibliotheksfunktionen, die Größen annehmen oder zurückgeben, erwarten, dass sie vom Typ sind oder den Rückgabetyp haben size_t. Darüber hinaus sollte die am häufigsten verwendete compilerbasierte Operatorgröße von einen konstanten Wert ergeben, der mit kompatibel ist size_t.

Folglich size_tist ein Typ garantiert, der jeden Array-Index enthält.

size_tist ein vorzeichenloser Typ. Es können also keine negativen Werte (<0) dargestellt werden. Sie verwenden es, wenn Sie etwas zählen, und sind sicher, dass es nicht negativ sein kann. Gibt beispielsweise a strlen()zurück, size_tda die Länge eines Strings mindestens 0 sein muss.

Wenn in Ihrem Beispiel Ihr Schleifenindex immer größer als 0 sein soll, ist die Verwendung size_teines anderen vorzeichenlosen Datentyps möglicherweise sinnvoll .

Wenn Sie ein size_tObjekt verwenden, müssen Sie sicherstellen, dass Sie in allen verwendeten Kontexten, einschließlich der Arithmetik, nicht negative Werte wünschen. Nehmen wir zum Beispiel an, Sie haben:

size_t s1 = strlen(str1);
size_t s2 = strlen(str2);

und Sie möchten den Unterschied der Längen von str2und finden str1. Du kannst nicht tun:

int diff = s2 - s1; /* bad */

Dies liegt daran, dass der zugewiesene Wert diffimmer eine positive Zahl ist, auch wenn s2 < s1die Berechnung mit vorzeichenlosen Typen durchgeführt wird. In diesem Fall ist es je nach Anwendungsfall möglicherweise besser, int(oder long long) für s1und zu verwenden s2.

Es gibt einige Funktionen in C / POSIX, die verwendet werden könnten / sollten size_t, aber aus historischen Gründen nicht. Zum Beispiel sollte der zweite Parameter fgetsidealerweise sein size_t, ist es aber int.

size_t ist ein Typ, der jeden Array-Index enthalten kann.

Abhängig von der Implementierung kann es sich um Folgendes handeln:

unsigned char

unsigned short

unsigned int

unsigned long

unsigned long long

So size_tist in stddef.hmeiner Maschine definiert:

typedef unsigned long size_t;

Wenn Sie der empirische Typ sind ,

echo | gcc -E -xc -include 'stddef.h' - | grep size_t

Ausgabe für Ubuntu 14.04 64-Bit GCC 4.8:

typedef long unsigned int size_t;

Beachten Sie, dass stddef.hdies von GCC bereitgestellt wird und nicht unter src/gcc/ginclude/stddef.hGCC 4.2 angezeigt wird.

Interessante C99 Auftritte

• malloc nimmt size_t als Argument, so bestimmt es die maximale Größe, die zugewiesen werden kann.

  Und da wird es auch von zurückgegeben sizeof , begrenzt es meiner Meinung nach die maximale Größe eines Arrays.

  Siehe auch: Was ist die maximale Größe eines Arrays in C?

Die Manpage für types.h sagt:

size_t muss ein vorzeichenloser Integer-Typ sein

Da es noch niemand erwähnt hat, besteht die primäre sprachliche Bedeutung size_tdarin, dass der sizeofOperator einen Wert dieses Typs zurückgibt. Ebenso ist die Hauptbedeutung von, ptrdiff_tdass das Subtrahieren eines Zeigers von einem anderen einen Wert dieses Typs ergibt. Bibliotheksfunktionen, die dies akzeptieren, tun dies, weil solche Funktionen auf Objekten, auf denen solche Objekte vorhanden sein könnten, mit Objekten arbeiten können, deren Größe UINT_MAX überschreitet, ohne dass Aufrufer gezwungen werden, Code zu verschwenden, der auf Systemen mit dem größeren Typ einen Wert über "unsigned int" übergibt würde für alle möglichen Objekte ausreichen.

Um zu erklären, warum size_tes existieren musste und wie wir hierher kamen:

In pragmatischen Begriffen size_tund ptrdiff_tbei einer 64-Bit-Implementierung mit einer Breite von 64 Bit, bei einer 32-Bit-Implementierung mit einer Breite von 32 Bit usw. garantiert. Sie konnten keinen vorhandenen Typ dazu zwingen, dies auf jedem Compiler zu bedeuten, ohne den alten Code zu beschädigen.

Ein size_toder ptrdiff_tist nicht unbedingt dasselbe wie ein intptr_toder uintptr_t. Sie waren anders auf bestimmte Architekturen , die noch in Gebrauch waren , als size_tund ptrdiff_twurden dem Standard - in den späten 80er Jahren hinzugefügt und veralten , wenn C99 viele neue Arten hinzugefügt , aber noch nicht gegangen (wie 16-Bit - Windows). Das x86 im 16-Bit-geschützten Modus hatte einen segmentierten Speicher, in dem das größtmögliche Array oder die größtmögliche Struktur nur 65.536 Byte groß sein konnte, ein farZeiger jedoch 32 Bit breit und breiter als die Register sein musste. Auf denen intptr_twäre aber 32 Bit breit gewesen size_tundptrdiff_tkönnte 16 Bit breit sein und in ein Register passen. Und wer wusste, welche Art von Betriebssystem in Zukunft geschrieben werden könnte? Theoretisch bietet die i386-Architektur ein 32-Bit-Segmentierungsmodell mit 48-Bit-Zeigern, das noch kein Betriebssystem verwendet hat.

Der Typ eines Speicherversatzes könnte nicht sein, longweil viel zu viel Legacy-Code davon ausgeht, dass er longgenau 32 Bit breit ist. Diese Annahme wurde sogar in die UNIX- und Windows-APIs integriert. Leider gingen viele andere Legacy-Codes auch davon aus, dass a longbreit genug ist, um einen Zeiger, einen Datei-Offset, die Anzahl der Sekunden, die seit 1970 vergangen sind, usw. aufzunehmen. POSIX bietet jetzt eine standardisierte Möglichkeit, die letztgenannte Annahme anstelle der ersteren als wahr zu erzwingen, aber es ist auch keine tragbare Annahme zu treffen.

Es konnte nicht sein, intdass nur eine winzige Handvoll Compiler in den 90er Jahren int64 Bit breit waren. Dann wurden sie wirklich komisch, indem sie long32 Bit breit hielten . Die nächste Überarbeitung des Standards erklärte es für illegal int, breiter als zu sein long, ist aber intauf den meisten 64-Bit-Systemen immer noch 32 Bit breit.

Es konnte nicht sein long long int, was ohnehin später hinzugefügt wurde, da dieses selbst auf 32-Bit-Systemen mindestens 64 Bit breit war.

Es wurde also ein neuer Typ benötigt. Selbst wenn dies nicht der Fall wäre, bedeuteten all diese anderen Typen etwas anderes als einen Versatz innerhalb eines Arrays oder Objekts. Und wenn es eine Lehre aus dem Fiasko der 32-zu-64-Bit-Migration gab, sollte genau angegeben werden, welche Eigenschaften ein Typ haben muss, und nicht eine, die in verschiedenen Programmen unterschiedliche Bedeutungen hat.

size_tund intsind nicht austauschbar. Zum Beispiel size_tist Linux unter 64-Bit 64-Bit groß (dh sizeof(void*)), aber int32-Bit.

Beachten Sie auch, dass dies size_tnicht signiert ist. Wenn Sie eine signierte Version benötigen, gibt es diese ssize_tauf einigen Plattformen und sie wäre für Ihr Beispiel relevanter.

In der Regel würde ich mit vorschlagen intfür die meisten allgemeinen Fälle und nur verwenden size_t/ ssize_twenn es ein besonderer Bedarf dafür ist (mit mmap()zum Beispiel).

Wenn Sie bei 0 beginnen und nach oben gehen, verwenden Sie im Allgemeinen immer einen vorzeichenlosen Typ, um einen Überlauf zu vermeiden, der Sie in eine negative Wertsituation führt. Dies ist von entscheidender Bedeutung, denn wenn Ihre Array-Grenzen zufällig kleiner als das Maximum Ihrer Schleife sind, Ihr Schleifenmaximum jedoch größer als das Maximum Ihres Typs ist, werden Sie negativ umbrochen und es kann zu einem Segmentierungsfehler (SIGSEGV) kommen ). Verwenden Sie daher im Allgemeinen niemals int für eine Schleife, die bei 0 beginnt und nach oben geht. Verwenden Sie eine nicht signierte.

size_t ist ein vorzeichenloser ganzzahliger Datentyp. Auf Systemen, die die GNU C-Bibliothek verwenden, ist dies int ohne Vorzeichen oder long int ohne Vorzeichen. size_t wird üblicherweise für die Array-Indizierung und Schleifenzählung verwendet.

size_t oder ein beliebiger vorzeichenloser Typ kann als Schleifenvariable verwendet werden, da Schleifenvariablen normalerweise größer oder gleich 0 sind.

Wenn wir ein size_t- Objekt verwenden, müssen wir sicherstellen, dass in allen verwendeten Kontexten, einschließlich der Arithmetik, nur nicht negative Werte gewünscht werden. Zum Beispiel würde folgendes Programm definitiv das unerwartete Ergebnis liefern:

// C program to demonstrate that size_t or
// any unsigned int type should be used 
// carefully when used in a loop

#include<stdio.h>
int main()
{
const size_t N = 10;
int a[N];

// This is fine
for (size_t n = 0; n < N; ++n)
a[n] = n;

// But reverse cycles are tricky for unsigned 
// types as can lead to infinite loop
for (size_t n = N-1; n >= 0; --n)
printf("%d ", a[n]);
}

Output
Infinite loop and then segmentation fault

size_tist ein vorzeichenloser Integer-Datentyp, der nur 0 und mehr als 0 Integer-Werte zuweisen kann. Es misst Bytes der Größe eines Objekts und wird vom sizeofOperator zurückgegeben. constist die Syntaxdarstellung von size_t, aber ohne dass constSie das Programm ausführen können.

const size_t number;

size_tWird regelmäßig für die Array-Indizierung und Schleifenzählung verwendet. Wenn der Compiler ist 32-bit, würde es funktionieren unsigned int. Wenn der Compiler ist 64-bit, würde es auch funktionieren unsigned long long int. Dort für maximale Größe size_tje nach Compilertyp.

size_tdefiniert bereits auf <stdio.h>Header - Datei, aber es kann auch durch definieren <stddef.h>, <stdlib.h>, <string.h>, <time.h>, <wchar.h>Header.

• Beispiel (mit const)

#include <stdio.h>

int main()
{
    const size_t value = 200;
    size_t i;
    int arr[value];

    for (i = 0 ; i < value ; ++i)
    {
        arr[i] = i;
    }

    size_t size = sizeof(arr);
    printf("size = %zu\n", size);
}

Ausgabe -: size = 800

• Beispiel (ohne const)

#include <stdio.h>

int main()
{
    size_t value = 200;
    size_t i;
    int arr[value];

    for (i = 0 ; i < value ; ++i)
    {
        arr[i] = i;
    }

    size_t size = sizeof(arr);
    printf("size = %zu\n", size);
}

Ausgabe -: size = 800

Nach meinem Verständnis size_thandelt es sich um eine unsignedGanzzahl, deren Bitgröße groß genug ist, um einen Zeiger auf die native Architektur aufzunehmen.

Damit:

sizeof(size_t) >= sizeof(void*)