C++ Academy · Aula

Limites e subspans

Divida spans com segurança

Limites e subspans é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 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.

Fatiamento com subspan

s.subspan(offset, count) retorna um span sobre parte do original; não faz cópia, apenas cria um novo ponteiro e um novo comprimento.

#include <iostream>
#include <span>
int main() {
    int buf[] = {0, 1, 2, 3, 4};
    std::span<int> s(buf, 5);
    auto mid = s.subspan(1, 3);
    for (int x : mid) std::cout << x << " ";
    std::cout << "\n"; // 1 2 3
}

first e last

first(n) e last(n) fornecem spans sobre os n primeiros ou últimos elementos.

#include <iostream>
#include <span>
int main() {
    int buf[] = {10, 20, 30, 40};
    std::span<int> s(buf, 4);
    auto f = s.first(2);
    auto l = s.last(2);
    std::cout << f[0] << " " << l[1] << "\n"; // 10 40
}

Subspans compartilham a memória

Modificar um subspan altera os dados originais, pois ambos apontam para o mesmo buffer.

#include <iostream>
#include <span>
int main() {
    int buf[] = {1, 1, 1, 1};
    std::span<int> s(buf, 4);
    auto tail = s.last(2);
    tail[0] = 99;
    std::cout << buf[2] << "\n"; // 99
}

size_bytes

size_bytes() retorna o tamanho total, em bytes, dos elementos do span, o que é útil para operações de entrada e saída de baixo nível.

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

Os limites são sua responsabilidade

operator[] em um span não verifica os limites. Ler s[s.size()] resulta em comportamento indefinido.

Verifique antes de fatiar

Chamar subspan com um deslocamento ou uma contagem maior que o span resulta em comportamento indefinido; valide primeiro usando size().

#include <iostream>
#include <span>
int main() {
    int buf[] = {1, 2, 3};
    std::span<int> s(buf, 3);
    size_t off = 1, cnt = 2;
    if (off + cnt <= s.size()) {
        auto sub = s.subspan(off, cnt);
        std::cout << sub.size() << "\n";
    }
}

Vazio após o fatiamento

O fatiamento pode produzir um span vazio, por exemplo, first(0); trate-o como qualquer intervalo vazio.

#include <iostream>
#include <span>
int main() {
    int buf[] = {1, 2};
    std::span<int> s(buf, 2);
    auto e = s.first(0);
    std::cout << e.empty() << "\n"; // 1
}

Encadeando fatias

Subspans podem ser fatiados novamente, pois cada um é apenas outra visão do buffer original.

#include <iostream>
#include <span>
int main() {
    int buf[] = {0, 1, 2, 3, 4, 5};
    std::span<int> s(buf, 6);
    auto inner = s.subspan(1, 4).first(2);
    std::cout << inner[0] << " " << inner[1] << "\n"; // 1 2
}

Processamento em blocos

Um uso comum de subspan é percorrer um buffer grande em janelas de tamanho fixo para transmissão ou processamento em lotes.

#include <iostream>
#include <span>
int main() {
    int buf[] = {1, 2, 3, 4, 5, 6};
    std::span<int> s(buf, 6);
    for (size_t i = 0; i < s.size(); i += 2) {
        auto chunk = s.subspan(i, 2);
        std::cout << "[" << chunk[0] << "," << chunk[1] << "] ";
    }
    std::cout << "\n";
}

Verificações de extensão estática

Com um span de extensão estática, o compilador pode verificar alguns tamanhos de fatia em tempo de compilação, identificando erros mais cedo.

O tempo de vida ainda se aplica

Todo subspan compartilha o tempo de vida do buffer original. Se a origem for destruída ou realocada, todos os spans derivados se tornarão inválidos.

Verificação rápida

Verifique sua compreensão sobre subspans e limites.

Recapitulação

Você aprendeu sobre limites e subspans:

subspan, first e last criam fatias sem alocação.
Subspans compartilham a memória; as alterações afetam o original.
operator[] e o fatiamento não verificam os limites; valide primeiro.
Todos os subspans compartilham o tempo de vida da origem.

Perguntas Frequentes

A aula “Limites e subspans” é grátis?

Sim — o texto completo de “Limites e subspans” é 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 “Limites e subspans”?

Divida spans com segurança 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 4 de 4.

Quanto tempo leva a aula “Limites e subspans”?

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