Namespaces
Variants

std::span<T,Extent>:: span

From cppreference.net
constexpr span ( ) noexcept ;
(1) (depuis C++20)
template < class It >

explicit ( extent ! = std:: dynamic_extent )

constexpr span ( It first, size_type count ) ;
(2) (depuis C++20)
template < class It, class End >

explicit ( extent ! = std:: dynamic_extent )

constexpr span ( It first, End last ) ;
(3) (depuis C++20)
template < std:: size_t N >
constexpr span ( std:: type_identity_t < element_type > ( & arr ) [ N ] ) noexcept ;
(4) (depuis C++20)
template < class U, std:: size_t N >
constexpr span ( std:: array < U, N > & arr ) noexcept ;
(5) (depuis C++20)
template < class U, std:: size_t N >
constexpr span ( const std:: array < U, N > & arr ) noexcept ;
(6) (depuis C++20)
template < class R >

explicit ( extent ! = std:: dynamic_extent )

constexpr span ( R && r ) ;
(7) (depuis C++20)
explicit ( extent ! = std:: dynamic_extent )
constexpr span ( std:: initializer_list < value_type > il ) noexcept ;
(8) (depuis C++26)
template < class U, std:: size_t N >

explicit ( extent ! = std:: dynamic_extent && N == std:: dynamic_extent )

constexpr span ( const std:: span < U, N > & source ) noexcept ;
(9) (depuis C++20)
constexpr span ( const span & other ) noexcept = default ;
(10) (depuis C++20)

Construit un span .

Table des matières

Paramètres

first - itérateur vers le premier élément de la séquence
count - nombre d'éléments dans la séquence
last - itérateur après le dernier élément de la séquence ou une autre sentinelle
arr - tableau pour lequel construire une vue
r - plage pour laquelle construire une vue
source - un autre span à convertir
other - un autre span à copier

Effets

Surcharge data() après construction size() après construction
( 1 ) nullptr 0
( 2 ) std:: to_address ( first ) count
( 3 ) last - first
( 4 ) std:: data ( arr ) N
( 5 )
( 6 )
( 7 ) ranges:: data ( r ) ranges:: size ( r )
( 8 ) il. begin ( ) il. size ( )
( 9 ) source. data ( ) source. size ( )
( 10 ) other. data ( ) other. size ( )

Contraintes et informations supplémentaires

Exigences de taille

Si extent n'est pas std:: dynamic_extent et que la taille de la plage source est différente de extent , l'objet span ne peut pas être construit.

Ces surcharges participent à la résolution de surcharge uniquement si le résultat de l'expression suivante est true :

1) extent == std:: dynamic_extent || extent == 0
4-6) extent == std:: dynamic_extent || extent == N
9) extent == std:: dynamic_extent || N == std:: dynamic_extent || extent == N


Si le résultat de l'expression suivante est false , le comportement est indéfini.

(jusqu'à C++26)

Si le résultat de l'expression suivante est false :

  • Si l'implémentation est renforcée , une violation de contrat se produit. De plus, si le gestionnaire de violation de contrat retourne sous la sémantique d'évaluation "observer", le comportement est indéfini.
  • Si l'implémentation n'est pas renforcée, le comportement est indéfini.
(depuis C++26)
2) extent == std:: dynamic_extent || extent == count
3) extent == std:: dynamic_extent || extent == last - first
7) extent == std:: dynamic_extent || extent == ranges:: size ( r )
8) extent == std:: dynamic_extent || extent == il. size ( )
9) extent == std:: dynamic_extent || extent == source. size ( )

Exigences de conversion

Si element_type est différent du type d'élément de la plage source, et que ce dernier ne peut pas être converti en le premier par qualification conversion , l'objet span ne peut pas être construit.

Ces surcharges participent à la résolution de surcharge seulement si std:: is_convertible_v < U ( * ) [ ] , element_type ( * ) [ ] > est true , où U est défini comme suit :

4-6) std:: remove_pointer_t < decltype ( std:: data ( arr ) ) >
9) U

Exigences de concept

Si un argument de template ne modélise pas certains concept(s), l'objet span ne peut pas être construit.

Ces surcharges participent à la résolution de surcharge uniquement si l'argument de modèle correspondant au paramètre de modèle spécifié satisfait aux concepts correspondants. S'il ne respecte pas les exigences sémantiques d'un concept correspondant, le comportement est indéfini :

Surcharge Paramètre
template
Concept Remarque
( 2 ) It contiguous_iterator
( 3 ) It contiguous_iterator
End sized_sentinel_for<It>
( 7 ) R contiguous_range
sized_range
borrowed_range requis uniquement si std:: is_const_v < element_type > est false

Autres contraintes

2) Si [ first , first + count ) n'est pas un intervalle valide , le comportement est indéfini.
3) Cette surcharge participe à la résolution de surcharge seulement si std:: is_convertible_v < End, std:: size_t > est false .
Si [ first , last ) n'est pas une plage valide, le comportement est indéfini.
7) Cette surcharge participe à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :
8) Cette surcharge participe à la résolution de surcharge uniquement si std:: is_const_v < element_type > est true .

Exceptions

2) Ne lance rien.
3) Lance quoi et quand last - first lance.
7) Lance quoi et quand std :: ranges:: size ( r ) et std :: ranges:: data ( r ) lancent.

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_span_initializer_list 202311L (C++26) Construction de std::span à partir d'un std::initializer_list , ( 8 )

Exemple

#include <array>
#include <iostream>
#include <span>
#include <vector>
void print_span(std::span<const int> s)
{
    for (int n : s)
        std::cout << n << ' ';
    std::cout << '\n';
}
int main()
{
    int c[]{1, 2, 3};
    print_span(c); // construit à partir d'un tableau
    std::array a{4, 5, 6};
    print_span(a); // construit à partir de std::array
    std::vector v{7, 8, 9};
    print_span(v); // construit à partir de std::vector
#if __cpp_lib_span_initializer_list
    print_span({0, 1, 2}); // construit à partir d'initializer_list
#else
    print_span({{0, 1, 2}}); // idem, une solution de contournement
#endif
}

Sortie :

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

Voir aussi

accès direct au stockage contigu sous-jacent
(fonction membre publique)
retourne le nombre d'éléments
(fonction membre publique)
assigne un span
(fonction membre publique)
(C++17) (C++20)
retourne la taille d'un conteneur ou d'un tableau
(fonction template)
(C++17)
obtient le pointeur vers le tableau sous-jacent
(fonction template)