C++ Academy · Aula

Algoritmos de strings

Pesquise e divida com eficiência

Algoritmos de strings é 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.

Pesquisando com find

find retorna o índice de uma substring ou npos se ela estiver ausente, trabalhando diretamente em uma visão sem fazer cópias.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "key=value";
    auto pos = sv.find('=');
    std::cout << pos << "\n"; // 3
}

Verificando npos

Sempre compare o resultado de uma pesquisa com std::string_view::npos antes de usá-lo como índice.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "abc";
    if (sv.find('z') == std::string_view::npos)
        std::cout << "not found\n";
}

Verificações de Prefixo e Sufixo

starts_with e ends_with (C++20) tornam a intenção evidente e evitam comparações manuais de substrings.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "report.pdf";
    std::cout << sv.starts_with("report") << "\n";
    std::cout << sv.ends_with(".pdf") << "\n";
}

Extraindo um Campo

Combine find com substr para separar um par chave/valor sem alocar novas strings.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "name=Ada";
    auto eq = sv.find('=');
    std::cout << sv.substr(0, eq) << " : " << sv.substr(eq + 1) << "\n";
}

Separando por um Delimitador

Você pode percorrer as partes encontrando repetidamente o delimitador e obtendo subvisões; cada parte é apenas uma visão.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "a,b,c";
    size_t start = 0, pos;
    while ((pos = sv.find(',', start)) != std::string_view::npos) {
        std::cout << sv.substr(start, pos - start) << "\n";
        start = pos + 1;
    }
    std::cout << sv.substr(start) << "\n";
}

Pesquisando a partir do Fim

rfind pesquisa de trás para frente, sendo útil para obter a extensão de um arquivo ou o último separador.

#include <iostream>
#include <string_view>
int main() {
    std::string_view path = "/usr/local/bin";
    auto slash = path.rfind('/');
    std::cout << path.substr(slash + 1) << "\n"; // bin
}

Removendo Espaços em Branco

Use find_first_not_of e find_last_not_of com remove_prefix/remove_suffix para remover espaços, tudo sem fazer cópias.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "  hi  ";
    sv.remove_prefix(sv.find_first_not_of(" "));
    sv.remove_suffix(sv.size() - 1 - sv.find_last_not_of(" "));
    std::cout << "[" << sv << "]\n"; // [hi]
}

Comparando Visões

As visões oferecem == e compare para comparação lexicográfica, comparando caracteres, não ponteiros.

#include <iostream>
#include <string_view>
int main() {
    std::string_view a = "apple", b = "apple";
    std::cout << (a == b) << "\n"; // 1
}

Contando Ocorrências

Um laço com find, avançando após cada ocorrência, conta quantas vezes um caractere ou substring aparece.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = "mississippi";
    int count = 0;
    for (size_t p = sv.find('s'); p != std::string_view::npos; p = sv.find('s', p + 1)) ++count;
    std::cout << count << "\n"; // 4
}

Os Algoritmos Permanecem sem Alocação

Todas essas operações trabalham na mesma área de memória subjacente. As partes e os resultados recortados são subvisões; nenhuma alocação de memória ocorre até que você crie uma std::string.

Atenção aos Tempos de Vida

As subvisões produzidas por esses algoritmos compartilham o tempo de vida da área de memória original. Não permita que elas sobrevivam à string de origem.

Verificação Rápida

Verifique sua compreensão dos algoritmos de string_view.

Recapitulação

Você aprendeu algoritmos de string em visões:

find/rfind retornam posições ou npos.
starts_with/ends_with verificam prefixos e sufixos.
Separar, remover espaços e dividir em partes produz subvisões sem alocação.
As subvisões compartilham o tempo de vida da fonte; tenha cuidado com referências pendentes.

Perguntas Frequentes

A aula “Algoritmos de strings” é grátis?

Sim — o texto completo de “Algoritmos de strings” é 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 “Algoritmos de strings”?

Pesquise e divida com eficiência 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 “Algoritmos de strings”?

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