Namespaces
Variants

    std::tuple_size

    Von de.cppreference.net
     
    C++
     
    Dienstprogrammbibliothek
    Sprachunterstützung
    Typunterstützung (Basistypen, RTTI)
    Feature-Test-Makros der Bibliothek (C++20)
    Programm-Dienstprogramme
    Variadische Funktionen
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    Koroutinen-Unterstützung (C++20)
    Vertragsunterstützung (C++26)
    Dreiseitiger Vergleich
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    Allgemeine Dienstprogramme
    Relationale Operatoren (veraltet in C++20)
    Ganzzahl-Vergleichsfunktionen
    (C++20)(C++20)(C++20)    
    (C++20)
    Tausch und Typoperationen
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    Allgemeine Vokabular-Typen
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    Definiert in Header <array>
    Definiert in Header <tuple>
    Definiert in Header <utility>
    Definiert in Header <ranges>
    (seit C++20)
    Definiert in Header <complex>
    (seit C++26)
    		 
    template< class T >
struct tuple_size; // not defined
    		(1) (seit C++11) 
    template< class T >
struct tuple_size< const T >
    : std::integral_constant<std::size_t, std::tuple_size<T>::value> {};
    		(2) (seit C++11) 
    template< class T >
struct tuple_size< volatile T >
    : std::integral_constant<std::size_t, std::tuple_size<T>::value> {};
    		(3) (seit C++11)
    (veraltet in C++20) 
    template< class T >
struct tuple_size< const volatile T >
    : std::integral_constant<std::size_t, std::tuple_size<T>::value> {};
    		(4) (seit C++11)
    (veraltet in C++20)

    Ermöglicht den Zugriff auf die Anzahl der Elemente in einem tuple-ähnlichen Typ als konstanten Ausdruck zur Compile-Zeit.

    1) Die primäre Schablone ist nicht definiert. Eine explizite (vollständige) oder partielle Spezialisierung ist erforderlich, um einen Typ tuple-ähnlich zu machen.
    2-4) Spezialisierungen für cv-qualifizierte Typen verwenden standardmäßig die value der entsprechenden nicht-cv-qualifizierten Versionen wieder.

    std::tuple_size Interagiert mit der Kernsprache: Es kann Structured Binding-Unterstützung im tuple-ähnlichen Fall bereitstellen.

    (2-4) sind SFINAE-freundlich: Wenn std::tuple_size<T>::value bei Behandlung als nicht ausgewerteter Operand ungültig ist, stellen sie das Member value nicht bereit. Die Zugriffsprüfung wird so durchgeführt, als ob sie in einem Kontext ohne Bezug zu tuple_size und T stattfände. Es wird nur die Gültigkeit des unmittelbaren Kontexts des Ausdrucks berücksichtigt. Dies erlaubt 

    #include <utility>

struct X { int a, b; };
const auto [x, y] = X(); // structured binding declaration first attempts
                         // tuple_size<const X> which attempts to use tuple_size<X>::value,
                         // then soft error encountered, binds to public data members
    		(seit C++17)

    Spezialisierungen

    Die Standardbibliothek bietet folgende Spezialisierungen für Standardbibliothekstypen:

    (C++11)
    		ermittelt die Größe

    eines tuple
    (Klassentemplate-Spezialisierung)

    (C++11)
    		ermittelt die Größe eines pair
    (Klassentemplate-Spezialisierung)
    (C++11)
    		ermittelt die Größe eines array
    (Klassentemplate-Spezialisierung)
    (C++20)
    		ermittelt die Größe eines std::ranges::subrange
    (Klassentemplate-Spezialisierung)
    (C++26)
    		ermittelt die Größe eines std::complex
    (Klassentemplate-Spezialisierung)

    Alle Spezialisierungen von std::tuple_size erfüllen UnaryTypeTrait mit Basis-Charakteristik std:: integral_constant < std:: size_t , N > für ein bestimmtes N .

    Benutzer können std::tuple_size für programmdefinierte Typen spezialisieren, um diese tupelartig zu gestalten. Programmdefinierte Spezialisierungen müssen die oben genannten Anforderungen erfüllen.

    In der Regel müssen nur Spezialisierungen für cv-unqualifizierte Typen angepasst werden.

    Hilfsvariablen-Template

    Definiert im Header <tuple>
    template < class T >
    constexpr std:: size_t tuple_size_v = tuple_size < T > :: value ;
    		(seit C++17)

    Geerbt von std:: integral_constant

    Member-Konstanten

    value
    [static]
    		für eine Standardspezialisierung, die Anzahl der Elemente im tupelartigen Typ T
    (öffentliche statische Member-Konstante)

    Member-Funktionen

    operator std::size_t
    		konvertiert das Objekt zu std:: size_t , gibt value zurück
    (öffentliche Member-Funktion)
    operator()
    (C++14)
    		gibt value zurück
    (öffentliche Member-Funktion)

    Member-Typen

    Typ Definition
    value_type std:: size_t
    type std:: integral_constant < std:: size_t , value >

    Beispiel

    Diesen Code ausführen 
    #include <array>
#include <cstddef>
#include <ranges>
#include <tuple>
#include <utility>
template<class T, std::size_t Size> struct Arr { T data[Size]; };
// Programmdefinierte Spezialisierung von std::tuple_size:
template<class T, std::size_t Size> struct std::tuple_size<Arr<T, Size>>
    : public integral_constant<std::size_t, Size> {};
int main()
{
    using tuple1 = std::tuple<int, char, double>;
    static_assert(3 == std::tuple_size_v<tuple1>); // verwendet using template (C++17)
    using array3x4 = std::array<std::array<int, 3>, 4>;
    static_assert(4 == std::tuple_size<array3x4>{}); // verwendet operator std::size_t
    using pair = std::pair<tuple1, array3x4>;
    static_assert(2 == std::tuple_size<pair>()); // verwendet operator()
    using sub = std::ranges::subrange<char*, char*>;
    static_assert(2 == std::tuple_size<sub>::value);
    using Arr5 = Arr<int, 5>;
    static_assert(5 == std::tuple_size_v<Arr5>);
}

    Fehlerberichte

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

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 2212 C++11 Spezialisierungen für cv-Typen waren in einigen Headern nicht erforderlich, was zu Mehrdeutigkeit führte erforderlich

    Siehe auch

    Structured binding (C++17) bindet die angegebenen Namen an Teilobjekte oder Tupel-Elemente des Initialisierers
    (C++11)
    		ermittelt die Elementtypen eines tupelartigen Typs
    (Klassen-Template)
    (C++11)
    		erstellt ein tuple durch Verkettung beliebig vieler Tupel
    (Funktions-Template)