C++ Academy · Aula

Noções básicas de std::span

Visualizações não proprietárias de dados contíguos

Noções básicas de std::span é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Uma visão não proprietária

std::span<T> (C++20) é uma visão leve sobre uma sequência contígua, semelhante a string_view, mas para qualquer tipo de elemento. Inclua <span>.

#include <iostream>
#include <span>
#include <array>
int main() {
    std::array<int, 3> a = {1, 2, 3};
    std::span<int> s = a;
    std::cout << s.size() << "\n";
}

Spans não possuem os dados

Um span armazena um ponteiro e um comprimento; ele observa dados pertencentes a outro lugar e nunca copia os elementos.

#include <iostream>
#include <vector>
#include <span>
int main() {
    std::vector<int> v = {5, 6, 7};
    std::span<int> s = v;
    s[0] = 50; // modifies v
    std::cout << v[0] << "\n"; // 50
}

De um std::array

Um array é convertido automaticamente em um span, e o span enxerga todos os seus elementos.

#include <iostream>
#include <span>
#include <array>
int main() {
    std::array<int, 4> a = {1, 2, 3, 4};
    std::span<int> s{a};
    for (int x : s) std::cout << x << " ";
    std::cout << "\n";
}

De um vector

Um std::vector também é convertido em um span, oferecendo uma visão uniforme independentemente do contêiner subjacente.

#include <iostream>
#include <vector>
#include <span>
int main() {
    std::vector<int> v = {9, 8, 7};
    std::span<int> s = v;
    std::cout << s.front() << " " << s.back() << "\n";
}

De um ponteiro e um tamanho

Você pode criar um span a partir de um ponteiro bruto e de uma contagem, o que é útil para buffers no estilo de C.

#include <iostream>
#include <span>
int main() {
    int buf[] = {10, 20, 30};
    std::span<int> s(buf, 3);
    std::cout << s[1] << "\n"; // 20
}

Percorrendo um span

Spans permitem laços baseados em intervalo e a interface habitual de contêineres (size, front, back, data).

#include <iostream>
#include <span>
int main() {
    int buf[] = {2, 4, 6, 8};
    std::span<int> s(buf, 4);
    int sum = 0;
    for (int x : s) sum += x;
    std::cout << sum << "\n"; // 20
}

Spans somente para leitura

Um std::span<const int> concede acesso somente para leitura; use-o quando uma função não deve modificar os dados.

#include <iostream>
#include <span>
int main() {
    int buf[] = {1, 2, 3};
    std::span<const int> s(buf, 3);
    std::cout << s[2] << "\n"; // 3
}

Mutável por meio de um span

Um span não const pode alterar os elementos subjacentes, pois aponta para os dados reais.

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

Extensão dinâmica versus estática

Por padrão, um span tem tamanho dinâmico, mas você pode fixá-lo em tempo de compilação com std::span<int, 3> para obter verificações adicionais.

Sem alocação, barato de passar

Como todas as visões, um span é barato de copiar e passar por valor; ele transporta apenas um ponteiro e um comprimento.

Atenção ao tempo de vida

Um span só é válido enquanto sua origem existir e não for realocada. Não mantenha um span para um vector que posteriormente cresça.

Verificação rápida

Verifique sua compreensão de std::span.

Recapitulação

Você aprendeu os fundamentos de std::span:

Visão não proprietária sobre dados contíguos (array, vector ou buffer bruto).
Contém um ponteiro e um comprimento; não faz cópias nem aloca memória.
Spans const permitem apenas leitura; spans mutáveis alteram a origem.
São válidos apenas enquanto a origem existir.

Perguntas Frequentes

A aula “Noções básicas de std::span” é grátis?

Sim — o texto completo de “Noções básicas de std::span” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Noções básicas de std::span”?

Visualizações não proprietárias de dados contíguos Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Noções básicas de std::span”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C++ Academy