Funciones de Caracteres y Manipulación de Cadenas en C

Funciones para Caracteres ============================

El lenguaje C proporciona un conjunto de funciones muy útiles para trabajar con caracteres individuales. Estas funciones, en su mayoría, se encuentran en el archivo de cabecera <ctype.h>.

1.1. Funciones de Clasificación de Caracteres

Estas funciones permiten determinar la categoría de un carácter (si es una letra, un dígito, un espacio, una mayúscula, una minúscula, etc.). Todas requieren incluir <ctype.h> y toman un entero (que se interpreta como un carácter) como argumento, devolviendo un valor distinto de cero si la condición es verdadera y cero si es falsa.

Ejemplo de uso de islower:

#include <stdio.h>
#include <ctype.h> // Para islower

int main() {
    char caracter_test = 'a';
    int es_minuscula = islower(caracter_test); // Devuelve distinto de 0 si es minúscula

    if (es_minuscula) {
        printf("'%c' es una letra minúscula.\n", caracter_test);
    } else {
        printf("'%c' NO es una letra minúscula.\n", caracter_test);
    }
    return 0;
}

Ejemplo: Convertir toda una cadena a mayúsculas

Podemos aplicar estas funciones en bucles para procesar cadenas completas. El siguiente ejemplo transforma todas las letras minúsculas de una cadena a mayúsculas utilizando islower y toupper.

#include <stdio.h>
#include <ctype.h>   // Para islower y toupper
#include <string.h>  // Para strlen

int main() {
    char mensaje_original[] = "Hola Mundo de C!";
    size_t indice; // Usamos size_t para el índice del bucle

    printf("Cadena original: %s\n", mensaje_original);

    for (indice = 0; indice < strlen(mensaje_original); indice++) {
        if (islower(mensaje_original[indice])) { // Si el carácter es minúscula
            mensaje_original[indice] = toupper(mensaje_original[indice]); // Convertirlo a mayúscula
        }
    }

    printf("Cadena en mayúsculas: %s\n", mensaje_original);
    return 0;
}

1.2. Funciones de Conversión de Caracteres

Estas dos funciones se utilizan para cambiar el caso de un carácter. También se encuentran en <ctype.h>.

int tolower(int c);: Convierte un carácter a minúscula si es una letra mayúscula.
int toupper(int c);: Convierte un carácter a mayúscula si es una letra minúscula.

Demostración sencilla:

#include <stdio.h>
#include <ctype.h> // Para tolower y toupper

int main() {
    char letra_mayus = 'B';
    char letra_minus = 'z';

    printf("'%c' a minúscula: %c\n", letra_mayus, tolower(letra_mayus));
    printf("'%c' a mayúscula: %c\n", letra_minus, toupper(letra_minus));
    return 0;
}

1.3. Funciones de Entrada/Salida de Caracteres: `getchar` y `putchar`

Las funciones getchar() y putchar(), parte de <stdio.h>, permiten leer y escribir caracteres individualmente.

int getchar(void);: Lee el siguiente carácter del flujo de entrada estándar (normalmente el teclado). Devuelve el carácter leído o EOF si hay un error o fin de archivo.
int putchar(int c);: Escribe el carácter c en el flujo de salida estándar (normalmente la pantalla). Devuelve el carácter escrito o EOF si hay un error.

Ejemplo básico:

#include <stdio.h>

int main() {
    char mi_caracter_ingresado;
    printf("Ingrese un carácter y presione Enter: ");
    mi_caracter_ingresado = getchar(); // Captura el primer carácter
    printf("Usted ingresó: ");
    putchar(mi_caracter_ingresado);   // Imprime el carácter
    putchar('\n');                  // Imprime un salto de línea
    return 0;
}

Consideración importante con `getchar()` y `scanf()`

getchar() es muy útil para consumir caracteres pendientes en el búfer de entrada, como el salto de línea ('\n') que queda después de usar scanf() para leer otros tipos de datos. Si no se maneja, este '\n' puede ser leído por una llamada posterior a getchar(), causando un comportamiento inesperado.

#include <stdio.h>

int main() {
    char nombre_completo[50];
    char inicial_profesion;

    printf("Por favor, ingrese su nombre (sin espacios): ");
    scanf("%s", nombre_completo); // Por ejemplo, 'Ana' seguido de Enter.
                                 // El '\n' queda en el búfer.

    // getchar() a continuación leería el '\n' pendiente,
    // en lugar de esperar una nueva entrada del usuario.
    // Para evitarlo, limpiamos el búfer:
    while (getchar() != '\n' && getchar() != EOF); // Consumir todos los caracteres hasta '\n'

    printf("Ingrese la inicial de su profesión (e.g., I para Ingeniero): ");
    inicial_profesion = getchar(); // Ahora espera una entrada real del usuario

    printf("Nombre: %s\n", nombre_completo);
    printf("Profesión (inicial): %c\n", inicial_profesion);

    return 0;
}

Sin la línea while (getchar() != '\n' && getchar() != EOF);, la segunda llamada a getchar() habría leído directamente el '\n' del búfer, lo que resultaría en una asignación incorrecta a inicial_profesion sin que el usuario tenga oportunidad de ingresar un carácter.

Funciones para Cadenas de Caracteres =======================================

Las funciones de cadena de caracteres, declaradas en <string.h>, simplifican enormemente la manipulación de textos en C. Todas las funciones de cadena en C esperan que las cadenas estén terminadas en nulo (es decir, el último carácter sea '\0').

2.1. `strlen`: Calcular la Longitud de una Cadena

size_t strlen(const char* str);

Propósito: Calcula la longitud de la cadena de caracteres apuntada por str, excluyendo el carácter nulo de terminación ('\0').

Parámetros: str — Puntero constante a la cadena cuya longitud se desea calcular.

Valor de Retorno: La longitud de la cadena como un valor de tipo size_t (un tipo entero sin signo).

#include <stdio.h>
#include <string.h> // Para strlen

int main() {
    char mi_frase[] = "Desarrollo de Software";
    size_t longitud_frase = strlen(mi_frase);
    printf("La frase '%s' tiene una longitud de %zu caracteres.\n", mi_frase, longitud_frase); // %zu para size_t
    return 0;
}

Notas importantes:

La cadena debe estar terminada en '\0' para que strlen funcione correctamente.
El tipo size_t es sin signo; tenga cuidado al realizar operaciones aritméticas o comparaciones con tipos con signo.
El puntero str no debe ser NULL, ya que esto podría causar un fallo del programa.

Implementación de `strlen` (Simulaciones)

Método 1: Usando un contador

#include <stdio.h>

size_t obtener_longitud_contador(const char* s) {
    size_t cuenta_caracteres = 0;
    while (*s != '\0') {
        cuenta_caracteres++;
        s++; // Avanza al siguiente carácter
    }
    return cuenta_caracteres;
}

int main() {
    char texto_ej[] = "Simulacion C";
    printf("Longitud (contador): %zu\n", obtener_longitud_contador(texto_ej));
    return 0;
}

Método 2: Aritmética de punteros

#include <stdio.h>

size_t obtener_longitud_punteros(const char* s) {
    const char* puntero_inicial = s; // Guarda el puntero de inicio
    while (*s != '\0') {
        s++; // Avanza el puntero hasta el final de la cadena
    }
    return (size_t)(s - puntero_inicial); // La diferencia es la longitud
}

int main() {
    char texto_ej[] = "Aritmetica Punteros";
    printf("Longitud (punteros): %zu\n", obtener_longitud_punteros(texto_ej));
    return 0;
}

Método 3: Recursivo

#include <stdio.h>

size_t obtener_longitud_recursiva(const char* s) {
    if (*s == '\0') { // Condición base: si llegamos al nulo, la longitud es 0
        return 0;
    }
    return 1 + obtener_longitud_recursiva(s + 1); // Suma 1 y llama recursivamente para el resto de la cadena
}

int main() {
    char texto_ej[] = "Funcion Recursiva";
    printf("Longitud (recursiva): %zu\n", obtener_longitud_recursiva(texto_ej));
    return 0;
}

2.2. `strcpy`: Copiar una Cadena

char* strcpy(char* destination, const char* source);

Propósito: Copia la cadena apuntada por source (incluyendo el carácter nulo de terminación) al buffer apuntado por destination.

Parámetros:

destination — Puntero al array de caracteres donde se copiará el contenido.
source — Puntero constante a la cadena de caracteres fuente.

Valor de Retorno: Un puntero a la cadena de destino (destination).

#include <stdio.h>
#include <string.h> // Para strcpy

int main() {
    char cadena_origen[] = "Hola, copia exitosa!";
    char cadena_destino[50]; // Asegurar que tenga suficiente espacio

    strcpy(cadena_destino, cadena_origen);
    printf("Cadena copiada: %s\n", cadena_destino);
    return 0;
}

Notas importantes:

El buffer de destino (destination) debe tener suficiente espacio para contener la cadena fuente, incluido el carácter nulo, de lo contrario, se producirá un desbordamiento del búfer.
Ambas cadenas (destination y source) deben estar terminadas en '\0'.
No se garantiza que source y destination puedan solaparse (es decir, ser la misma cadena o tener memoria compartida). Si hay solapamiento, use memmove.

Implementación de `strcpy` (Simulación)

#include <stdio.h>

char* mi_strcpy(char* dest_buffer, const char* src_buffer) {
    char* inicio_destino = dest_buffer;
    while ((*dest_buffer++ = *src_buffer++) != '\0'); // Copia carácter a carácter, incluyendo '\0'
    return inicio_destino;
}

int main() {
    char frase_original[] = "Un texto para copiar.";
    char buffer_almacenamiento[100];
    mi_strcpy(buffer_almacenamiento, frase_original);
    printf("Copia personalizada: %s\n", buffer_almacenamiento);
    return 0;
}

2.3. `strcat`: Concatenar Cadenas

char* strcat(char* destination, const char* source);

Propósito: Añade una copia de la cadena source al final de la cadena destination. El carácter nulo de terminación de destination se sobrescribe y un nuevo carácter nulo se añade al final de la cadena resultante.

Parámetros:

destination — Puntero al array de caracteres donde se añadirá el contenido. Debe ser lo suficientemente grande para contener la cadena concatenada.
source — Puntero constante a la cadena de caracteres fuente a añadir.

Valor de Retorno: Un puntero a la cadena de destino (destination).

#include <stdio.h>
#include <string.h> // Para strcat

int main() {
    char primera_parte[50] = "Programación "; // Suficiente espacio para la concatenación
    char segunda_parte[] = "en C es genial!";
    strcat(primera_parte, segunda_parte);
    printf("Cadena final: %s\n", primera_parte);
    return 0;
}

Notas importantes:

El buffer de destino (destination) debe tener suficiente espacio para contener la cadena fuente y la cadena destino, además del nuevo carácter nulo.
Ambas cadenas deben estar terminadas en '\0'.
destination no puede ser una cadena literal (constante).
Las cadenas source y destination no deben solaparse.

Implementación de `strcat` (Simulación)

#include <stdio.h>

char* mi_strcat(char* dest_buf, const char* src_buf) {
    char* puntero_inicio = dest_buf; // Guarda el puntero original del destino

    while (*dest_buf != '\0') { // Encuentra el final de la cadena destino
        dest_buf++;
    }
    while ((*dest_buf++ = *src_buf++) != '\0'); // Copia la cadena fuente incluyendo '\0'
    return puntero_inicio;
}

int main() {
    char prefijo[30] = "Prefijo-";
    char sufijo[] = "sufijo";
    mi_strcat(prefijo, sufijo);
    printf("Concatenación personalizada: %s\n", prefijo);
    return 0;
}

2.4. `strcmp`: Comparar Cadenas

int strcmp(const char* str1, const char* str2);

Propósito: Compara lexicográficamente dos cadenas de caracteres, str1 y str2, basándose en el valor ASCII de sus caracteres.

Modo de Comparación: Compara carácter a carácter. La comparación termina en el primer par de caracteres que difieren, o cuando se llega al final de una de las cadenas (o ambas).

Parámetros:

str1 — Primera cadena a comparar.
str2 — Segunda cadena a comparar.

Valor de Retorno:

Valor de Retorno	Significado
`< 0`	`str1` es lexicográficamente menor que `str2`
`== 0`	`str1` es lexicográficamente igual a `str2`
`> 0`	`str1` es lexicográficamente mayor que `str2`

#include <stdio.h>
#include <string.h> // Para strcmp

int main() {
    char cadena_A[] = "computadora";
    char cadena_B[] = "computo";
    char cadena_C[] = "computadora";

    int resultado1 = strcmp(cadena_A, cadena_B);
    int resultado2 = strcmp(cadena_A, cadena_C);
    int resultado3 = strcmp(cadena_B, cadena_A);

    if (resultado1 < 0) {
        printf("'%s' es menor que '%s'\n", cadena_A, cadena_B); // Salida: 'computadora' es menor que 'computo'
    }

    if (resultado2 == 0) {
        printf("'%s' es igual a '%s'\n", cadena_A, cadena_C); // Salida: 'computadora' es igual a 'computadora'
    }

    if (resultado3 > 0) {
        printf("'%s' es mayor que '%s'\n", cadena_B, cadena_A); // Salida: 'computo' es mayor que 'computadora'
    }
    return 0;
}

Notas importantes:

No compare cadenas directamente usando operadores ==, <, >. Siempre use strcmp.
El valor exacto (distinto de 0, 1, -1) puede variar entre implementaciones, solo importa su signo.
Ambas cadenas deben estar terminadas en '\0'.

Implementación de `strcmp` (Simulación)

#include <stdio.h>

int mi_strcmp(const char* s_izq, const char* s_der) {
    while (*s_izq != '\0' && *s_izq == *s_der) { // Mientras no sea el final y los caracteres sean iguales
        s_izq++;
        s_der++;
    }
    return (int)(*s_izq - *s_der); // Retorna la diferencia ASCII del primer carácter diferente o 0
}

int main() {
    char dato1[] = "ordenador";
    char dato2[] = "orden";
    int res = mi_strcmp(dato1, dato2);
    if (res < 0) {
        printf("'%s' es menor que '%s' (custom)\n", dato1, dato2);
    } else if (res == 0) {
        printf("'%s' es igual a '%s' (custom)\n", dato1, dato2);
    } else {
        printf("'%s' es mayor que '%s' (custom)\n", dato1, dato2);
    }
    return 0;
}

2.5. `strncpy`: Copiar N Caracteres

char* strncpy(char* destination, const char* source, size_t num);

Propósito: Copia hasta num caracteres de la cadena source a destination. Es una versión "segura" en el sentido de que permite limitar la cantidad de caracteres a copiar, ayudando a prevenir desbordamientos de búfer.

Parámetros:

destination — Puntero al array de caracteres de destino.
source — Puntero constante a la cadena de caracteres fuente.
num — El número máximo de caracteres a copiar.

Valor de Retorno: Un puntero a la cadena de destino (destination).

#include <stdio.h>
#include <string.h> // Para strncpy

int main() {
    char texto_completo[] = "Programacion en C";
    char destino_parcial[10]; // Tamaño para 9 caracteres + '\0'

    // Copiar los primeros 9 caracteres
    strncpy(destino_parcial, texto_completo, 9);
    destino_parcial[9] = '\0'; // strncpy NO garantiza terminación nula si num es menor o igual a la longitud de la fuente
    printf("Copia parcial: %s\n", destino_parcial); // Salida: Programac

    // Ejemplo donde 'num' es mayor que la longitud de la fuente:
    char cadena_corta[] = "abc";
    char destino_con_relleno[10] = {0}; // Inicializar a ceros para asegurar '\0'
    strncpy(destino_con_relleno, cadena_corta, 7); // Copia "abc" y rellena con '\0's
    printf("Copia con relleno: '%s'\n", destino_con_relleno); // Salida: 'abc'
    return 0;
}

Nota importante: Si el número de caracteres a copiar (num) es mayor o igual a la longitud de source, strncpy copiará toda la cadena y rellenará el resto de destination (hasta num caracteres) con caracteres nulos ('\0'). Si num es menor que la longitud de source, destination NO se terminará automáticamente con un nulo, lo que puede causar problemas si no se añade manualmente.

2.6. `strncat`: Concatenar N Caracteres

char* strncat(char* destination, const char* source, size_t num);

Propósito: Añade como máximo los primeros num caracteres de la cadena source al final de destination, sobrescribiendo el carácter nulo de destination. Siempre añade un carácter nulo de terminación al final del resultado.

Parámetros:

destination — Puntero al array de caracteres de destino.
source — Puntero constante a la cadena de caracteres fuente.
num — El número máximo de caracteres de source a añadir.

Valor de Retorno: Un puntero a la cadena de destino (destination).

#include <stdio.h>
#include <string.h> // Para strncat

int main() {
    char mensaje_buffer[50] = "Hola "; // Espacio suficiente
    char palabra1[] = "mundo";
    char palabra2[] = "feliz";

    strncat(mensaje_buffer, palabra1, 3); // Añade "mun"
    printf("Mensaje actual: %s\n", mensaje_buffer); // Salida: Hola mun

    strncat(mensaje_buffer, palabra2, 5); // Añade "feliz"
    printf("Mensaje final: %s\n", mensaje_buffer); // Salida: Hola munfeliz
    return 0;
}

Notas: Al igual que strcat, destination debe tener suficiente espacio, no puede ser una constante, y las cadenas no deben solaparse.

2.7. `strncmp`: Comparar N Caracteres

int strncmp(const char* str1, const char* str2, size_t num);

Propósito: Compara hasta num caracteres de dos cadenas, str1 y str2, o hasta que se encuentre un carácter nulo en cualquiera de ellas, lo que ocurra primero. La comparación se basa en los valores ASCII.

Modo de Comparación: Carácter a carácter, hasta num veces, o hasta '\0'.

Parámetros:

str1 — Primera cadena a comparar.
str2 — Segunda cadena a comparar.
num — El número máximo de caracteres a comparar.

Valor de Retorno: Igual que strcmp, un entero que indica si str1 es menor, igual o mayor que str2.

Valor de Retorno	Significado
`< 0`	`str1` es menor que `str2` (en los primeros `num` caracteres)
`== 0`	`str1` es igual a `str2` (en los primeros `num` caracteres)
`> 0`	`str1` es mayor que `str2` (en los primeros `num` caracteres)

#include <stdio.h>
#include <string.h> // Para strncmp

int main() {
    char palabra_completa[] = "biblioteca";
    char palabra_corta[] = "biblia";
    size_t limite_comp = 4; // Comparar los primeros 4 caracteres ("bibl")

    int resultado_limitado = strncmp(palabra_completa, palabra_corta, limite_comp);

    if (resultado_limitado == 0) {
        printf("Las primeras %zu letras de '%s' y '%s' son idénticas.\n", limite_comp, palabra_completa, palabra_corta);
    } else if (resultado_limitado < 0) {
        printf("'%s' es menor que '%s' en sus primeros %zu caracteres.\n", palabra_completa, palabra_corta, limite_comp);
    } else {
        printf("'%s' es mayor que '%s' en sus primeros %zu caracteres.\n", palabra_completa, palabra_corta, limite_comp);
    }

    // Otro ejemplo
    char fruta1[] = "manzana";
    char fruta2[] = "mandarina";
    limite_comp = 3; // Comparar "man"
    resultado_limitado = strncmp(fruta1, fruta2, limite_comp);
    if (resultado_limitado == 0) {
        printf("Las primeras %zu letras de '%s' y '%s' son idénticas.\n", limite_comp, fruta1, fruta2); // Este se imprimirá
    }
    return 0;
}

2.8. `strstr`: Buscar Subcadena

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

Propósito: Busca la primera ocurrencia de la cadena needle dentro de la cadena haystack.

Parámetros:

haystack — Puntero a la cadena principal donde se buscará.
needle — Puntero a la subcadena a buscar.

Valor de Retorno:

Si se encuentra needle, devuelve un puntero a la primera aparición de needle dentro de haystack.
Si no se encuentra needle, devuelve un puntero NULL.
Si needle es una cadena vacía (""), devuelve haystack.

#include <stdio.h>
#include <string.h> // Para strstr

int main() {
    char texto_largo[] = "Bienvenidos al curso de C de programación.";
    char buscar_palabra[] = "curso";
    char buscar_no_existente[] = "python";

    char* hallazgo = strstr(texto_largo, buscar_palabra);
    if (hallazgo != NULL) {
        printf("La palabra '%s' se encontró a partir de: '%s'\n", buscar_palabra, hallazgo);
    } else {
        printf("La palabra '%s' no se encontró.\n", buscar_palabra);
    }

    hallazgo = strstr(texto_largo, buscar_no_existente);
    if (hallazgo != NULL) {
        printf("La palabra '%s' se encontró a partir de: '%s'\n", buscar_no_existente, hallazgo);
    } else {
        printf("La palabra '%s' no se encontró.\n", buscar_no_existente);
    }
    return 0;
}

Implementación de `strstr` (Simulación)

#include <stdio.h>

char* mi_strstr(const char* texto_principal, const char* subcadena) {
    if (*subcadena == '\0') {
        return (char*)texto_principal; // Subcadena vacía siempre se encuentra al inicio
    }

    const char* ptr_principal;
    const char* ptr_sub;
    const char* inicio_actual = texto_principal;

    while (*inicio_actual != '\0') { // Recorrer la cadena principal
        ptr_principal = inicio_actual;
        ptr_sub = subcadena;

        // Intentar hacer coincidir la subcadena a partir de la posición actual
        while (*ptr_principal != '\0' && *ptr_sub != '\0' && *ptr_principal == *ptr_sub) {
            ptr_principal++;
            ptr_sub++;
        }

        if (*ptr_sub == '\0') { // Si la subcadena se agotó, significa que se encontró una coincidencia completa
            return (char*)inicio_actual;
        }

        inicio_actual++; // Avanzar en la cadena principal para la siguiente posible coincidencia
    }
    return NULL; // Subcadena no encontrada
}

int main() {
    char documento[] = "El lenguaje C es muy eficiente.";
    char termino[] = "eficiente";
    char* resultado_busqueda = mi_strstr(documento, termino);
    if (resultado_busqueda != NULL) {
        printf("Custom strstr: '%s' encontrado desde '%s'\n", termino, resultado_busqueda);
    } else {
        printf("Custom strstr: '%s' no encontrado.\n", termino);
    }
    return 0;
}

2.9. `strtok`: Tokenizar Cadena

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

Propósito: Divide la cadena str en una serie de "tokens" (subcadenas), utilizando los caracteres en delimiters como separadores. Modifica la cadena original, reemplazando los delimitadores encontrados por caracteres nulos ('\0').

Parámetros:

str — La cadena a tokenizar. En la primera llamada, es la cadena completa. En llamadas subsiguientes para seguir tokenizando la misma cadena, debe ser NULL.
delimiters — Una cadena que contiene todos los caracteres que se deben considerar como delimitadores.

Valor de Retorno:

Un puntero al siguiente token encontrado.
NULL si no quedan más tokens o si la cadena inicial era NULL.

#include <stdio.h>
#include <string.h> // Para strtok

int main() {
    char registro_empleado[] = "ID:123;Nombre:Juan Perez;Departamento:IT;Salario:50000";
    char* token_actual;
    char separadores[] = ":;"; // Delimitadores: dos puntos y punto y coma

    printf("Tokens del registro:\n");
    // Primera llamada a strtok, con la cadena a procesar
    token_actual = strtok(registro_empleado, separadores);
    while (token_actual != NULL) {
        printf("- %s\n", token_actual);
        // Llamadas subsiguientes con NULL para continuar con la misma cadena
        token_actual = strtok(NULL, separadores);
    }
    return 0;
}

Nota: strtok modifica la cadena original. Si necesita la cadena original intacta, haga una copia antes de usar strtok.

2.10. `strerror` y `perror`: Manejo de Errores

Estas funciones ayudan a obtener descripciones de errores del sistema.

`strerror`: Obtener Mensaje de Error

char* strerror(int errnum);

Propósito: Mapea un número de error (errnum) a una cadena de texto descriptiva del error. El número de error usualmente proviene de la varible global errno, definida en <errno.h>.

Parámetros: errnum — El código de error numérico.

Valor de Retorno: Un puntero a una cadena de caracteres que contiene la descripción del error. Esta cadena es estática y no debe ser modificada.

Algunos códigos de error comunes (el valor exacto puede variar):

Código de Error (`errno`)	Mensaje de Error (Ejemplo)
0	Success
1	Operation not permitted
2	No such file or directory
3	No such process
5	Input/output error
9	Bad file descriptor

#include <stdio.h>
#include <string.h> // Para strerror
#include <errno.h>  // Para errno

int main() {
    FILE* archivo_abierto;
    const char* nombre_archivo = "archivo_inexistente.txt";

    // Intentamos abrir un archivo que probablemente no existe
    archivo_abierto = fopen(nombre_archivo, "r");

    if (archivo_abierto == NULL) {
        fprintf(stderr, "Error al intentar abrir '%s'.\n", nombre_archivo);
        fprintf(stderr, "Código de error (errno): %d\n", errno);
        fprintf(stderr, "Descripción del error: %s\n", strerror(errno));
        return 1; // Indicamos que el programa finalizó con un error
    }

    printf("El archivo '%s' se abrió correctamente.\n", nombre_archivo);
    fclose(archivo_abierto); // Es buena práctica cerrar el archivo si se abrió
    return 0;
}

`perror`: Imprimir Mensaje de Error Estándar

void perror(const char* str);

Propósito: Imprime una cadena de caracteres proporcionada por el usuario (str), seguida de un signo de dos puntos, un espacio, el mensaje de error correspondiente a la variable global errno, y un salto de línea. Es una forma conveniente de reportar errores del sistema.

Parámetros: str — Una cadena de caracteres personalizada que se imprimirá antes del mensaje de error del sistema.

#include <stdio.h>
#include <errno.h> // Aunque perror lo usa internamente, incluirlo es buena práctica

int main() {
    FILE* archivo_fallido;
    const char* ruta_invalida = "/ruta/totalmente/invalida/no_existe.data";

    // Intentamos abrir un archivo en una ruta que seguramente no existe
    archivo_fallido = fopen(ruta_invalida, "w"); // Intentar escribir

    if (archivo_fallido == NULL) {
        perror("Fallo al crear archivo"); // Imprimirá algo como: "Fallo al crear archivo: No such file or directory"
        return 1;
    }

    printf("Archivo creado exitosamente (esto no debería pasar en este ejemplo).\n");
    fclose(archivo_fallido);
    return 0;
}

Etiquetas: Lenguaje C Funciones de Caracteres Funciones de Cadenas ctype.h string.h

Publicado el 7-23 02:03

Friki Work

Funciones de Caracteres y Manipulación de Cadenas en C

1.1. Funciones de Clasificación de Caracteres

Ejemplo: Convertir toda una cadena a mayúsculas

1.2. Funciones de Conversión de Caracteres

1.3. Funciones de Entrada/Salida de Caracteres: `getchar` y `putchar`

Consideración importante con `getchar()` y `scanf()`

2.1. `strlen`: Calcular la Longitud de una Cadena

Implementación de `strlen` (Simulaciones)

2.2. `strcpy`: Copiar una Cadena

Implementación de `strcpy` (Simulación)

2.3. `strcat`: Concatenar Cadenas

Implementación de `strcat` (Simulación)

2.4. `strcmp`: Comparar Cadenas

Implementación de `strcmp` (Simulación)

2.5. `strncpy`: Copiar N Caracteres

2.6. `strncat`: Concatenar N Caracteres

2.7. `strncmp`: Comparar N Caracteres

2.8. `strstr`: Buscar Subcadena

Implementación de `strstr` (Simulación)

2.9. `strtok`: Tokenizar Cadena

2.10. `strerror` y `perror`: Manejo de Errores

`strerror`: Obtener Mensaje de Error

`perror`: Imprimir Mensaje de Error Estándar

Etiquetas populares

Friki Work

Funciones de Caracteres y Manipulación de Cadenas en C

1.1. Funciones de Clasificación de Caracteres

Ejemplo: Convertir toda una cadena a mayúsculas

1.2. Funciones de Conversión de Caracteres

1.3. Funciones de Entrada/Salida de Caracteres: getchar y putchar

Consideración importante con getchar() y scanf()

2.1. strlen: Calcular la Longitud de una Cadena

Implementación de strlen (Simulaciones)

2.2. strcpy: Copiar una Cadena

Implementación de strcpy (Simulación)

2.3. strcat: Concatenar Cadenas

Implementación de strcat (Simulación)

2.4. strcmp: Comparar Cadenas

Implementación de strcmp (Simulación)

2.5. strncpy: Copiar N Caracteres

2.6. strncat: Concatenar N Caracteres

2.7. strncmp: Comparar N Caracteres

2.8. strstr: Buscar Subcadena

Implementación de strstr (Simulación)

2.9. strtok: Tokenizar Cadena

2.10. strerror y perror: Manejo de Errores

strerror: Obtener Mensaje de Error

perror: Imprimir Mensaje de Error Estándar

Etiquetas populares

1.3. Funciones de Entrada/Salida de Caracteres: `getchar` y `putchar`

Consideración importante con `getchar()` y `scanf()`

2.1. `strlen`: Calcular la Longitud de una Cadena

Implementación de `strlen` (Simulaciones)

2.2. `strcpy`: Copiar una Cadena

Implementación de `strcpy` (Simulación)

2.3. `strcat`: Concatenar Cadenas

Implementación de `strcat` (Simulación)

2.4. `strcmp`: Comparar Cadenas

Implementación de `strcmp` (Simulación)

2.5. `strncpy`: Copiar N Caracteres

2.6. `strncat`: Concatenar N Caracteres

2.7. `strncmp`: Comparar N Caracteres

2.8. `strstr`: Buscar Subcadena

Implementación de `strstr` (Simulación)

2.9. `strtok`: Tokenizar Cadena

2.10. `strerror` y `perror`: Manejo de Errores

`strerror`: Obtener Mensaje de Error

`perror`: Imprimir Mensaje de Error Estándar