C++ Academy · Lección

Errores y tiempos de vida

Evite vistas colgantes

Lección 3 de 413 pasos

Errores y tiempos de vida es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.

Las vistas no son propietarias

Un string_view solo apunta a caracteres que pertenecen a otro objeto. Si ese almacenamiento desaparece, la vista queda colgante y acceder a ella produce un comportamiento indefinido.

Una vista colgante de un temporal

Vincular una vista a un std::string temporal es peligroso: el temporal desaparece al final de la instrucción y la vista queda apuntando a memoria 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;
}

No devuelva una vista a un objeto local

No devuelva nunca una vista que apunte al interior de una cadena local; el objeto local se destruye cuando la función 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: vista de una cadena existente

Una vista es segura siempre que la fuente dure más que ella. En este caso, la cadena existe durante toda la función.

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

No termina en nulo

No se garantiza que los datos de una vista terminen en un \0. Pasar sv.data() a una función de C que espere una cadena C puede hacer que lea más allá del final.

Use size(), no strlen

Confíe siempre en sv.size() para obtener la longitud en lugar de usar funciones de cadenas C, ya que una vista puede ser una sección de un búfer más grande.

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

Modificar la fuente

Si la cadena subyacente se realoca (por ejemplo, porque push_back aumenta su capacidad), las vistas existentes que apuntan a ella dejan de ser válidas.

Almacenar vistas como miembros

Tenga cuidado al almacenar un string_view como miembro de una clase; debe garantizar que los datos referenciados duren más que el objeto. Si tiene dudas, almacene un std::string.

Los parámetros suelen ser seguros

Usar string_view como parámetro de una función es el caso seguro e idiomático: el argumento dura más que la llamada.

#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 cuando deba conservar el texto

Si necesita conservar el texto más allá del tiempo de vida de su fuente, cópielo en un std::string. La copia es el precio de la propiedad.

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

Regla práctica

Prefiera string_view para parámetros y variables locales de corta duración. Evítelo como tipo de retorno o miembro de larga duración, salvo que los datos vayan a existir claramente durante más tiempo.

Comprobación rápida

Compruebe su comprensión de los tiempos de vida de las vistas.

Responde en la lección interactiva

Resumen

Ha aprendido sobre los problemas y tiempos de vida de las vistas:

Las vistas no son propietarias de los datos; la fuente debe durar más que la vista.
Evite las vistas de temporales y objetos locales.
No se garantiza que las vistas terminen en nulo; use size().
Copie el texto en un std::string cuando necesite conservarlo.

Gratis para empezar

Aprende C++ con un tutor de IA — gratis

Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.

Cursos: 51
Lecciones: 203

Empezar a aprender gratis Ver el curso completo

Preguntas frecuentes

¿La lección «Errores y tiempos de vida» es gratis?

Sí — el texto completo de «Errores y tiempos de vida» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Errores y tiempos de vida»?

Evite vistas colgantes Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C++ Academy?

No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Errores y tiempos de vida»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C++ Academy?

Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C++ Academy