std::size_t

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Dienstprogramm-Bibliotheken

Sprachunterstützung Typunterstützung (Basistypen, RTTI) Bibliotheks-Feature-Test-Makros (C++20) Programm-Dienstprogramme Variadische Funktionen initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine-Unterstützung (C++20) Vertragsunterstützung (C++26) Drei-Wege-Vergleich three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Allgemeine Hilfsmittel Funktionsobjekte Bit-Manipulation (C++20) bitset hash (C++11) Relationale Operatoren (in C++20 veraltet) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Ganzzahl-Vergleichsfunktionen cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap und Typ-Operationen swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Gemeinsame Vokabulartypen pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Typunterstützung

Basistypen
Ganzzahltypen mit fester Breite (C++11)
Gleitkommatypen mit fester Breite (C++23)
ptrdiff_t size_t max_align_t (C++11)     byte (C++17)	nullptr_t (C++11) offsetof NULL
Numerische Grenzwerte
numeric_limits
C-Schnittstelle für numerische Grenzwerte
Laufzeit-Typinformationen
type_info type_index (C++11)	bad_typeid bad_cast

 

Definiert in Header <cstddef>
Definiert in Header <cstdio>
Definiert in Header <cstdlib>
Definiert in Header <cstring>
Definiert im Header <ctime>
Definiert in Header <cuchar>		(seit C++17)
Definiert in Header <cwchar>
typedef /* implementierungsabhängig */ size_t;

std::size_t ist der vorzeichenlose Integer-Typ des Ergebnisses der folgenden Operatoren

• sizeof

sizeof... alignof

(seit C++11)

Wenn ein Programm versucht, einen überdimensionierten Typ zu bilden (d.h. die Anzahl der Bytes in seiner Objektdarstellung überschreitet den maximalen Wert, der in std::size_t dargestellt werden kann), ist das Programm fehlerhaft.

Die Bitbreite von std::size_t ist nicht kleiner als 16.

(seit C++11)

Hinweise

std::size_t kann die maximale Größe eines theoretisch möglichen Objekts eines beliebigen Typs (einschließlich Arrays) speichern. Auf vielen Plattformen (eine Ausnahme bilden Systeme mit segmentierter Adressierung) kann std::size_t sicher den Wert eines beliebigen Nicht-Member-Zeigers speichern, in diesem Fall ist es synonym mit std::uintptr_t.

std::size_t wird häufig für Array-Indizierung und Schleifenzählungen verwendet. Programme, die andere Typen wie unsigned int für die Array-Indizierung verwenden, können auf z.B. 64-Bit-Systemen fehlschlagen, wenn der Index UINT_MAX überschreitet oder wenn er auf 32-Bit-Modulararithmetik angewiesen ist.

Beim Indizieren von C++-Containern wie std::string, std::vector usw. ist der geeignete Typ der von solchen Containern bereitgestellte verschachtelte Typ size_type. Er wird normalerweise als Synonym für std::size_t definiert.

Es ist nicht spezifiziert, ob die Deklaration von std::size_t in anderen Standardbibliotheksheadern verfügbar ist. Eine Implementierung kann vermeiden, diesen Namen einzuführen, auch wenn der Standard die Verwendung von std::size_t vorschreibt.

Das Suffix für Ganzzahl-Literale für std::size_t ist jede Kombination aus z oder Z mit u oder U (d.h. zu, zU, Zu, ZU, uz, uZ, Uz oder UZ).

(seit C++23)

Beispiel

Führen Sie diesen Code aus

#include <array>
#include <cstddef>
#include <iostream>
 
int main()
{
    std::array<std::size_t, 10> a;
 
    // Example with C++23 std::size_t literal
    for (auto i = 0uz; i != a.size(); ++i)
        std::cout << (a[i] = i) << ' ';
    std::cout << '\n';
 
    // Example of decrementing loop
    for (std::size_t i = a.size(); i--;)
        std::cout << a[i] << ' ';
    std::cout << '\n';
 
    // Note the naive decrementing loop:
    //  for (std::size_t i = a.size() - 1; i >= 0; --i) ...
    // is an infinite loop, because unsigned numbers are always non-negative
}

Ausgabe

0 1 2 3 4 5 6 7 8 9
9 8 7 6 5 4 3 2 1 0

Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
CWG 1122	C++98	std::size_t war zirkulär definiert	es ist implementierungsabhängig
CWG 1464	C++98	Objektgröße ist möglicherweise nicht in std::size_t darstellbar	ein solcher Typ ist fehlerhaft

Referenzen

• C++23 Standard (ISO/IEC 14882:2024)

• 6.8.4 Zusammengesetzte Typen [basic.compound] (S. 79-80)

• 7.6.2.5 Sizeof [expr.sizeof] (S. 136)

• 7.6.2.6 Alignof [expr.alignof] (S. 136)

• 17.2.4 Größen, Ausrichtungen und Offsets [support.types.layout] (S. 504-505)

• C++20 Standard (ISO/IEC 14882:2020)

• 6.8.3 Zusammengesetzte Typen [basic.compound] (S. 75-76)

• 7.6.2.5 Sizeof [expr.sizeof] (S. 129-130)

• 7.6.2.6 Alignof [expr.alignof] (S. 130)

• 17.2.4 Größen, Ausrichtungen und Offsets [support.types.layout] (S. 507-508)

• C++17 Standard (ISO/IEC 14882:2017)

• 6.9.2 Zusammengesetzte Typen [basic.compound] (S. 81-82)

• 8.3.3 Sizeof [expr.sizeof] (S. 121-122)

• 8.3.6 Alignof [expr.alignof] (S. 129)

• 21.2.4 Größen, Ausrichtungen und Offsets [support.types.layout] (S. 479)

• C++14 Standard (ISO/IEC 14882:2014)

• 3.9.2 Zusammengesetzte Typen [basic.compound] (S. 73-74)

• 5.3.3 Sizeof [expr.sizeof] (S. 109-110)

• 5.3.6 Alignof [expr.alignof] (S. 116)

• 18.2 Typen [support.types] (S. 443-444)

• C++11 Standard (ISO/IEC 14882:2011)

• 5.3.3 Sizeof [expr.sizeof] (S. 111)

• 5.3.6 Alignof [expr.alignof] (S. 116)

• 18.2 Typen [support.types] (S. 454-455)

• C++03-Standard (ISO/IEC 14882:2003)

• 5.3.3 Sizeof [expr.sizeof] (S. 79)

• C++98 Standard (ISO/IEC 14882:1998)

• 5.3.3 Sizeof [expr.sizeof] (S. 77)

Siehe auch

ptrdiff_t	vorzeichenbehafteter Ganzzahltyp, der bei der Subtraktion zweier Zeiger zurückgegeben wird (typedef)
offsetof	Byte-Offset vom Anfang eines Standardlayout-Typs zu einem angegebenen Mitglied (function macro)
Ganzzahl-Literale	binäre,(seit C++14) dezimale, okale oder hexadezimale Zahlen vom Ganzzahltyp
C-Dokumentation für size_t