Curso de C
Por Nacho Cabanes, versión 0.90 pre4

5. Arrays y estructuras


5.1. Conceptos básicos sobre tablas

5.1.1. Definición de una tabla y acceso a los datos

Una tabla, vector, matriz o array (que algunos autores traducen por “arreglo”) es un conjunto de elementos, todos los cuales son del mismo tipo. Estos elementos tendrán todos el mismo nombre, y ocuparán un espacio contiguo en la memoria.

Por ejemplo, si queremos definir un grupo de 4 números enteros, usaríamos

int ejemplo[4];

Podemos acceder a cada uno de los valores individuales indicando su nombre (ejemplo) y el número de elemento que nos interesa, pero con una precaución: se empieza a numerar desde 0, así que en el caso anterior tendríamos 4 elementos, que serían ejemplo[0], ejemplo[1], ejemplo[2], ejemplo[3].

Como ejemplo, vamos a definir un grupo de 5 números enteros y hallar su suma:

/*---------------------------*/
/*  Ejemplo en C nº 38:      */
/*  C038.C                   */
/*                           */
/*  Primer ejemplo de tablas */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
 
main()
{
    int numero[5];           /* Un array de 5 números enteros */
    int suma;                /* Un entero que será la suma */
 
    numero[0] = 200;      /* Les damos valores */
    numero[1] = 150;
    numero[2] = 100;
    numero[3] = -50;
    numero[4] = 300;
    suma = numero[0] +    /* Y hallamos la suma */
        numero[1] + numero[2] + numero[3] + numero[4];
    printf("Su suma es %d", suma);
    /* Nota: esta es la forma más ineficiente e incómoda */
    /* Ya lo iremos mejorando */
}
 

Ejercicios propuestos:

5.1.2. Valor inicial de una tabla

Al igual que ocurría con las variables “normales”, podemos dar valor a los elementos de una tabla al principio del programa. Será más cómodo que dar los valores uno por uno, como hemos hecho antes. Esta vez los indicaremos todos entre llaves, separados por comas:

/*---------------------------*/
/*  Ejemplo en C nº 39:      */
/*  C039.C                   */
/*                           */
/*  Segundo ejemplo de       */
/*  tablas                   */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
main()
{
    int numero[5] =            /* Un array de 5 números enteros */
      {200, 150, 100, -50, 300};
    int suma;                  /* Un entero que será la suma */
 
    suma = numero[0] +    /* Y hallamos la suma */
        numero[1] + numero[2] + numero[3] + numero[4];
    printf("Su suma es %d", suma);
    /* Nota: esta forma es algo menos engorrosa, pero todavía no */
    /* está bien hecho.  Lo seguiremos mejorando */
}
 

Ejercicios propuestos:

•  Un programa que almacene en una tabla el número de días que tiene cada mes (su­pon­dremos que es un año no bisiesto), pida al usuario que le indique un mes (1=enero, 12=diciembre) y muestre en pantalla el número de días que tiene ese mes.

•  Un programa que almacene en una tabla el número de días que tiene cada mes (año no bisiesto), pida al usuario que le indique un mes (ej. 2 para febrero) y un día (ej. el día 15) y diga qué número de día es dentro del año (por ejemplo, el 15 de febrero sería el día número 46, el 31 de diciembre sería el día 365).

 

5.1.3. Recorriendo los elementos de una tabla

Es de esperar que exista una forma más cómoda de acceder a varios elementos de un array, sin tener siempre que repetirlos todos, como hemos hecho en

suma = numero[0] + numero[1] + numero[2] + numero[3] + numero[4];

El “truco” consistirá en emplear cualquiera de las estructuras repetitivas que ya hemos visto (while, do..while, for), por ejemplo así:

suma = 0; /* Valor inicial */
for (i=0; i<=4; i++)
suma += numero[i];

En este caso, que sólo sumábamos 5 números, no hemos escrito mucho menos, pero si trabajásemos con 100, 500 o 1000 números, la ganancia en comodidad sí que está clara.

Ejercicios propuestos:

 

5.2. Cadenas de caracteres

5.2.1. Definición. Lectura desde teclado

Para las cadenas de texto, la situación se complica un poco: se crean como “arrays” de caracteres. Están formadas por una sucesión de caracteres terminada con un carácter nulo (\0), de modo que tendremos que reservar una letra más de las que necesitamos. Por ejemplo, para guardar el texto “Hola” usaríamos “char saludo[5]”.

Este carácter nulo lo utilizarán todas las órdenes estándar que tienen que ver con manejo de cadenas: las que las muestran en pantalla, las que comparan cadenas, las que dan a una cadena un cierto valor, etc. Por tanto, si no queremos usar esas funciones y sólo vamos a acceder letra a letra (como hemos hecho con los números en los últimos ejemplos) nos bastaría con “char saludo[4]”, pero si queremos usar cualquiera de esta posibilidades (será lo habitual), deberemos tener la prudencia de reservar una letra más de las “necesarias”, para ese carácter nulo, que indica el final de la cadena, y que todas esas órdenes utilizan para saber cuando deben terminar de manipular la cadena.

Un primer ejemplo que nos pidiese nuestro nombre y nos saludase sería:

/*---------------------------*/
/*  Ejemplo en C nº 40:      */
/*  C040.C                   */
/*                           */
/*  Primer ejemplo de        */
/*  cadenas de texto         */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
 
main()
{
    char texto[40];         /* Para guardar hasta 39 letras */
 
    printf("Introduce tu nombre: ");
    scanf("%s", &texto);
    printf("Hola, %s\n", texto);
}
 

Dos comentarios:

/*---------------------------*/
/*  Ejemplo en C nº 41:      */
/*  C041.C                   */
/*                           */
/*  Segundo ejemplo de       */
/*  cadenas de texto: scanf  */
/*  sin &                    */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
 
main()
{
    char texto[40];         /* Para guardar hasta 39 letras */
 
    printf("Introduce tu nombre: ");
    scanf("%s", texto);
    printf("Hola, %s\n", texto);
}
 

5.2.2. Cómo acceder a las letras que forman una cadena

Podemos leer (o modificar) una de las letras de una cadena de igual forma que leemos o modificamos los elementos de cualquier tabla: el primer elemento será texto[0], el segundo será texto[1] y así sucesivamente:

/*---------------------------*/
/*  Ejemplo en C nº 42:      */
/*  C042.C                   */
/*                           */
/*  Tercer ejemplo de        */
/*  cadenas de texto:        */
/*  acceder letra a letra    */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
 
main()
{
    char texto[40];         /* Para guardar hasta 39 letras */
 
    printf("Introduce tu nombre: ");
    scanf("%s", texto);
    printf("Hola, %s. Tu inicial es %c\n", texto, texto[0]);
}
 

5.2.3. Longitud de la cadena.

En una cadena que definamos como “char texto[40]” lo habitual es que realmente no ocupemos las 39 letras que podríamos llegar a usar. Si guardamos 9 letras (y el carácter nulo que marca el final), tendremos 30 posiciones que no hemos usado. Pero estas 30 posiciones generalmente contendrán “basura”, lo que hubiera previamente en esas posiciones de memoria, porque el compilador las reserva para nosotros pero no las “limpia”. Si queremos saber cual es la longitud real de nuestra cadena tenemos dos opciones:

> Podemos leer la cadena carácter por carácter desde el principio hasta que encontremos el carácter nulo (\0) que marca el final.

> Hay una orden predefinida que lo hace por nosotros, y que nos dice cuantas letras hemos usado realmente en nuestra cadena. Es “strlen”, que se usa así:

/*---------------------------*/
/*  Ejemplo en C nº 43:      */
/*  C043.C                   */
/*                           */
/*  Longitud de una cadena   */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
#include <string.h>
 
main()
{
    char texto[40];
 
    printf("Introduce una palabra: ");
    scanf("%s", texto);
    printf("Has tecleado %d letras", strlen(texto));
}
 

Como es de esperar, si escribimos “Hola”, esta orden nos dirá que hemos tecleado 4 letras (no cuenta el \0 que se añade automáticamente al final).

Si empleamos “strlen”, o alguna de las otras órdenes relacionadas con cadenas de texto que veremos en este tema, debemos incluir <string.h> , que es donde se definen todas ellas.

Ejercicio propuesto:

5.2.4. Entrada/salida para cadenas: gets, puts

Hemos visto que si leemos una cadena de texto con “scanf”, se paraba en el primer espacio en blanco y no seguía leyendo a partir de ese punto. Existen otras órdenes que están diseñadas específicamente para manejar cadenas de texto, y que nos podrán servir en casos como éste.

Para leer una cadena de texto (completa, sin parar en el primer espacio), usaríamos la orden “gets”, así:

gets(texto);

De igual modo, para escribir un texto en pantalla podemos usar “puts”, que muestra la cadena de texto y avanza a la línea siguiente:

puts(texto);

Sería equivalente a esta otra orden:

printf("%s\n", texto);

Ejercicio propuesto:


5.2.5. Asignando a una cadena el valor de otra: strcpy, strncpy; strcat

Cuando queremos dar a una variable el valor de otra, normalmente usamos construcciones como a =2, o como a = b. Pero en el caso de las cadenas de texto, esta NO es la forma correcta, no podemos hacer algo como saludo="hola" ni algo como texto1=texto2. Si hacemos algo así, haremos que las dos cadenas estén en la misma posición de memoria, y que los cambios que hagamos a una de ellas se reflejen también en la otra. La forma correcta de guardar en una cadena de texto un cierto valor es:

strcpy (destino, origen);

Es decir, debemos usar una función llamada “strcpy” (string copy, copiar cadena), que se encuentra también en “string.h”. Vamos a ver dos ejemplos de su uso:

strcpy (saludo, "hola");

strcpy (textoDefinitivo, textoProvisional);

Es nuestra responsabilidad que en la cadena de destino haya suficiente espacio reservado para copiar lo que queremos. Si no es así, estaremos sobreescribiendo direcciones de memoria en las que no sabemos qué hay.

Para evitar este problema, tenemos una forma de indicar que queremos copiar sólo los primeros n bytes de origen, usando la función “strncpy”, así:

strncpy (destino, origen, n);

Vamos a ver un ejemplo, que nos pida que tecleemos una frase y guarde en otra variable sólo las 4 primeras letras:

/*---------------------------*/
/*  Ejemplo en C nº 44:      */
/*  C044.C                   */
/*                           */
/*  Tomar 4 letras de una    */
/*  cadena                   */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
#include <string.h>
 
main()
{
    char texto1[40], texto2[40], texto3[10];
 
    printf("Introduce un frase: ");
    gets(texto1);
 
    strcpy(texto2, texto1);
    printf("Una copia de tu texto es %s\n", texto2);
    strncpy(texto3, texto1, 4);
    printf("Y sus 4 primeras letras son %s\n", texto3);
}
 

Finalmente, existe otra orden relacionada con estas dos: podemos añadir una cadena al final de otra (concatenarla), con

strcat (destino, origen);

Vamos a ver un ejemplo de su uso, que nos pida nuestro nombre, nuestro apellido y cree una nueva cadena de texto que contenga los dos, separados por un espacio:

/*---------------------------*/
/*  Ejemplo en C nº 45:      */
/*  C045.C                   */
/*                           */
/*  Concatenar dos cadenas   */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
#include <string.h>
 
main()
{
    char texto1[40], texto2[40], texto3[40];
 
    printf("Introduce tu nombre: ");
    gets(texto1);
 
    printf("Introduce tu apellido: ");
    gets(texto2);
 
    strcat(texto1, " ");     /* Añado un espacio al nombre */
    strcat(texto1, texto2);  /* Y luego el apellido */
    printf("Te llamas %s\n", texto1);
}
 

Ejercicio propuesto:

5.2.6. Comparando cadenas: strcmp

Para comparar dos cadenas alfabéticamente (para ver si son iguales o para poder ordenarlas, por ejemplo), usamos

strcmp (cad1, cad2);

Esta función devuelve un número entero, que será:

Hay que tener cuidado, porque las cadenas se comparan como en un diccionario, pero hay que tener en cuenta ciertas cosas:

Vamos a ver un primer ejemplo que nos pida dos palabras y diga si hemos tecleado la misma las dos veces:

/*---------------------------*/
/*  Ejemplo en C nº 46:      */
/*  C046.C                   */
/*                           */
/*  Comparar dos cadenas     */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
#include <string.h>
 
 
main()
{
    char texto1[40], texto2[40];
 
    printf("Introduce una palabra: ");
    gets(texto1);
 
    printf("Introduce otra palabra: ");
    gets(texto2);
 
    if (strcmp(texto1, texto2)==0)
        printf("Son iguales\n");
    else
        printf("Son distintas\n");
}
 

Podemos mejorarlo ligeramente para que nos diga qué palabra es “menor” de las dos:

/*---------------------------*/
/*  Ejemplo en C nº 47:      */
/*  C047.C                   */
/*                           */
/*  Comparar dos cadenas (2) */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
#include <string.h>
 
main()
{
    char texto1[40], texto2[40];
    int comparacion;
 
    printf("Introduce una palabra: ");
    gets(texto1);
 
    printf("Introduce otra palabra: ");
    gets(texto2);
 
    comparacion = strcmp(texto1, texto2);
 
    if (comparacion==0)
        printf("Son iguales\n");
    else if (comparacion>0)
        printf("La primera palabra es mayor\n");
    else 
        printf("La segunda palabra es mayor\n");
}
 

Ejercicio propuesto:

5.2.7. Otras funciones de cadenas: sprintf, sscanf, strstr, …

Hay dos posibilidades más de las cadenas de texto que merece la pena comentar. Son las que nos ofrecen las funciones “sprintf” y “sscanf”:

La funcion “sprintf” crea una cadena de texto a partir de una especificación de formato y unos ciertos parámetros, al igual que hace “printf”, pero la diferencia está en que “printf” manda su salida a la pantalla, mientras que “sprintf” la deja guardada en una cadena de texto.

Por ejemplo, si escribimos

printf(”El número %d multiplicado por 2 vale %d\n”, 50, 50*2);

En pantalla aparecerá escrito

El número 50 multiplicado por 2 vale 100

Pues bien, si tenemos una cadena de texto que hayamos definido (por ejemplo) como char cadena[100] y escribimos

sprintf(cadena,”El número %d multiplicado por 2 vale %d\n”, 50, 50*2);

Esta vez en pantalla no aparece nada escrito, sino que “cadena” pasa a contener el texto que antes habíamos mostrado. Ahora ya podríamos escribir este texto con:

puts(cadena);

o bien con

printf(”%s”, cadena);

¿Qué utilidad tiene esta orden? Nos puede resultar cómoda cuando queramos formatear texto que no vaya a aparecer directamente en pantalla de texto, sino que lo vayamos a enviar a un fichero, o que queramos mostrar en pantalla gráfica, o enviar a través de una red mediante “sockets”, por ejemplo.

Por otra parte “sscanf” es similar a “scanf”, con la diferencia de que los valores para las variables no se leen desde el teclado, sino desde una cadena de texto

strcpy(cadena, "20 30");
sscanf(cadena, "%d %d", &primerNum, &segundoNum);

Nota: sscanf devuelve el número de valores que realmente se han detectado, de modo que podemos comprobar si ha tomado todos los que esperábamos o alguno menos (porque el usuario haya tecleado menos de los que esperábamos o porque alguno esté tecleado incorrectamente).

if (sscanf(cadena, "%d %d", &primerNum, &segundoNum)<2)
printf("Debia teclear dos numeros");

Ejercicio propuesto: Un programa que pida tu nombre, tu día de nacimiento y tu mes de nacimiento y lo junte todo en una cadena, separando el nombre de la fecha por una coma y el día del mes por una barra inclinada, así: “Juan, nacido el 31/12”.

Una tercera orden que puede resultar útil más de una vez es “strstr”. Permite comprobar si una cadena contiene un cierto texto. Devuelve NULL (un valor especial, que nos encontraremos cada vez más a partir de ahora) si no la contiene, y otro valor (no daremos más detalles por ahora sobre qué tipo de valor ni por qué) en casi de que sí la contenga:

if (strstr (frase, "Hola ") == NULL)
printf("No has dicho la palabra Hola ");

Nota: estas no son todas las posibilidades que tenemos para manipular cadenas, pero posiblemente sí son las más habituales. Hay otras que nos permiten buscar una letra dentro de una cadena (strchr), una cadena dentro de otra cadena (strstr), “dar la vuelta” a una cadena (strrev), etc. Según el compilador que usemos, podemos tener incluso funciones ya preparadas para convertir una cadena a mayúsculas (strupr) o a minúsculas (strlwr).

5.2.8. Valor inicial de una cadena de texto

Podemos dar un valor inicial a una cadena de texto, usando dos formatos distintos:

El formato “clásico” para dar valores a tablas:

char nombre[50]= {'J','u','a','n'};

O bien un formato más compacto:

char nombre[50]="Juan";

Pero cuidado con este último formato: hay que recordar que sólo se puede usar cuando se declara la variable, al principio del programa. Si ya estamos dentro del programa, deberemos usar necesariamente la orden “strcpy” para dar un valor a una cadena de texto.

5.3. Tablas bidimensionales

Podemos declarar tablas de dos o más dimensiones. Por ejemplo, si queremos guardar datos de dos grupos de alumnos, cada uno de los cuales tiene 20 alumnos, tenemos dos opciones:

> Podemos usar int datosAlumnos[40] y entonces debemos recordar que los 20 primeros datos corresponden realmente a un grupo de alumnos y los 20 siguientes a otro grupo.
> O bien podemos emplear int datosAlumnos[2][20] y entonces sabemos que los datos de la forma datosAlumnos[0][i] son los del primer grupo, y los datosAlumnos[1][i] son los del segundo.

En cualquier caso, si queremos indicar valores iniciales, lo haremos entre llaves, igual que si fuera una tabla de una única dimensión. Vamos a verlo con un ejemplo de su uso: 

/*---------------------------*/
/*  Ejemplo en C nº 48:      */
/*  C048.C                   */
/*                           */
/*  Array de dos dimensiones */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
 
 
main() 
{      
  int notas[2][10] = 
     { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
       11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };
 
  printf("La nota del tercer alumno del grupos 1 es %d",
    notas[0][2]);
}
 

Este tipo de tablas son las que se usan también para guardar matrices, cuando hay que resolver problemas matemáticos más complejos.

También podemos usar arrays de dos dimensiones si queremos guardar una lista de cadenas de texto, como en este ejemplo:

/*---------------------------*/
/*  Ejemplo en C nº 49:      */
/*  C049.C                   */
/*                           */
/*  Array de cadenas         */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
 
main() 
{      
  char mensajeError[5][80] = {
    "Fichero no encontrado",
    "El fichero no se puede abrir para escritura",
    "El fichero está vacío",
    "El fichero contiene datos de tipo incorrecto"
    "El fichero está siendo usado"
    };
 
  printf("El segundo mensaje de error es: %s",
    mensajeError[1]);
}
 

Ejercicios propuestos :

5.4. Arrays indeterminados.

Si damos un valor inicial a un array, no será necesario que indiquemos su tamaño, porque el compilador lo puede saber contando cuantos valores hemos detallado, así:

int punto[] = {10, 0, -10}; 
  char saludo[ ] = "hola";
  char mensajes[][80] = {"Bienvenido", "Hasta otra"};

Ejercicios propuestos:

5.5. Estructuras

5.5.1. Definición y acceso a los datos

Un registro es una agrupación de datos, los cuales no necesariamente son del mismo tipo. Se definen con la palabra “struct”.

Para acceder a cada uno de los datos que forman el registro, tanto si queremos leer su valor como si queremos cambiarlo, se debe indicar el nombre de la variable y el del dato (o campo) separados por un punto:

/*---------------------------*/
/*  Ejemplo en C nº 50:      */
/*  C050.C                   */
/*                           */
/*  Registros (struct)       */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
 
main()
{
  struct 
  {
    char  inicial;
    int   edad;
    float nota;
  } persona;
 
  persona.inicial = 'J';
  persona.edad = 20;
  persona.nota = 7.5;
  printf("La edad es %d", persona.edad);
}
 

Como es habitual en C, para declarar la variable hemos indicado primero el tipo de datos (struct { ...} ) y después el nombre que tendrá esa variable (persona).

También podemos declarar primero cómo van a ser nuestros registros, y más adelante definir variables de ese tipo: 

/*---------------------------*/
/*  Ejemplo en C nº 51:      */
/*  C051.C                   */
/*                           */
/*  Registros (2)            */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
 
struct datosPersona 
{
  char  inicial;
  int   edad;
  float nota;
};
 
main()
{
  struct datosPersona ficha;
 
  ficha.inicial = 'J';
  ficha.edad = 20;
  ficha.nota = 7.5;
  printf("La edad es %d", ficha.edad);
}
 

Ejercicios propuestos:

5.5.2. Arrays de estructuras

Hemos guardado varios datos de una persona. Se pueden almacenar los de varias personas si combinamos el uso de los “struct” con las tablas (arrays) que vimos anteriormente. Por ejemplo, si queremos guardar los datos de 100 alumnos podríamos hacer:

struct
{ 
  char inicial; 
  int edad; 
  float nota; 
} alumnos[100]; 
 

La inicial del primer alumno sería “alumnos[0].inicial”, y la edad del último sería “alumnos[99].edad”.

Ejercicios propuestos:

 

5.5.3. Estructuras anidadas

Podemos encontrarnos con un registo que tenga varios datos, y que a su vez ocurra que uno de esos datos esté formado por varios datos más sencillos. Para hacerlo desde C, incluiríamos un “struct” dentro de otro, así:

/*---------------------------*/
/*  Ejemplo en C nº 52:      */
/*  C052.C                   */
/*                           */
/*  Registros anidados       */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
 
struct fechaNacimiento 
{
  int  dia;
  int  mes;
  int anyo;
};
 
 
struct 
{
  char  inicial;
  struct fechaNacimiento diaDeNacimiento;
  float nota;
} persona;
 
main()
{
  persona.inicial = 'I';
  persona.diaDeNacimiento.mes = 8;
  persona.nota = 7.5;
  printf("La nota es %f", persona.nota);
}
 

Ejercicios propuestos:

 

5.6 Ejemplo completo

Vamos a hacer un ejemplo completo que use tablas (“arrays”), registros (“struct”) y que además manipule cadenas.

La idea va a ser la siguiente: Crearemos un programa que pueda almacenar datos de hasta 1000 ficheros (archivos de ordenador). Para cada fichero, debe guardar los siguientes datos: Nombre del fichero (max 40 letras), Tamaño (en KB, número de 0 a 2.000.000.000). El programa mostrará un menú que permita al usuario las siguientes operaciones:

1- Añadir datos de un nuevo fichero
2- Mostrar los nombres de todos los ficheros almacenados
3- Mostrar ficheros que sean de más de un cierto tamaño (por ejemplo, 2000 KB).
4- Ver todos los datos de un cierto fichero (a partir de su nombre)
5- Salir de la aplicación (como todavía no sabemos almacenar los datos, éstos se perderán).

No debería resultar difícil. Vamos a ver directamente una de las formas en que se podría plantear y luego comentaremos alguna de las mejoras que se podría (incluso se debería) hacer.

Una opción que podemos a tomar para resolver este problema es la de contar el número de fichas que tenemos almacenadas, y así podremos añadir de una en una. Si tenemos 0 fichas, deberemos almacenar la siguiente (la primera) en la posición 0; si tenemos dos fichas, serán la 0 y la 1, luego añadiremos en la posición 2; en general, si tenemos “n” fichas, añadiremos cada nueva ficha en la posición “n”. Por otra parte, para revisar todas las fichas, recorreremos desde la posición 0 hasta la n-1, haciendo algo como

for (i=0; i<=n-1; i++) { ... más órdenes ...}

o bien algo como

for (i=0; i<n; i++) { ... más órdenes ...}

El resto del programa no es difícil: sabemos leer y comparar textos y números. Sólo haremos tres consideraciones:

Con todo esto, nuestro fuente quedaría así:

/*---------------------------*/
/*  Ejemplo en C nº 53:      */
/*  C053.C                   */
/*                           */
/*  Tabla con muchos struct  */
/*  y menu para manejarla    */
/*                           */
/*  Curso de C,              */
/*    Nacho Cabanes          */
/*---------------------------*/
 
#include <stdio.h>
#include <string.h>
 
struct{
   char nombreFich[41];     /* Nombre del fichero */
   unsigned long tamanyo;   /* El tamaño en bytes */
} fichas[1000];
 
int numeroFichas=0;  /* Número de fichas que ya tenemos */
int i;               /* Para bucles */
 
int opcion;          /* La opcion del menu que elija el usuario */
 
char textoTemporal[40]; /* Para cuando preguntemos al usuario */
unsigned long numeroTemporal;
 
main()
{ 
  do {
    /* Menu principal */
    printf("Escoja una opción:\n");
    printf("1.- Añadir datos de un nuevo fichero\n");
    printf("2.- Mostrar los nombres de todos los ficheros\n");
    printf("3.- Mostrar ficheros que sean de mas de un cierto tamaño\n");
    printf("4.- Ver datos de un fichero\n");
    printf("5.- Salir\n");
 
    /* Para evitar problemas con datos mal introducidos,
       leemos con "gets" y luego lo filtramos con "sscanf" */
    gets (textoTemporal);
    sscanf(textoTemporal, "%d", &opcion);
 
    /* Hacemos una cosa u otra según la opción escogida */
    switch(opcion){
       case 1: /* Añadir un dato nuevo */
               if (numeroFichas < 1000) {  /* Si queda hueco */
                 printf("Introduce el nombre del fichero: ");
                 gets(fichas[numeroFichas].nombreFich);
                 printf("Introduce el tamaño en KB: ");
                 gets(textoTemporal);
                 sscanf(textoTemporal,"%ld",&fichas[numeroFichas].tamanyo);
                 /* Y ya tenemos una ficha más */
                 numeroFichas++;
               } else   /* Si no hay hueco para más fichas, avisamos */
                 printf("Máximo de fichas alcanzado (1000)!\n");
               break;
       case 2: /* Mostrar todos */
               for (i=0; i<numeroFichas; i++) 
                  printf("Nombre: %s; Tamaño: %ld Kb\n",
                    fichas[i].nombreFich, fichas[i].tamanyo);
               break;
       case 3: /* Mostrar según el tamaño */
               printf("¿A partir de que tamaño quieres que te muestre?");
               gets(textoTemporal);
               sscanf(textoTemporal, "%ld", &numeroTemporal);
               for (i=0; i<numeroFichas; i++)
                 if (fichas[i].tamanyo >= numeroTemporal)
                    printf("Nombre: %s; Tamaño: %ld Kb\n",
                      fichas[i].nombreFich, fichas[i].tamanyo);
               break;
       case 4: /* Ver todos los datos (pocos) de un fichero */
               printf("¿De qué fichero quieres ver todos los datos?");
               gets(textoTemporal);
               for (i=0; i<numeroFichas; i++) 
                 if (strcmp(fichas[i].nombreFich, textoTemporal) == 0)
                    printf("Nombre: %s; Tamaño: %ld Kb\n",
                      fichas[i].nombreFich, fichas[i].tamanyo);
               break;
       case 5: /* Salir: avisamos de que salimos */
               printf("Fin del programa\n"); 
               break;
       default: /* Otra opcion: no válida */
               printf("Opción desconocida!\n"); 
               break;
       }
   } while (opcion != 5);  /* Si la opcion es 5, terminamos */
}
 

Funciona, y hace todo lo que tiene que hacer, pero es mejorable. Por supuesto, en un caso real es habitual que cada ficha tenga que guardar más información que sólo esos dos apartados de ejemplo que hemos previsto esta vez. Si nos muestra todos los datos en pantalla y se trata de muchos datos, puede ocurrir que aparezcan en pantalla tan rápido que no nos dé tiempo a leerlos, así que sería deseable que parase cuando se llenase la pantalla de información (por ejemplo, una pausa tras mostrar cada 25 datos). Por supuesto, se nos pueden ocurrir muchas más preguntas que hacerle sobre nuestros datos. Y además, cuando salgamos del programa se borrarán todos los datos que habíamos tecleado, pero eso es lo único “casi inevitable”, porque aún no sabemos manejar ficheros.

 

Ejercicios propuestos:

 

5.7 Ordenaciones simples

Es muy frecuente querer ordenar datos que tenemos en un array. Para conseguirlo, existen varios algoritmos sencillos, que no son especialmente eficientes, pero son fáciles de programar. La falta de eficiencia se refiere a que la mayoría de ellos se basan en dos bucles “for” anidados, de modo que en cada pasada quede ordenado un dato, y se dan tantas pasadas como datos existen, de modo que para un array con 1.000 datos, podrían llegar a tener que hacerse un millón de comparaciones.

 

Existen ligeras mejoras (por ejemplo, cambiar uno de los “for” por un “while”, para no repasar todos los datos si ya estaban parcialmente ordenados), así como métodos claramente más efectivos, pero más difíciles de programar, alguno de los cuales veremos más adelante.

 

Veremos tres de estos métodos simples de ordenación, primero mirando la apariencia que tiene el algoritmo, y luego juntando los tres en un ejemplo que los pruebe:

 

Método de burbuja

(Intercambiar cada pareja consecutiva que no esté ordenada) 


Para i=1 hasta n-1
    Para j=i+1 hasta n
        Si A[i] > A[j]
          Intercambiar ( A[i], A[j])
(Nota: algunos autores hacen el bucle exterior creciente y otros decreciente, así:) 

Para i=n descendiendo hasta 1
    Para j=2 hasta i
        Si A[j-1] > A[j]
          Intercambiar ( A[j-1], A[j])

Selección directa

(En cada pasada busca el menor, y lo intercambia al final de la pasada) 


Para i=1 hasta n-1 
    menor = i
    Para j=i+1 hasta n 
        Si A[j] < A[menor]
            menor = j
    Si menor <> i
        Intercambiar ( A[i], A[menor])

Inserción directa

(Comparar cada elemento con los anteriores -que ya están ordenados- y desplazarlo hasta su posición correcta). 


Para i=2 hasta n
      j=i-1
      mientras (j>=1) y (A[j] > A[j+1])
          Intercambiar ( A[j], A[j+1])
          j = j - 1

(Es mejorable, no intercambiando el dato que se mueve con cada elemento, sino sólo al final de cada pasada, pero no entraremos en más detalles).

 

Ejercicios propuestos: