Guía para principiantes: Arreglos char en C – De lo básico a cadenas avanzadas

1. Introducción

2. ¿Qué es un arreglo de char?

¿Qué es el tipo char?

char c = 'A';

Sintaxis básica de los arreglos de char

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

Importancia del carácter nulo (‘

Tamaño del arreglo y consideraciones

char str[] = "Hello"; // automáticamente agrega un '\0' al final

3. Declaración e Inicialización de Arreglos char

Declaración e Inicialización Estáticas

Inicialización con Literales de Cadena

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

Asignación de un Literal con un Tamaño Especificado

char str[] = "Hello";

Uso de Asignación Dinámica de Memoria (malloc)

char str[5] = "Hello"; // ❌ Error causado por tamaño insuficiente

4. Operaciones con cadenas

#include 
#include 

char* str = malloc(6 * sizeof(char));
strcpy(str, "Hello");

Copia de cadena: strcpy

Concatenación de cadenas: strcat

#include 

char src[] = "Hello";
char dest[10];
strcpy(dest, src);

Obtención de la longitud de la cadena: strlen

#include 

char str1[20] = "Hello";
char str2[] = " World";
strcat(str1, str2);

Comparación de cadenas: strcmp

#include 

char str[] = "Hello";
int len = strlen(str); // len = 5

Búsqueda en cadena: strchr y strstr

#include 

char str1[] = "Hello";
char str2[] = "World";

if (strcmp(str1, str2) == 0) {
    // iguales
} else {
    // diferentes
}

5. Diferencias entre arreglos de char y punteros

#include 

char str[] = "Hello World";

// búsqueda de carácter
char *ptr1 = strchr(str, 'o'); // puntero al primer 'o'

// búsqueda de subcadena
char *ptr2 = strstr(str, "World"); // puntero al inicio de "World"

Diferencias en las declaraciones

Diferencias en la mutabilidad

char str1[] = "Hello";  // arreglo de char
char *str2 = "Hello";   // puntero de char

Diferencias en la estructura de memoria

str1[0] = 'h'; // Correcto

str2[0] = 'h'; // ❌ Comportamiento indefinido (posible error en tiempo de ejecución)

Diferencias en la obtención del tamaño

• arreglo de char es una entidad local asignada en lapila.
• puntero de char puede apuntar a unaregión constante (solo lectura)o unaregión de montón (malloc, etc.); es más flexible, perose debe tener cuidado al manejar la memoria.

Resumen: Puntos para elegir

char str1[] = "Hello";
printf("%lu", sizeof(str1)); // → 6 (incluyendo el terminador nulo)

char *str2 = "Hello";
printf("%lu", sizeof(str2)); // → 8 (entorno de 64 bits)

6. Cómo pasar un arreglo de char a una función

Ejemplo básico: Pasar un arreglo de char como argumento

Función que modifica el contenido

#include 

void printString(char str[]) {
    printf("Cadena: %s\n", str);
}

int main() {
    char greeting[] = "Hola";
    printString(greeting);
    return 0;
}

Gestión del tamaño del arreglo

#include 

void toUpperCase(char str[]) {
    for (int i = 0; str[i] != ' '; i++) {
        if ('a' <= str[i] && str[i] <= 'z') {
            str[i] = str[i] - ('a' - 'A');
        }
    }
}

int main() {
    char text[] = "hola mundo";
    toUpperCase(text);
    printf("%s\n", text); // Salida: HOLA mundo
    return 0;
}

Argumentos de solo lectura usando const

void printChars(char str[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%c ", str[i]);
    }
    printf("\n");
}

7. Ejemplo Práctico: Mostrar una Cadena en Orden Inverso

void printConstString(const char *str) {
    printf("%s\n", str);
}

Propósito

Código de Ejemplo

Explicación

#include 
#include 

void printReversed(char str[]) {
    int len = strlen(str);
    for (int i = len - 1; i >= 0; i--) {
        putchar(str[i]);
    }
    putchar('n');
}

int main() {
    char text[100];

    printf("Ingrese una cadena:");
    fgets(text, sizeof(text), stdin);

    // Eliminar el carácter de nueva línea (manejo para el uso de fgets)
    size_t len = strlen(text);
    if (len > 0 && text[len - 1] == 'n') {
        text[len - 1] = '\0';
    }

    printf("Salida invertida:");
    printReversed(text);

    return 0;
}

Ejecución de Ejemplo

• La función fgets puede leer de manera segura cadenas que contienen espacios.
• Asegúrese de eliminar el 'n' final (carácter de nueva línea) agregado a la entrada.
• Use strlen() para obtener la longitud de la cadena y mostrarla carácter por carácter en un bucle inverso.

Consejos de Aplicación

Ingrese una cadena: OpenAI
Salida invertida: IAnepO

8. Errores comunes y sus soluciones

1. Omisión del terminador nulo ()

2. Tamaño de búfer insuficiente

char str[5] = {'H', 'e', 'l', 'l', 'o'}; // ❌ falta '\0' al final
printf("%sn", str); // comportamiento indefinido

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

3. Modificar literales de cadena

char str1[5];
strcpy(str1, "Hello"); // ❌ copia 6 caracteres en un arreglo de tamaño 5

• Asegúrese de que el destino tengatamaño suficiente(por ejemplo, “número de caracteres + 1”).
• Considere usar el más seguro strncpy.

char str1[6];
strncpy(str1, "Hello", sizeof(str1) - 1);
str1[5] = '\0'; // agregar explícitamente el terminador nulo al final como precaución

4. Olvidar manejar el carácter de nueva línea de fgets

char *str = "Hello";
str[0] = 'h'; // ❌ causa una falla de segmentación en tiempo de ejecución

char str[] = "Hello"; // ✅ declarado como un arreglo mutable
str[0] = 'h';

5. Confundir punteros y arreglos

fgets(str, sizeof(str), stdin);
// str contendrá algo como "Hellon\0"

size_t len = strlen(str);
if (len > 0 && str[len - 1] == '\n') {
    str[len - 1] = '\0';
}

9. Resumen

Lo que aprendiste en este artículo

Orientación para el aprendizaje futuro

• Función y declaración de arreglos charEn C, no hay un tipo de cadena, por lo que para manejar cadenas usas arreglos char.
• Literales de cadena y la importancia del carácter nulo ()Un terminador nulo al final es esencial para representar cadenas.
• Manipulación de cadenas usando funciones de la biblioteca estándarUsando funciones como strcpy, strcat, strlen, strcmp, puedes procesar cadenas de manera eficiente.
• Diferencias entre arreglos char y punteros charLos arreglos y los punteros pueden parecer similares, pero son fundamentalmente diferentes, con claras distinciones en el diseño de memoria y la mutabilidad.
• Pasar arreglos a funciones y consideraciones de seguridadDado que los arreglos en realidad se pasan como punteros, debes tener cuidado con las modificaciones y la gestión del tamaño.
• Consolidar el entendimiento a través de ejemplos prácticos y errores comunesAplicando a código real y manejando errores, aprendiste un uso más realista.

Orientación para el aprendizaje futuro

• Aritmética de punteros: profundiza tu comprensión de arreglos char y punteros
• Gestión dinámica de memoria: manejo avanzado de cadenas usando malloc y free
• Combinación con estructuras: diseño de aplicaciones prácticas usando estructuras de datos