¿Qué son los arrays y cadenas en C?

Bienvenidos a la gestión de datos en masa, mis queridos STEAMdiantes.

Aquí es donde la programación deja de ser “teoría de juguetes” y se convierte en una herramienta de ingeniería real. Hasta ahora, manejábamos variables individuales (una temperatura, un voltaje). Pero, ¿qué pasa si necesitas guardar los datos de 1,000 sensores vibratorios en un puente? ¿Crearías variable1, variable2… hasta variable1000? Eso sería una locura.

Necesitamos estructuras de datos. Necesitamos Arrays.

Un array (también llamado arreglo o vector) es una colección de variables del mismo tipo, almacenadas en bloques de memoria contiguos (uno al lado del otro) y accesibles bajo un mismo nombre.

Imagina un casillero o un pastillero semanal. Tienes el pastillero “Medicina”. Dentro, tienes compartimentos individuales: Lunes, Martes, Miércoles… Todos guardan medicinas (mismo tipo) y están pegados físicamente (contiguos).

Declaración y acceso

Para crear un array, definimos el tipo de dato, el nombre y el tamaño (cuántos espacios tendrá).

// Tipo nombre[TAMAÑO];
int lecturas[5]; // Un array de 5 enteros

La regla de oro (Zero-Indexing): En C (y en casi toda la ingeniería de software), empezamos a contar desde 0. Si pides 5 espacios, tus índices son: 0, 1, 2, 3, 4. 

• El índice 5 no existe. Es un error clásico intentar acceder a él.

lecturas[0] = 10; // Guardamos 10 en la primera posición
lecturas[4] = 50; // Guardamos 50 en la última posición
// lecturas[5] = 20; // ¡ERROR! Desbordamiento de memoria (Buffer Overflow)

Inicialización rápida

Podemos llenar el casillero al momento de comprarlo:

int voltajes[] = {12, 5, 3, 9}; 
// C cuenta automáticamente que son 4 elementos.

Cadenas de texto (Strings) 

Aquí viene una revelación importante: en C, el tipo de dato String no existe. 

A diferencia de Python o Java, C no tiene un tipo nativo para texto. Lo que llamamos “cadena” o string es simplemente un array de caracteres (char).

El carácter nulo (\0)

Si escribes “HOLA”, C lo guarda así en la memoria: [‘H’] [‘O’] [‘L’] [‘A’] [‘\0’]

¿Ves ese \0 al final? Es el carácter nulo (Null Terminator). Es vital. Le dice a la computadora: “Aquí termina el texto”. Sin él, la computadora seguiría leyendo basura de la memoria RAM hasta colapsar.

Declaración de una cadena:

// Opción A (Manual — Tediosa):
char saludo[5] = {'H', 'o', 'l', 'a', '\0'}; // ¡Debes contar el \0!

// Opción B (Ingenieril — Automática):
char saludo[] = "Hola"; 
// C calcula automáticamente 5 espacios (4 letras + 1 nulo)

Ojo con las comillas:

• ‘A’ (Comillas simples): Es un carácter (un solo número entero pequeño).
• “A” (Comillas dobles): Es una cadena (un array que contiene la letra ‘A’ y el terminador \0).

Limitaciones críticas

• Tamaño fijo: Una vez que declaras int datos[10], ese array tendrá 10 espacios para siempre. No puedes “agrandarlo” mágicamente si te llegan más datos (para eso necesitaremos memoria dinámica, un tema avanzado).
• Desbordamiento (Buffer Overflow): C no te protege. Si declaras char nombre[5] e intentas escribir “Alejandro” (9 letras), C intentará hacerlo. Escribirá encima de lo que haya en la memoria vecina, corrompiendo otros datos o vulnerando tu propio programa.

Práctica: registrador de datos

Vamos a Visual Studio. Crearemos un programa que simule un sistema de votación simple. Usaremos un array numérico para los votos y cadenas de texto para los nombres.

#include <stdio.h>
#include <string.h> // Biblioteca necesaria para trabajar con cadenas (strcpy, etc.)

int main() {
    // 1. Arrays de Datos Numéricos
    // Supongamos 3 candidatos. Inicializamos votos en 0.
    int votos[3] = {0, 0, 0}; 

    // 2. Arrays de Cadenas (Matriz de caracteres)
    // "3 espacios" de "20 caracteres cada uno"
    char candidatos[3][20] = {
        "Ingenieria", 
        "Medicina", 
        "Leyes"
    };

    printf("=== SISTEMA DE VOTACION v1.0 ===\n");

    // Simulamos una votación manual
    // Voto para Ingeniería (Índice 0)
    votos[0]++; 
    votos[0]++;
    votos[0]++; // 3 votos

    // Voto para Medicina (Índice 1)
    votos[1]++; // 1 voto

    // 3. Procesamiento con Bucles (Iteración)
    // Usamos un 'for' para recorrer el array. Es la pareja perfecta del array.
    printf("\nResultados Preliminares:\n");
    
    for (int i = 0; i < 3; i++) {
        // %s imprime una cadena hasta encontrar el \0
        // %d imprime el entero
        printf("Candidato %s: %d votos\n", candidatos[i], votos[i]);
    }

    // 4. Manipulación de Cadenas (Ojo aquí)
    char mensaje_final[50];
    
    // NO puedes hacer: mensaje_final = "Ganador"; (Eso es ilegal en C)
    // Debes usar una función para copiar texto: strcpy (String Copy)
    strcpy(mensaje_final, "El ganador virtual es: ");
    
    printf("\n%s %s\n", mensaje_final, candidatos[0]);

    return 0;
}

Análisis:

• Iteración: Fíjate cómo el bucle for va desde i=0 hasta i<3. Esto recorre perfectamente los índices 0, 1 y 2.
• candidatos[3][20]: Esto es un array multidimensional (una tabla). Una lista de 3 nombres, donde cada nombre puede tener hasta 20 letras.
• strcpy: Aprendiste que las cadenas son especiales. No se pueden asignar con =, hay que copiarlas carácter por carácter (o usar funciones como strcpy que lo hacen por ti).

Con los arrays, ya puedes manejar grandes volúmenes de información. Pero, ¿qué pasa en la memoria realmente? ¿Cómo sabe C dónde empieza y termina el array?

Aquí es donde entramos en el terreno de los “magos oscuros” de C. El concepto más temido y poderoso. Nos enfrentaremos al jefe final: punteros.

Gracias por leernos.
Si te gusto este artículo, únete a nuestra comunidad en Facebook o WhatsApp para más…
¡Hasta la próxima!