Procesamiento de texto eficiente con std::string_view

Un std::string_view [C++17] es un objeto ligero que representa una secuencia contigua de caracteres sin poseer la memoria que los contiene. Internamente, es simplemente un puntero (const char*) y un tamaño (size_t). A diferencia de std::string, que gestiona su propio búfer y puede realizar asignaciones en el heap, una view es solo una “ventana” sobre datos que ya existen en memoria.

Esta abstracción funciona mediante la manipulación de punteros; cuando pides un substr() en una view, no se copia la cadena, sino que se crea una nueva view con un puntero desplazado y un tamaño reducido, una operación con complejidad $O(1)$. Es ideal para parsing de protocolos, procesamiento de archivos de configuración o cualquier algoritmo que solo necesite lectura (read-only). Sin embargo, debes tener cuidado: si el objeto dueño de la cadena original (el std::string o el array de caracteres) desaparece, la view queda apuntando a memoria invalidada, resultando en comportamiento indefinido (dangling view).

Para usarlo correctamente, evita el uso de std::regex para tareas simples de búsqueda o división. Aunque std::regex es potente, su implementación estándar suele ser lenta porque compila el estado de la máquina de estados en tiempo de ejecución y carece de optimizaciones JIT modernas. En su lugar, utiliza métodos de búsqueda manual con find() o las nuevas utilidades de inspección de C++20.

#include <iostream>
#include <string>
#include <string_view>
#include <vector>
#include <regex>

// Split eficiente: no realiza copias, solo manipula punteros.
std::vector<std::string_view> split_view(std::string_view sv, std::string_view delim) {
    std::vector<std::string_view> tokens;
    size_t start = 0;
    size_t end = sv.find(delim);

    while (end != std::string_view::npos) {
        // substr() en string_view es O(1)
        tokens.push_back(sv.substr(start, end - start));
        start = end + delim.size();
        end = sv.find(delim, start);
    }

    // Añadir el último fragmento restante
    if (start < sv.size()) {
        tokens.push_back(sv.substr(start));
    }
    return tokens;
}

int main() {
    // El string original es el dueño de la memoria.
    const std::string data = "sensor_id:42;temp:23.5;status:ok";

    // Conversión implícita: std::string -> std::string_view (seguro y barato).
    std::string_view sv = data;

    // C++20: Métodos de inspección rápida.
    if (sv.starts_with("sensor")) {
        std::cout << "Datos de sensor detectados.\n";
    }

    // Parsing sin copias
    auto parts = split_view(sv, ";");

    for (std::string_view part : parts) {
        if (part.contains(':')) { // C++23: contains() para string_view
            size_t colon_pos = part.find(':');
            std::string_view key = part.substr(0, colon_pos);
            std::string_view value = part.substr(colon_pos + 1);

            std::cout << "Clave: " << key << " | Valor: " << value << "\n";
            
            // Conversión explícita: string_view -> std::string (requiere copia/asignación).
            std::string key_std{key}; 
            if (key_std == "temp") {
                std::cout << "  -> Procesando temperatura...\n";
            }
        }
    }

    // Comparativa conceptual: std::regex (lento) vs string_view (rápido)
    // std::regex reg("temp:([0-9.]+)"); // Requiere construcción de máquina de estados en runtime.
    // std::smatch match;
    // std::regex_search(data, match, reg); 

    return 0;
}

Análisis detallado

En la función split_view, el bucle utiliza sv.find(delim). El valor devuelto es de tipo size_t. Cuando no se encuentra el delimitador, se retorna std::string_view::npos, que es una constante que equivale al valor máximo de size_t (típicamente size_t(-1)). Esto permite usar la misma variable para indexar y para la condición de salida.

La llamada sv.substr(start, end - start) es la clave de la eficiencia. A diferencia de std::string::substr, que reserva memoria en el heap para devolver una nueva cadena, la versión de std::string_view solo ajusta el puntero base y el contador de longitud. Por eso, el std::vector<std::string_view> contiene múltiples “ventanas” apuntando a distintas partes del mismo búfer original data.

En el main, observa la distinción de tipos. La asignación std::string_view sv = data; es una conversión implícita permitida para evitar fricciones al pasar strings a funciones que esperan views. Sin embargo, para el caso contrario, std::string key_std{key}; es una conversión explícita. Esto es un diseño deliberado del estándar para evitar que el programador cree accidentalmente objetos en el heap (y por tanto, penalizaciones de rendimiento) sin ser consciente de ello.

El error frecuente

El error más crítico con std::string_view es el dangling view causado por la gestión de vida de los objetos temporales.

// ERROR CRÍTICO: Retorna una vista a un objeto que va a morir.
std::string_view get_bad_view() {
    std::string s = "datos_temporales";
    return std::string_view(s); // 's' se destruye al salir de la función.
}

// Uso posterior:
std::string_view view = get_bad_view();
std::cout << view << std::endl; // ERROR: Acceso a memoria liberada (Undefined Behavior).

Este error no suele ser detectado por el compilador en fases de compilación estándar. Sin embargo, herramientas como AddressSanitizer (-fsanitize=address) lo detectarán inmediatamente al ejecutar el programa, reportando un error de stack-use-after-scope. Si necesitas devolver una cadena desde una función que no sea un parámetro de entrada, debes devolver un std::string para transferir la propiedad de la memoria.

N° 140