C++ Academy · Leçon

Passer des spans aux fonctions

Écrire des API flexibles

Passer des spans aux fonctions est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Une fonction, de nombreux conteneurs

Une fonction prenant std::span accepte aussi bien les tableaux, les vecteurs que les tampons bruts, sans modèles ni surcharges supplémentaires.

#include <iostream>
#include <span>
#include <vector>
#include <array>
int sum(std::span<const int> s) {
    int t = 0; for (int x : s) t += x; return t;
}
int main() {
    std::vector<int> v = {1, 2, 3};
    std::array<int, 2> a = {4, 5};
    std::cout << sum(v) << " " << sum(a) << "\n";
}

Aucun paramètre de taille nécessaire

Les anciennes API de style C transmettent un pointeur et une taille distincte. Une vue span regroupe les deux, ce qui élimine les erreurs dues à des longueurs incohérentes.

#include <iostream>
#include <span>
void printAll(std::span<const int> s) {
    for (int x : s) std::cout << x << " ";
    std::cout << "\n";
}
int main() {
    int buf[] = {7, 8, 9};
    printAll(buf); // size inferred
}

Vue span const en lecture seule

Utilisez std::span<const T> pour garantir que la fonction ne modifiera pas les données de l'appelant.

#include <iostream>
#include <span>
int maxOf(std::span<const int> s) {
    int m = s[0];
    for (int x : s) if (x > m) m = x;
    return m;
}
int main() {
    int data[] = {3, 9, 4};
    std::cout << maxOf(data) << "\n"; // 9
}

Vue span modifiable pour modifier sur place

Une vue span non const permet à une fonction de modifier directement les éléments de l'appelant.

#include <iostream>
#include <span>
#include <vector>
void doubleAll(std::span<int> s) {
    for (int& x : s) x *= 2;
}
int main() {
    std::vector<int> v = {1, 2, 3};
    doubleAll(v);
    std::cout << v[2] << "\n"; // 6
}

Évite la multiplication des instanciations

Sans vue span, vous pourriez utiliser un modèle paramétré par le type de conteneur, ce qui générerait de nombreuses instanciations. Une vue span fournit une seule signature concrète qui fonctionne directement.

Évite les copies

Transmettre une vue span ne copie jamais les éléments ; seuls un pointeur et une longueur sont transmis à la fonction.

#include <iostream>
#include <span>
#include <vector>
size_t count(std::span<const int> s) { return s.size(); }
int main() {
    std::vector<int> big(1000, 0);
    std::cout << count(big) << "\n"; // no copy of 1000 ints
}

Les vues span vides sont acceptables

Une fonction doit gérer correctement une vue span vide ; size() vaut zéro et la boucle basée sur une plage s'exécute simplement zéro fois.

#include <iostream>
#include <span>
int sum(std::span<const int> s) { int t = 0; for (int x : s) t += x; return t; }
int main() {
    std::span<const int> empty;
    std::cout << sum(empty) << "\n"; // 0
}

Passage par valeur

Les vues span sont minuscules : transmettez-les par valeur, et non par référence. Copier un pointeur et une longueur est pratiquement gratuit.

Documenter l'intention de const

Choisir span<const T> plutôt que span<T> indique immédiatement aux appelants si leurs données peuvent être modifiées.

L'appelant conserve la propriété

L'appelant reste propriétaire du conteneur ; la vue span ne l'emprunte que pendant la durée de l'appel. La fonction ne doit pas conserver la vue span au-delà de cet appel.

Un style d'API moderne

Accepter une vue span est la manière moderne et idiomatique d'écrire des fonctions travaillant sur des données contiguës : c'est flexible, sûr et sans copie.

Vérification rapide

Vérifiez votre compréhension de la transmission des vues span.

Récapitulatif

Vous avez appris à transmettre des vues span aux fonctions :

Une seule signature accepte les tableaux, les vecteurs et les tampons.
span<const T> pour la lecture seule ; span<T> pour modifier sur place.
Le passage par valeur ne copie rien.
L'appelant conserve la propriété ; ne conservez pas la vue span après l'appel.

Questions Fréquemment Posées

La leçon « Passer des spans aux fonctions » est-elle gratuite ?

Oui — le texte complet de « Passer des spans aux fonctions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Passer des spans aux fonctions » ?

Écrire des API flexibles Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Passer des spans aux fonctions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy