Namespaces
Variants

std:: tuple_size

From cppreference.net
C++
Utilities library
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 ; // nicht definiert
(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)

Bietet Zugriff auf die Anzahl der Elemente in einem tuple-like Typ als einen Compile-time konstanten Ausdruck.

1) Die primäre Vorlage ist nicht definiert. Eine explizite (vollständige) oder partielle Spezialisierung ist erforderlich, um einen Typ tupelartig zu machen.
2-4) Spezialisierungen für cv-qualifizierte Typen verwenden standardmäßig den value aus den entsprechenden cv-unqualifizierten Versionen.

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 als nicht wohlgeformt behandelt wird, wenn es als nicht ausgewerteter Operand betrachtet wird, stellen sie das Mitglied value nicht bereit. Die Zugriffsprüfung wird durchgeführt, als ob in einem Kontext, der nicht mit tuple_size und T zusammenhängt. Nur die Gültigkeit des unmittelbaren Kontexts des Ausdrucks wird berücksichtigt. Dies ermöglicht 

#include <utility>
struct X { int a, b; };
const auto [x, y] = X(); // Structured Binding-Deklaration versucht zunächst
                         // tuple_size<const X>, was tuple_size<X>::value zu verwenden versucht,
                         // dann wird ein Soft-Fehler festgestellt, bindet an öffentliche Datenelemente
 (seit C++17)

Inhaltsverzeichnis

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)