Introducción

El tipo de dato cadena, al menos en los estándares de C, no existe.

Una cadena es un arreglo de caracteres, o sea, del tipo char.

Por lo tanto, para declarar un arreglo de cadenas o strings en C necesitamos un arreglo de caracteres bidimensional, porque tendrá arreglos dentro de un arreglo.

Veamos hoy cómo declararlo, calcular su tamaño, recorrerlo y pasarlo como argumento a una función en C.

Declarar un arreglo de cadenas

Lo malo de esto es que no podemos confiar en que el compilador pondrá la longitud automáticamente. Por ejemplo, cuando declaramos una cadena podemos hacer esto:

char busqueda[] = {"Comadreja"};

Ahí, no declaramos la longitud de la cadena pero el compilador se la pondrá. No pasa lo mismo con un arreglo de cadenas.

La forma con la que soñamos es:

char arreglo[][] = {"Arsenal", "Bautizo", "Comadreja", "Consulta", "Dinosaurio", "Zapato"};

Pero no, no es así. Si intentamos compilar, GCC u otro compilador nos avisará que todas las dimensiones del arreglo deben tener límites, excepto la primera.

O sea que estamos obligados a poner la longitud de las cadenas que podrá albergar el arreglo. Así:

char arreglo[][50] = {"Arsenal", "Bautizo", "Comadreja", "Consulta", "Dinosaurio", "Zapato"};

En ese caso, el compilador calculará la cantidad de cadenas que hay, pero nosotros le decimos cuál es la longitud máxima.

En resumen, podemos poner cadenas de hasta 50 caracteres dentro de nuestro arreglo.

Pero no te confundas, ese número lo ponemos nosotros, puedes cambiarlo a 9999 si quieres, o ponerlo en un macro al inicio:

#define MAXIMA_LONGITUD_CADENA 50

Y declarar el arreglo así:

char arreglo[][MAXIMA_LONGITUD_CADENA] = {"Arsenal", "Bautizo", "Comadreja", "Consulta", "Dinosaurio", "Zapato"};

De esta manera puedes cambiar la longitud rápidamente.

Calcular tamaño de arreglo de cadenas en C

Igualmente usamos sizeof para calcular el tamaño, como lo vimos hace algún tiempo.

Para la longitud de un arreglo de cadenas nada cambia, así se calcula:

int longitudDelArreglo = sizeof(arreglo) / sizeof(arreglo[0]);

Un programa que imprime su longitud y que nos sirve de ejemplo es este:

/*
    Trabajando con arreglos de cadenas en C
    @author parzibyte
*/#include <stdio.h>
#define MAXIMA_LONGITUD_CADENA 50
 
int main(){
    char arreglo[][MAXIMA_LONGITUD_CADENA] = {"Arsenal", "Bautizo", "Comadreja", "Consulta", "Dinosaurio", "Zapato"};
    int longitudDelArreglo = sizeof(arreglo) / sizeof(arreglo[0]);
    printf("El arreglo mide: %d", longitudDelArreglo);
}

Al ejecutarlo, la salida será El arreglo mide: 6

Recorrer arreglo de cadenas en C

Igual que los otros. Aquí el código necesario, pues es casi la combinación de lo de arriba:

/*
    Trabajando con arreglos de cadenas en C: recorrer uno
    @author parzibyte
*/#include <stdio.h>
#define MAXIMA_LONGITUD_CADENA 50
 
int main(){
    char arreglo[][MAXIMA_LONGITUD_CADENA] = {"Arsenal", "Bautizo", "Comadreja", "Consulta", "Dinosaurio", "Zapato"};
    int longitudDelArreglo = sizeof(arreglo) / sizeof(arreglo[0]);
    for(int x = 0; x < longitudDelArreglo; x++){
        printf("En %d el arreglo tiene el valor %s\n", x, arreglo[x]);
    }
}

Es un ciclo for a partir de que ya tenemos el tamaño o longitud del arreglo. Y dentro del arreglo hay cadenas.

Pasar un arreglo de cadenas como argumento a una función en C

Para terminar veremos cómo podemos llamar a una función y pasarle nuestro arreglo de cadenas; dentro de la función simplemente lo vamos a recorrer.

Si queremos recibir un arreglo, debemos definir sus límites al igual que cuando lo declaramos. Así:

void funcion(char arreglo[][20]){
 
}

No debemos especificar la longitud del mismo, pero sí de lo que contiene. Para llamar a una función, primero declaramos el arreglo y se lo pasamos sin más.

Aquí un ejemplo:

/*
    Trabajando con arreglos de cadenas en C:
        Pasarlo como argumento a función
    @author parzibyte
*/#include <stdio.h>
#define MAXIMA_LONGITUD_CADENA 50
 
void imprimirArregloDeCadenas(char arreglo[][MAXIMA_LONGITUD_CADENA], int longitudDelArreglo);
 
int main(){
    char arreglo[][MAXIMA_LONGITUD_CADENA] = {"Arsenal", "Bautizo", "Comadreja", "Consulta", "Dinosaurio", "Zapato"};
    int longitudDelArreglo = sizeof(arreglo) / sizeof(arreglo[0]);
    imprimirArregloDeCadenas(arreglo, longitudDelArreglo);
}
 
void imprimirArregloDeCadenas(char arreglo[][MAXIMA_LONGITUD_CADENA], int longitudDelArreglo){
    for(int x = 0; x < longitudDelArreglo; x++){
        printf("En %d el arreglo tiene el valor %s\n", x, arreglo[x]);
    }
}

Combinando todo lo de arriba, podemos usar a la función del preprocesador para que ponga los límites dependiendo de MAXIMA_LONGITUD_CADENA.

De esta manera podemos llamar a funciones con arreglos de cadenas en C.