Namespaces
Variants

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

From cppreference.net
C++
Containers library
std::span
template < std:: size_t Offset,

std:: size_t Count = std:: dynamic_extent >
constexpr std:: span < element_type, /* voir ci-dessous */ >

subspan ( ) const ;
(1) (depuis C++20)
constexpr std:: span < element_type, std:: dynamic_extent >

subspan ( size_type offset,

size_type count = std:: dynamic_extent ) const ;
(2) (depuis C++20)

Obtient une sous-vue sur certains éléments consécutifs de cette étendue, les éléments à inclure sont déterminés par un nombre d'éléments et un décalage.

1) Le nombre d'éléments et le décalage sont fournis comme arguments de modèle, et la sous-vue a une étendue dynamique uniquement si Count et Offset sont tous deux std:: dynamic_extent .
  • Si Count est std:: dynamic_extent , la sous-vue contient tous les éléments à partir du Offset ème .
  • Sinon, la sous-vue contient Count éléments à partir du Offset ème .
Désignons le deuxième argument template du type de retour comme FinalExtent , il est défini comme Count ! = std:: dynamic_extent
? Count
: ( Extent ! = std:: dynamic_extent
? Extent - Offset
: std:: dynamic_extent ) .
Si Offset <= Extent && ( Count == std:: dynamic_extent || Count <= Extent - Offset ) est false , le programme est mal formé.

Si Offset <= size ( ) && ( Count == std:: dynamic_extent || Count <= size ( ) - Offset ) est false , le comportement est indéfini.

(jusqu'à C++26)

Si Offset <= size ( ) && ( Count == std:: dynamic_extent || Count <= size ( ) - Offset ) 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) Le nombre d'éléments et le décalage sont fournis comme arguments de fonction, et la sous-vue a toujours une étendue dynamique.
  • Si count est std:: dynamic_extent , la sous-vue contient tous les éléments à partir du offset ème .
  • Sinon, la sous-vue contient count éléments à partir du offset ème .

Si offset <= size ( ) && ( count == std:: dynamic_extent || count <= size ( ) - offset ) est false , le comportement est indéfini.

(jusqu'à C++26)

Si offset <= size ( ) && ( count == std:: dynamic_extent || count <= size ( ) - offset ) 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)

Valeur de retour

1) std:: span < element_type, FinalExtent >
( data ( ) + Offset, Count ! = std:: dynamic_extent ? Count : size ( ) - Offset ) )
2) std:: span < element_type, std:: dynamic_extent >
( data ( ) + offset, count ! = std:: dynamic_extent ? count : size ( ) - offset ) )
**Note:** Le texte à traduire ne contient que le numéro "2)" qui est déjà universellement compris. Le reste du contenu est soit : - Des balises HTML (conservées intactes) - Du code C++ dans des balises ` ` (non traduit selon les instructions) - Des termes spécifiques C++ comme `std::span`, `element_type`, `dynamic_extent` (non traduits selon les instructions) Aucune traduction supplémentaire n'était donc nécessaire.

Exemple

Exécuter ce code 
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <ranges>
#include <span>
void display(std::span<const char> abc)
{
    const auto columns{20U};
    const auto rows{abc.size() - columns + 1};
    for (auto offset{0U}; offset < rows; ++offset)
    {
        std::ranges::for_each(abc.subspan(offset, columns), std::putchar);
        std::puts("");
    }
}
int main()
{
    char abc[26];
    std::ranges::iota(abc, 'A');
    display(abc);
}

Sortie : 

ABCDEFGHIJKLMNOPQRST
BCDEFGHIJKLMNOPQRSTU
CDEFGHIJKLMNOPQRSTUV
DEFGHIJKLMNOPQRSTUVW
EFGHIJKLMNOPQRSTUVWX
FGHIJKLMNOPQRSTUVWXY
GHIJKLMNOPQRSTUVWXYZ

Voir aussi

obtient un sous-span constitué des premiers N éléments de la séquence
(fonction membre publique)
obtient un sous-span constitué des derniers N éléments de la séquence
(fonction membre publique)