C++ Academy · Lección

Algoritmos de cadenas

Busque y divida de forma eficiente

Algoritmos de cadenas es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 4 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.

Buscar con find

find devuelve el índice de una subcadena o npos si no está presente, y trabaja directamente sobre una vista sin copiarla.

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

Comprobar npos

Compare siempre el resultado de una búsqueda con std::string_view::npos antes de usarlo 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";
}

Comprobaciones de prefijo y sufijo

starts_with y ends_with (C++20) hacen evidente la intención y evitan comparar subcadenas manualmente.

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

Extraer un campo

Combine find con substr para dividir un par de clave y valor sin reservar memoria para nuevas cadenas.

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

Dividir por un delimitador

Puede recorrer los tokens buscando repetidamente el delimitador y tomando subvistas; cada token es solo una vista.

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

Buscar desde el final

rfind busca hacia atrás; resulta práctico para obtener una extensión de archivo o el ú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
}

Recortar espacios en blanco

Use find_first_not_of y find_last_not_of con remove_prefix/remove_suffix para recortar, todo sin copiar.

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

Comparar vistas

Las vistas admiten == y compare para la comparación lexicográfica: comparan caracteres, no punteros.

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

Contar apariciones

Un bucle con find que avance más allá de cada coincidencia permite contar cuántas veces aparece un carácter o una subcadena.

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

Los algoritmos no reservan memoria

Todas estas operaciones trabajan sobre el mismo búfer subyacente. Los tokens y los resultados recortados son subvistas; no se reserva memoria en el heap hasta construir un std::string.

Tenga presentes los tiempos de vida

Las subvistas producidas por estos algoritmos comparten el tiempo de vida del búfer original. No permita que sobrevivan a la cadena fuente.

Comprobación rápida

Compruebe su comprensión de los algoritmos de string_view.

Resumen

Ha aprendido algoritmos de cadenas sobre vistas:

find/rfind devuelven posiciones o npos.
starts_with/ends_with comprueban prefijos y sufijos.
Dividir, recortar y tokenizar produce subvistas sin reservar memoria.
Las subvistas comparten el tiempo de vida de la fuente; tenga cuidado con las vistas colgantes.

Preguntas frecuentes

¿La lección «Algoritmos de cadenas» es gratis?

Sí — el texto completo de «Algoritmos de cadenas» 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 «Algoritmos de cadenas»?

Busque y divida de forma eficiente 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 4 de 4.

¿Cuánto tiempo toma la lección «Algoritmos de cadenas»?

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