std::span est une vue de mémoire continue non possédée introduite dans C 20, qui est utilisée pour accéder de manière s?re et efficace à des données continues telles que des tableaux et des vecteurs sans copie ; 1. Span peut être créé à partir de vecteurs, de tableaux, de tableaux natifs, etc.?; 2. Prend en charge les opérations telles que la taille, la sous-portée, le premier, le dernier, etc.?; 3. Il ne possède pas les données, et il faut s'assurer que le cycle de vie de la mémoire pointée est plus long que la durée elle-même ; 4. Souvent utilisé pour éviter la copie de grands tableaux et améliorer les performances?; 5. Il ne convient pas aux conteneurs non continus tels que list et deque?; lorsque vous l'utilisez, vous devez activer la norme C20 et faire attention à éviter les références pendantes.

std::span est une vue conteneur légère et non propriétaire introduite dans C 20, utilisée pour accéder en toute sécurité à des séquences de mémoire continues (telles que des tableaux, std::array , std::vector , etc.) sans copier de données. C'est similaire aux combinaisons de longueur de pointeur, mais plus s?re et plus facile à utiliser.

Voici un exemple typique d'utilisation de std::span?:

? Exemples d'utilisation de base

 #include <iostream>
#include <span>
#include <vecteur>
#include <tableau>

void print_span(std::span<int> sp) {
    std::cout << "Taille de la portée?: " << sp.size() << &#39;\n&#39;;
    pour (int x : sp) {
        std :: cout << x << &#39; &#39;;
    }
    std :: cout << &#39;\n&#39;;
}

int main() {
    // 1. Créer un span à partir de std :: vector
    std::vecteur<int> vec = {10, 20, 30, 40, 50};
    std::span<int> vec_sp(vec); // ou vec.data(), vec.size()
    print_span(vec_sp);

    // 2. Créer un span à partir de std :: array
    std::array<int, 4> arr = {1, 2, 3, 4};
    std::span<int, 4> arr_sp(arr); // Le deuxième paramètre du modèle est facultatif (étendue statique)
    print_span(arr_sp);

    // 3. Créer un span à partir d&#39;un tableau natif
    int raw_arr[] = {100, 200, 300}?;
    std :: span raw_sp (raw_arr);
    print_span(raw_sp);

    // 4. Créer une sous-portée
    auto sub_sp = vec_sp.subspan(1, 3); // à partir de l&#39;index 1, prenez 3 éléments std::cout << "Subspan: ";
    pour (int x : sub_sp) {
        std :: cout << x << &#39; &#39;;
    }
    std :: cout << &#39;\n&#39;;

    renvoie 0?;
}

Sortir:

 Taille de la portée?:?5
10 20 30 40 50 
Taille de la portée?:?4
1 2 3 4 
Taille de la portée?:?3
100 200 300 
Sous-portée?: 20 30 40

? Descriptions des fonctionnalités clés

? Tapez la signature

 std::span<T> // taille dynamique std::span<T, N> // taille statique N

• T est le type d'élément.
• N est la taille connue au moment de la compilation (facultatif).

?Sources de données prises en charge

• std::vector
• std::array
• Tableau de style C
• longueur du pointeur vers la mémoire contigu?

? Les conteneurs non continus tels que std::list et std::deque ne sont pas pris en charge.

? Opérations courantes

 sp.size() // Nombre d'éléments sp.empty()
sp[i] //élément d'accès (ne vérifie pas les limites)
sp.at(i) // Accéder aux éléments (avec vérification des limites, pris en charge depuis C 23)
sp.data() // Renvoie le pointeur d'origine sp.first(n) // La sous-étendue des n premiers éléments
sp.last(n) //Les n derniers éléments sp.subspan(pos, len) //La section du milieu

? Scénario d'application pratique?: évitez de copier de grands tableaux

 void process_data(std::span<const double> data) {
    pour (double x : données) {
        // Traitement en lecture seule, pas de copie std::cout << x << &#39; &#39;;
    }
    std :: cout << &#39;\n&#39;;
}

int main() {
    std::vector<double> big_data(1000, 3.14);
    process_data(big_data); // Passe la vue, ne copie pas return 0;
}

? Précautions

• std::span n'est pas propriétaire des données , garantissant que les données vers lesquelles elles pointent ont une durée de vie plus longue que la durée.

  

• Ne renvoie pas span d'un tableau local?:

   std::span<int> bad() {
      int arr[10] = {};
      return std :: span (arr); // ? Pointeur pendant !
  }

• Le compilateur doit prendre en charge C 20?:

   g -std=c 20 -o span_example span_example.cpp

  ---

  C'est essentiellement ?a. std::span est le moyen recommandé pour gérer les vues de données continues dans le C moderne, en rempla?ant les pointeurs bruts et pair<t size_t></t> , rendant le code plus clair et plus s?r.

  Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!