C++ Academy · Aula

Passando spans para funções

Escreva APIs flexíveis

Passando spans para funções é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 3 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 função, muitos contêineres

Uma função que recebe std::span aceita igualmente arrays, vectors e buffers brutos, sem precisar de modelos ou sobrecargas.

#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";
}

Não é necessário um parâmetro de tamanho

As APIs antigas no estilo de C passam um ponteiro e um tamanho separado. Um span reúne os dois, eliminando erros causados por comprimentos incompatíveis.

#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
}

span const para somente leitura

Use std::span<const T> para garantir que a função não modificará os dados de quem a chamou.

#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
}

span mutável para editar no local

Um span não const permite que uma função modifique diretamente os elementos de quem a chamou.

#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
}

Evita o inchaço de modelos

Sem span, talvez você criasse um modelo para cada tipo de contêiner, gerando muitas instanciações. Um span oferece uma única assinatura concreta que funciona diretamente.

Evita cópias

Passar um span nunca copia os elementos; apenas um ponteiro e um comprimento são enviados para a função.

#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
}

Spans vazios não são problema

Uma função deve lidar tranquilamente com um span vazio; size() é zero, e o laço baseado em intervalo simplesmente executa zero vezes.

#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
}

Passagem por valor

Spans são pequenos, portanto, passe-os por valor, não por referência. Copiar um ponteiro e um comprimento é praticamente gratuito.

Documente a intenção de const

Escolher span<const T> ou span<T> informa imediatamente a quem chama se os dados podem ser modificados.

Quem chama mantém a propriedade

Quem chama ainda é proprietário do contêiner; o span apenas o toma emprestado durante a chamada. A função não deve armazenar o span depois que a chamada terminar.

Um estilo moderno de API

Aceitar um span é a forma moderna e idiomática de escrever funções para dados contíguos: flexível, segura e sem cópias.

Verificação rápida

Verifique sua compreensão sobre a passagem de spans.

Recapitulação

Você aprendeu a passar spans para funções:

Uma única assinatura aceita arrays, vectors e buffers.
span<const T> para somente leitura; span<T> para editar no local.
Passá-los por valor não copia nada.
Quem chama mantém a propriedade; não armazene o span depois que a chamada terminar.

Perguntas Frequentes

A aula “Passando spans para funções” é grátis?

Sim — o texto completo de “Passando spans para funções” é 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 “Passando spans para funções”?

Escreva APIs flexíveis 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 3 de 4.

Quanto tempo leva a aula “Passando spans para funções”?

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