C++ Academy · Aula

Armadilhas e tempos de vida

Evite visualizações pendentes

Aula 3 de 413 etapas

Armadilhas e tempos de vida é 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.

As Visões Não São Proprietárias

Uma string_view apenas aponta para caracteres pertencentes a outro lugar. Se esse armazenamento desaparecer, a visão fica pendente; acessá-la resulta em comportamento indefinido.

Visão Pendente de um Temporário

Vincular uma visão a uma std::string temporária é perigoso: o temporário é destruído ao fim da instrução, deixando a visão apontando para memória liberada.

#include <string>
#include <string_view>
std::string make() { return "temp"; }
int main() {
    std::string_view sv = make(); // dangles immediately
    // using sv here is undefined behavior
    (void)sv;
}

Retornando uma Visão para uma Variável Local

Nunca retorne uma visão que aponte para dentro de uma string local; a variável local é destruída quando a função retorna.

#include <string>
#include <string_view>
std::string_view bad() {
    std::string local = "oops";
    return local; // local dies, view dangles
}
int main() { (void)bad(); }

Seguro: Visão de uma String Ativa

Uma visão é segura desde que a fonte sobreviva a ela. Aqui, a string permanece ativa durante toda a função.

#include <iostream>
#include <string>
#include <string_view>
int main() {
    std::string s = "alive";
    std::string_view sv = s;
    std::cout << sv << "\n"; // safe
}

Não Terminada em Nulo

Não há garantia de que os dados de uma visão terminem em \0. Passar sv.data() para uma função C que espera uma string C pode fazer a leitura ultrapassar o fim.

Use size(), Não strlen

Sempre use sv.size() para obter o comprimento, em vez de funções de strings C, pois uma visão pode ser uma fatia de uma área de memória maior.

#include <iostream>
#include <string_view>
int main() {
    std::string_view sv = std::string_view("hello world").substr(0, 5);
    std::cout << sv.size() << "\n"; // 5, not 11
}

Modificando a Fonte

Se a string subjacente for realocada, por exemplo, por push_back ao aumentar sua capacidade, as visões existentes para ela se tornarão inválidas.

Armazenando Visões em Membros

Tenha cuidado ao armazenar uma string_view como membro de uma classe; você precisa garantir que os dados referenciados sobrevivam ao objeto. Quando tiver dúvida, armazene uma std::string.

Parâmetros Geralmente São Seguros

Usar string_view como parâmetro de função é o caso seguro e idiomático: o argumento sobrevive à chamada.

#include <iostream>
#include <string_view>
size_t len(std::string_view sv) { return sv.size(); }
int main() {
    std::cout << len("temporary is fine here") << "\n";
}

Copie quando Precisar Persistir

Se precisar manter o texto além do tempo de vida da fonte, copie-o para uma std::string. A cópia é o preço da propriedade.

#include <string>
#include <string_view>
std::string keep(std::string_view sv) {
    return std::string(sv); // owns a copy
}
int main() { (void)keep("persist"); }

Regra Prática

Prefira string_view para parâmetros e variáveis locais de curta duração. Evite usá-la como tipo de retorno ou membro de longa duração, a menos que os dados tenham claramente um tempo de vida maior.

Verificação Rápida

Verifique sua compreensão dos tempos de vida das visões.

Responda na aula interativa

Recapitulação

Você aprendeu sobre armadilhas e tempos de vida das visões:

As visões não são proprietárias dos dados; a fonte precisa sobreviver à visão.
Evite visões para temporários e variáveis locais.
Não há garantia de que as visões terminem em nulo; use size().
Copie para uma std::string quando precisar preservar o texto.

Grátis para começar

Aprenda C++ com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Armadilhas e tempos de vida” é grátis?

Sim — o texto completo de “Armadilhas e tempos de vida” é 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 “Armadilhas e tempos de vida”?

Evite visualizações pendentes 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 “Armadilhas e tempos de vida”?

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