Guía completa para extraer subcadenas en C | Funciones estándar, personalizadas y multibyte

1. Introducción

Lo que se puede aprender en este artículo

• Conceptos básicos de las cadenas en el lenguaje C y el rol del carácter de terminación ' '
• strncpy o strchr , como extracción de subcadenas usando funciones de la biblioteca estándar
• Métodos de implementación de manipulación de cadenas usando funciones personalizadas
• Procesamiento de cadenas UTF-8 o Shift_JIS considerando caracteres multibyte (japonés)
• strtok para métodos de división de cadenas
• Métodos para obtener el contenido antes y después de un carácter específico y ejemplos de aplicación

¿Por qué es importante la extracción de subcadenas en el lenguaje C?

1. Procesamiento de datos de entrada

2. Búsqueda de palabras clave específicas

3. Mejora de la seguridad del programa

Estructura de este artículo

1. ¿Qué son las cadenas en el lenguaje C? Importancia de los conceptos básicos y el carácter de terminación
2. Métodos para extraer subcadenas en el lenguaje C [Edición de biblioteca estándar]
3. Métodos para extraer subcadenas en el lenguaje C [Edición de funciones personalizadas]
4. Métodos de extracción de cadenas según la codificación de caracteres
5. Métodos para dividir cadenas en el lenguaje C
6. Ejemplo de aplicación: Métodos para extraer el contenido antes y después de un carácter específico
7. Resumen
8. FAQ

2. ¿Qué son las cadenas en C? Conceptos básicos e importancia del carácter de terminación

2.1 Conceptos básicos de las cadenas en C

Las cadenas son «arrays de char»

#include 

int main() {
    char str[] = "Hello, World!"; // Definir el literal de cadena como un array
    printf("%s\n", str); // Imprimir la cadena
    return 0;
}

Estructura interna de las cadenas

2.2 Importancia del carácter de terminación (carácter nulo '

¿Qué es el carácter nulo?

')

Problemas si no hay carácter nulo

#include 

int main() {
    char str[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; // Especificar explícitamente el carácter de terminación
    printf("%s\n", str); // Se muestra correctamente
    return 0;
}

2.3 Cómo definir correctamente las cadenas

#include 

int main() {
    char str[5] = {'H', 'e', 'l', 'l', 'o'}; // No incluye el carácter nulo
    printf("%s\n", str); // Puede ocurrir un comportamiento inesperado
    return 0;
}

• printf("%s", str); es continúa imprimiendo caracteres hasta encontrar el carácter nulo '\0'.
• Si no hay '\0', es posible que se imprima otro dato en la memoria.

Método 1: Usar literales de cadena

Método 2: Definir el array explícitamente

char str[] = "Hello";

2.4 Cómo verificar el tamaño de la cadena

char str[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

• Es importante especificar el tamaño de número de caracteres +1 e insertar '\0' al final.
• Si se olvida insertar str[5] en '\0', ocurrirá un comportamiento inesperado.

Funcionamiento de strlen

#include 
#include 

int main() {
    char str[] = "Hello";
    printf("Longitud de la cadena: %lu\n", strlen(str)); // Imprime 5 (sin incluir el carácter nulo)
    return 0;
}

2.5 Resumen

• strlen cuenta el número de caracteres hasta que aparece el carácter nulo '\0'.
• sizeof(str) a diferencia, obtiene no el tamaño del array sino «la longitud real de la cadena».

3. Cómo extraer subcadenas en lenguaje C [Edición de biblioteca estándar]

1. Las cadenas en C se representan con arrays de char.
2. Dado que el carácter de terminación (carácter nulo '\0') indica el final de la cadena, es necesario incluirlo siempre.
3. Para obtener la longitud de la cadena, se usa strlen.
4. Si no se define la cadena de manera adecuada, puede ocurrir un error inesperado.

3.1 Obtención de subcadenas utilizando strncpy

Sintaxis básica de strncpy

Ejemplo de uso básico

char *strncpy(char *dest, const char *src, size_t n);

• dest: Búfer de destino de la copia
• src: Cadena de origen de la copia
• n: Número máximo de caracteres a copiar (sin incluir el '\0')

Puntos de atención de strncpy

#include 
#include 

int main() {
    char src[] = "Hello, World!";
    char dest[6];  // Búfer para almacenar la subcadena

    strncpy(dest, src, 5); // Copiar los primeros 5 caracteres "Hello"
    dest[5] = '\0';  // Agregar el carácter nulo manualmente

    printf("Subcadena: %s\n", dest);  // Imprimir "Hello"

    return 0;
}

3.2 Copia de cadenas segura utilizando strncpy_s

1. Es necesario agregar manualmente el carácter nulo '\0'strncpy copia un máximo de n caracteres, perono agrega automáticamente el '\0', por lo que es necesario agregar explícitamente dest[n] = '\0';.
2. Prestar atención al desbordamiento de búferSi n es mayor que el tamaño de dest, existe la posibilidad de escribir más allá del búfer.

Sintaxis básica de strncpy_s

Ejemplo de uso

errno_t strncpy_s(char *dest, rsize_t destsz, const char *src, rsize_t n);

• dest: Búfer de destino de la copia
• destsz: Tamaño de dest
• src: Cadena de origen de la copia
• n: Número máximo de caracteres a copiar

Ventajas de strncpy_s

#include 
#include 

int main() {
    char src[] = "Hello, World!";
    char dest[6];

    if (strncpy_s(dest, sizeof(dest), src, 5) == 0) {
        dest[5] = '\0';  // Agregar el carácter nulo por si acaso
        printf("Subcadena: %s\n", dest);
    } else {
        printf("Error de copia\n");
    }

    return 0;
}

3.3 Extracción hasta un carácter específico utilizando strchr

• Al especificar el tamaño del búfer (destsz), se puede copiar de manera segura.
• Si n es mayor que destsz, devuelve un error.

Sintaxis básica de strchr

Ejemplo de uso

char *strchr(const char *str, int c);

• str: Cadena de búsqueda
• c: Carácter a buscar (tipo char)

Puntos clave

#include 
#include 

int main() {
    char str[] = "Hello, World!";
    char *pos = strchr(str, ','); // Buscar la posición de ','

    if (pos != NULL) {
        int length = pos - str; // Calcular el número de caracteres hasta ','
        char result[20];

        strncpy(result, str, length);
        result[length] = '\0'; // Agregar el carácter nulo

        printf("Subcadena: %s\n", result);  // Imprimir "Hello"
    }

    return 0;
}

3.4 Búsqueda de palabras clave y extracción utilizando strstr

• strchr devuelve la dirección del c encontrado primero, por lo que se puede usar para determinar el rango de la subcadena.
• Al calcular la longitud de la subcadena con pos - str y copiar con strncpy, se puede obtener la subcadena hasta un carácter específico.

Sintaxis básica de strstr

Ejemplo de uso

char *strstr(const char *haystack, const char *needle);

• haystack: Cadena de búsqueda
• needle: Subcadena a buscar

Puntos clave

#include 
#include 

int main() {
    char str[] = "Hello, World!";
    char *pos = strstr(str, "World"); // Buscar la posición de "World"

    if (pos != NULL) {
        printf("Subcadena encontrada: %s\n", pos);
    } else {
        printf("No se encontró la subcadena.\n");
    }

    return 0;
}

3.5 Resumen

• strstr devuelve el puntero del needle encontrado primero.
• Si se devuelve NULL, significa que needle no existe en haystack.

4. Cómo extraer subcadenas en C [Edición de funciones personalizadas]

1. Al usar strncpy, se puede copiar subcadenas de manera segura, pero es necesario agregar manualmente el carácter nulo.
2. strncpy_s permite especificar destsz, mejorando la seguridad.
3. Al usar strchr, se puede obtener la subcadena hasta un carácter específico.
4. Al usar strstr, se puede obtener la posición de una palabra clave específica y extraer a partir de allí.

4.1 Ventajas de crear funciones personalizadas

4.2 Función básica para extraer subcadenas

• strncpy no agrega automáticamente el carácter nulo '\0'
• strchr o strstr solo permiten búsquedas parciales
• Es difícil realizar operaciones de cadenas más flexibles

Especificaciones de la función

Código de implementación

• Argumentos
• const char *source (cadena original)
• int start (posición de inicio)
• int length (número de caracteres a extraer)
• char *dest (buffer para almacenar la subcadena extraída)
• Contenido del procesamiento
• start desde length caracteres de la cadena a dest copiar
• '\0' agregar automáticamente

Puntos clave

#include 
#include 

void substring(const char *source, int start, int length, char *dest) {
    int i;
    for (i = 0; i < length && source[start + i] != '\0'; i++) {
        dest[i] = source[start + i];
    }
    dest[i] = '\0'; // Agregar carácter nulo
}

int main() {
    char text[] = "Hello, World!";
    char result[10];

    substring(text, 7, 5, result); // Extraer "World"
    printf("Subcadena: %s\n", result);

    return 0;
}

4.3 Obtención dinámica de subcadenas usando malloc

• for bucle para copiar los length caracteres especificados.
• '\0' al llegar, terminar el bucle.
• dest[i] = '\0'; agregar para colocar siempre el carácter nulo al final.

Especificaciones de la función

Código de implementación

• Asegurar la memoria necesaria con malloc
• start desde length caracteres de subcadena a un nuevo buffer copiar
• El llamador debe free

Puntos clave

#include 
#include 
#include 

char *substring_dynamic(const char *source, int start, int length) {
    char *dest = (char *)malloc(length + 1); // +1 para el carácter nulo
    if (dest == NULL) {
        return NULL; // Fallo en la asignación de memoria
    }

    int i;
    for (i = 0; i < length && source[start + i] != '\0'; i++) {
        dest[i] = source[start + i];
    }
    dest[i] = '\0';

    return dest;
}

int main() {
    char text[] = "Hello, World!";
    char *result = substring_dynamic(text, 7, 5);

    if (result != NULL) {
        printf("Subcadena: %s\n", result);
        free(result); // Liberar memoria
    } else {
        printf("Fallo en la asignación de memoria.\n");
    }

    return 0;
}

4.4 Compatibilidad con caracteres multibyte (japonés)

• malloc para asignar memoria dinámicamente, por lo que no es necesario preocuparse por el tamaño del buffer.
• Después del uso, es necesario liberar la memoria con free(result);.

Implementación considerando caracteres multibyte

Código de implementación (compatible con UTF-8)

• mbstowcs usar para convertir cadena multibyte a cadena amplia (wchar_t)
• wcsncpy usar para obtener subcadena
• wcstombs para volver a cadena multibyte

Puntos clave

#include 
#include 
#include 
#include 
#include 

void substring_utf8(const char *source, int start, int length, char *dest) {
    setlocale(LC_ALL, ""); // Establecer localización

    wchar_t wsource[256];
    mbstowcs(wsource, source, 256); // Convertir cadena UTF-8 a cadena amplia

    wchar_t wresult[256];
    wcsncpy(wresult, wsource + start, length); // Extraer en cadena amplia
    wresult[length] = L'\0';

    wcstombs(dest, wresult, 256); // Volver a cadena multibyte
}

int main() {
    char text[] = "¡Hola, mundo!"; // Cadena UTF-8
    char result[20];

    substring_utf8(text, 5, 3, result); // Obtener "世界"
    printf("Subcadena: %s\n", result);

    return 0;
}

4.5 Resumen

• setlocale(LC_ALL, ""); para establecer localización y compatibilidad multibyte.
• mbstowcs para convertir cadena multibyte a cadena amplia.
• wcsncpy para obtener subcadena, luego wcstombs para volver a multibyte.

5. Método de extracción de subcadenas por código de caracteres

1. Si se crea substring uno mismo, se puede obtener subcadenas de manera flexible.
2. Usar asignación de memoria dinámica (malloc) permite obtener subcadenas de tamaño variable.
3. Para manejar caracteres multibyte (japonés), utilizar mbstowcs / wcstombs.

5.1 Caso de ASCII (caracteres de 1 byte)

Obtención básica de subcadena

Ejemplo de implementación

5.2 Caso de UTF-8 (caracteres multibyte)

#include 
#include 

void substring_ascii(const char *source, int start, int length, char *dest) {
    strncpy(dest, source + start, length);
    dest[length] = ' '; // Agregar el carácter nulo
}

int main() {
    char text[] = "Hello, World!";
    char result[6];

    substring_ascii(text, 7, 5, result); // Obtener "World"
    printf("Subcadena: %s\n", result);

    return 0;
}

• En el caso de caracteres ASCII (solo alfanuméricos), strncpy es suficiente
• ' ' (carácter nulo) debe agregarse siempre

Características de UTF-8

Método de procesamiento correcto

Obtención de subcadena compatible con UTF-8

5.3 Caso de Shift_JIS (caracteres multibyte)

#include 
#include 
#include 
#include 

void substring_utf8(const char *source, int start, int length, char *dest) {
    setlocale(LC_ALL, ""); // Configurar el locale

    wchar_t wsource[256];
    mbstowcs(wsource, source, 256); // Convertir la cadena multibyte a cadena ancha

    wchar_t wresult[256];
    wcsncpy(wresult, wsource + start, length); // Obtener la subcadena
    wresult[length] = L' ';

    wcstombs(dest, wresult, 256); // Convertir de nuevo la cadena ancha a multibyte
}

int main() {
    char text[] = "¡Hola, mundo!"; // Cadena UTF-8
    char result[20];

    substring_utf8(text, 5, 3, result); // Obtener "mundo"
    printf("Subcadena: %s\n", result);

    return 0;
}

• setlocale(LC_ALL, ""); Sin configurar el locale, los caracteres multibyte no se procesan correctamente.
• mbstowcs convierte la cadena multibyte a wchar_t y wcsncpy procesa de manera segura.
• wcstombs vuelve a convertir a cadena multibyte.

Características de Shift_JIS

Obtención de subcadena compatible con Shift_JIS

Implementación en Shift_JIS

5.4 Caso de EUC-JP (caracteres multibyte)

#include 
#include 
#include 
#include 

void substring_sjis(const char *source, int start, int length, char *dest) {
    setlocale(LC_ALL, "Japanese"); // Configurar el locale para procesar Shift_JIS

    wchar_t wsource[256];
    mbstowcs(wsource, source, 256);

    wchar_t wresult[256];
    wcsncpy(wresult, wsource + start, length);
    wresult[length] = L' ';

    wcstombs(dest, wresult, 256);
}

int main() {
    char text[] = "¡Hola, mundo!"; // Cadena Shift_JIS (depende del entorno)
    char result[20];

    substring_sjis(text, 5, 3, result);
    printf("Subcadena: %s\n", result);

    return 0;
}

• Para procesar Shift_JIS correctamente, configurar setlocale(LC_ALL, "Japanese"); .
• mbstowcs y wcstombs se usan para procesar la cadena de manera segura.

Características de EUC-JP

Obtención de subcadena compatible con EUC-JP

5.5 Resumen

#include 
#include 
#include 
#include 

void substring_eucjp(const char *source, int start, int length, char *dest) {
    setlocale(LC_ALL, "ja_JP.eucJP"); // Configurar el locale para procesar EUC-JP

    wchar_t wsource[256];
    mbstowcs(wsource, source, 256);

    wchar_t wresult[256];
    wcsncpy(wresult, wsource + start, length);
    wresult[length] = L' ';

    wcstombs(dest, wresult, 256);
}

int main() {
    char text[] = "¡Hola, mundo!"; // Cadena EUC-JP (depende del entorno)
    char result[20];

    substring_eucjp(text, 5, 3, result);
    printf("Subcadena: %s\n", result);

    return 0;
}

• setlocale(LC_ALL, "ja_JP.eucJP"); configura el locale para EUC-JP.
• mbstowcs / wcstombs se usan para procesar correctamente los caracteres multibyte.

6. Cómo dividir cadenas en C

• Si solo caracteres ASCII, strncpy está bien
• En los casos de UTF-8, Shift_JIS, EUC-JP, usar mbstowcs / wcstombs
• Configurar setlocale(LC_ALL, "..."); de manera adecuada según el entorno

6.1 División de cadenas usando strtok

Sintaxis básica

Ejemplo de uso: Dividir cadena con coma ,

char *strtok(char *str, const char *delim);

• str: Cadena objetivo de división (especificada en la primera llamada)
• delim: Delimitador (se pueden especificar varios)
• Valor de retorno: El primer token (la primera parte dividida)
• Notas: strtok modifica la cadena original (cambia el delimitador a '\0')

Resultado de ejecución

#include 
#include 

int main() {
    char str[] = "apple,banana,orange,grape"; // Cadena a dividir
    char *token = strtok(str, ","); // Obtener el primer token

    while (token != NULL) {
        printf("Token: %s\n", token);
        token = strtok(NULL, ","); // Obtener el siguiente token
    }

    return 0;
}

Notas sobre strtok

Token: apple
Token: banana
Token: orange
Token: grape

6.2 División de cadenas segura para hilos usando strtok_r

1. Modifica la cadena original

• strtok sobrescribe el delimitador con ‘\0’, por lo que se pierde la cadena original.

1. No es seguro para hilos

• strtok usa una variable estática global internamente, por lo que no es recomendable usarla en entornos multihilo.

Sintaxis básica

Ejemplo de uso: Dividir cadena con espacio

char *strtok_r(char *str, const char *delim, char **saveptr);

• str: Cadena objetivo de división (especificada en la primera llamada)
• delim: Delimitador (se pueden especificar varios)
• saveptr: Puntero que mantiene el estado interno (se actualiza en cada llamada)

Ventajas de strtok_r

#include 
#include 

int main() {
    char str[] = "Hello World from C"; // Cadena a dividir
    char *token;
    char *saveptr; // Puntero para guardar el estado interno

    token = strtok_r(str, " ", &saveptr); // Obtener el primer token
    while (token != NULL) {
        printf("Token: %s\n", token);
        token = strtok_r(NULL, " ", &saveptr); // Obtener el siguiente token
    }

    return 0;
}

6.3 Dividir cadenas con una función personalizada (sin usar strtok)

• Seguro para hilos
• Permite procesar múltiples cadenas en paralelo

Especificaciones de la función personalizada

Código de implementación

• Entrada
• const char *source (cadena original)
• const char delim (delimitador)
• char tokens[][50] (arreglo para almacenar las cadenas divididas)
• Procesamiento
• source se copia para no modificar el original
• delim se usa para almacenar los resultados divididos en tokens

Resultado de ejecución

#include 
#include 

void split_string(const char *source, char delim, char tokens[][50], int *count) {
    int i = 0, j = 0, token_index = 0;

    while (source[i] != '\0') {
        if (source[i] == delim) {
            tokens[token_index][j] = '\0';
            token_index++;
            j = 0;
        } else {
            tokens[token_index][j] = source[i];
            j++;
        }
        i++;
    }
    tokens[token_index][j] = '\0';
    *count = token_index + 1;
}

int main() {
    char text[] = "dog,cat,bird,fish";
    char tokens[10][50]; // Puede almacenar hasta 10 palabras
    int count;

    split_string(text, ',', tokens, &count);

    for (int i = 0; i < count; i++) {
        printf("Token: %s\n", tokens[i]);
    }

    return 0;
}

Puntos clave

Token: dog
Token: cat
Token: bird
Token: fish

6.4 Aplicaciones de la división de cadenas (procesamiento de datos CSV)

• source se copia y se procesa sin modificar el original.
• tokens almacena los resultados divididos y mantiene la cadena original.

Ejemplo de análisis de datos CSV

Resultado de ejecución

#include 
#include 

int main() {
    char csv[] = "Alice,24,Female\nBob,30,Male\nCharlie,28,Male"; // Datos CSV
    char *line = strtok(csv, "\n"); // Procesar línea por línea

    while (line != NULL) {
        char *name = strtok(line, ",");
        char *age = strtok(NULL, ",");
        char *gender = strtok(NULL, ",");

        printf("Nombre: %s, Edad: %s, Género: %s\n", name, age, gender);

        line = strtok(NULL, "\n");
    }

    return 0;
}

6.5 Resumen

Nombre: Alice, Edad: 24, Género: Female
Nombre: Bob, Edad: 30, Género: Male
Nombre: Charlie, Edad: 28, Género: Male

Conclusión

7. Ejemplo de aplicación: Cómo extraer antes y después de un carácter específico

• Para divisiones simples, usa strtok
• Para multihilo, usa strtok_r
• Si no quieres modificar el original, usa una función personalizada
• También se puede aplicar al análisis de datos CSV

7.1 Usar strchr para obtener la cadena antes de un carácter específico

• Obtener solo la parte de dominio de una URL
• Extraer el nombre de archivo de una ruta de archivo
• Obtener la cadena antes y después de una etiqueta o símbolo específico

Sintaxis básica

Ejemplo de uso: Obtener el nombre de archivo de una ruta de archivo

char *strchr(const char *str, int c);

• str: Cadena de búsqueda
• c: Carácter a buscar (tipo char )

Resultado de ejecución

#include 
#include 

void get_filename(const char *path, char *filename) {
    char *pos = strrchr(path, '/'); // Buscar la última '/'
    
    if (pos != NULL) {
        strcpy(filename, pos + 1); // Copiar desde la posición siguiente a '/'
    } else {
        strcpy(filename, path); // Si no hay '/', copiar tal como está
    }
}

int main() {
    char path[] = "/home/user/documents/report.txt";
    char filename[50];
    
    get_filename(path, filename);
    printf("Nombre del archivo: %s\n", filename);
    
    return 0;
}

Puntos clave

Nombre del archivo: report.txt

7.2 Usar strstr para obtener la cadena después de una palabra clave específica

• strrchr permite obtener la posición del carácter específico (/ ) que aparece por última vez.
• pos + 1 copia la cadena siguiente a la barra diagonal, lo que permite obtener solo el nombre del archivo.

Sintaxis básica

Ejemplo de uso: Obtener el dominio de una URL

char *strstr(const char *haystack, const char *needle);

• haystack: Cadena de búsqueda
• needle: Subcadena a buscar

Resultado de ejecución

#include 
#include 

void get_domain(const char *url, char *domain) {
    char *pos = strstr(url, "://"); // Buscar la posición de "://"
    
    if (pos != NULL) {
        strcpy(domain, pos + 3); // Copiar desde después de "://"
    } else {
        strcpy(domain, url); // Si no hay "://", copiar tal como está
    }
}

int main() {
    char url[] = "https://www.example.com/page.html";
    char domain[50];
    
    get_domain(url, domain);
    printf("Parte de dominio: %s\n", domain);
    
    return 0;
}

Puntos clave

Parte de dominio: www.example.com/page.html

7.3 Usar strchr para dividir las partes antes y después de un carácter específico

• strstr se usa para obtener desde "https://" o "http://" la parte posterior a "//" .
• pos + 3 copia desde después de :// .

Ejemplo de uso: Separar nombre de usuario y dominio de una dirección de correo electrónico

Resultado de ejecución

#include 
#include 

void split_email(const char *email, char *username, char *domain) {
    char *pos = strchr(email, '@'); // Buscar la posición de '@'
    
    if (pos != NULL) {
        strncpy(username, email, pos - email); // Copiar antes de '@'
        username[pos - email] = '\0'; // Agregar carácter nulo
        strcpy(domain, pos + 1); // Copiar la parte después de '@'
    }
}

int main() {
    char email[] = "user@example.com";
    char username[50], domain[50];
    
    split_email(email, username, domain);
    printf("Nombre de usuario: %s\n", username);
    printf("Dominio: %s\n", domain);
    
    return 0;
}

Puntos clave

Nombre de usuario: user
Dominio: example.com

7.4 Aplicación: Extraer un atributo específico dentro de una etiqueta HTML

• strchr busca la posición de '@' .
• strncpy copia la parte antes de '@' y agrega el carácter nulo.
• strcpy copia la parte después de '@' .

Ejemplo de uso: Obtener la URL de <a href="URL">

Resultado de ejecución

#include 
#include 

void get_href(const char *html, char *url) {
    char *start = strstr(html, "href=\""); // Buscar la posición de href="
    if (start != NULL) {
        start += 6; // Mover después de href="
        char *end = strchr(start, '"'); // Buscar la siguiente "
        if (end != NULL) {
            strncpy(url, start, end - start);
            url[end - start] = '\0'; // Agregar carácter nulo
        }
    }
}

int main() {
    char html[] = "Click Here";
    char url[100];
    
    get_href(html, url);
    printf("URL extraída: %s\n", url);
    
    return 0;
}

Puntos clave

URL extraída: https://example.com

7.5 Resumen

• strstr busca la posición de "href="" y se mueve 6 caracteres.
• strchr busca la posición de " (comilla) y determina el rango.

Conclusión

8. Resumen

• Explotando strchr o strstr , se puede obtener fácilmente antes y después de un carácter o palabra clave específico.
• Útil en muchos escenarios, como procesamiento de rutas de archivos, análisis de URL y división de direcciones de correo electrónico.
• Aplicable también a procesamientos avanzados como web scraping.

8.1 Repaso del artículo

8.2 Métodos óptimos según el uso

1. Extracción de subcadenas

2. División de cadenas

3. Obtención antes y después de un carácter específico

8.3 Precauciones en el procesamiento de cadenas en C

1. Gestionar exhaustivamente el terminador nulo '

Ejemplo de copia de cadena segura

'

2. Prestar atención a desbordamientos de búfer

3. Para el procesamiento de caracteres multibyte, usar mbstowcs

#include 
#include 

int main() {
    char src[] = "Hello, World!";
    char dest[6];

    strncpy(dest, src, 5);
    dest[5] = '\0'; // Agregar terminador nulo por seguridad

    printf("Subcadena: %s\n", dest);

    return 0;
}

4. Gestión del tamaño del búfer

#include 
#include 

int main() {
    char src[] = "Hello, World!";
    char dest[6];

    strncpy(dest, src, sizeof(dest) - 1);
    dest[5] = '\0'; // Agregar explícitamente el carácter nulo

    printf("Subcadena: %s\n", dest);
    return 0;
}

8.4 Hacia un aprendizaje más profundo

#include 
#include 
#include 

int main() {
    setlocale(LC_ALL, ""); // Establecer la localización

    char text[] = "¡Hola, mundo!"; // UTF-8
    wchar_t wtext[256];

    mbstowcs(wtext, text, 256); // Convertir a cadena amplia

    printf("Cadena amplia después de la conversión: %ls\n", wtext);

    return 0;
}

Temas para profundizar el aprendizaje

8.5 Resumen

Temas para profundizar el aprendizaje

1. Expresiones regulares (regex) (posible con bibliotecas externas de C)
2. Operaciones de archivos (procesamiento de cadenas con fgets, fscanf)
3. Gestión de memoria (procesamiento dinámico de cadenas con malloc, realloc)
4. Análisis de datos (métodos de análisis de JSON, XML)

8.5 Resumen

1. Las cadenas en C se gestionan con arrays de char, por lo que el manejo del carácter de terminación '\0' es importante
2. Para extraer subcadenas, usar strncpy, substring(), malloc
3. Para dividir cadenas, aprovechar strtok / strtok_r / funciones personalizadas
4. Para obtener antes y después de un carácter específico, aprovechar strchr, strstr
5. Para manejar caracteres multibyte (japonés), utilizar mbstowcs
6. Tener en cuenta un procesamiento seguro de cadenas y prestar atención a desbordamientos de búfer