Desarrollo de Drones?

Su construcción se ha realizado y su aplicación es grande, desde robots que nos entregan las compras, hasta robots con fines bélicos

Raspberri Pi?

La computadora más barata del mercado y sus diferentes aplicaciones como una excelente herramienta de desarrollo mecatrónico

PROGRAMACIÓN

El desarrollo de excelentes proyectos depende muchísimo de las habilidades de programación del diseñador, un mecatrónico debe conocerlas todas...

INSOMNIO DEL ESTUDIANTE

Para estudiar cualquier tipo de ingeniería debes estar preparado para acostumbrarte al desvelo, con un mínimo de 2 a tres horas al día de descanso es suficiente, animos a todos!!!

ARDUINO GEEK

Proyectos desarrollados en Arduino, su interfaz con Simulink, y union con otras tarjetas o shields para cumplir los objetivos del robot

Mostrando entradas con la etiqueta C. Mostrar todas las entradas
Mostrando entradas con la etiqueta C. Mostrar todas las entradas

martes, 25 de febrero de 2014

Estilo de Programación en el Lenguaje C (Extras)


Trataremos de dar unas breves indicaciones acerca de cuál es la forma más correcta de programar. Qué aspecto dar al código fuente para que sea más legible y elegante, cómo distribuir el código fuente, etc

Aspecto del código

Obsérvese el siguiente código:

#include <stdio.h>
int main(void){ char cadena[20]; printf("Introduce una cadena:"
);
gets(cadena);printf("Has escrito: %s",cadena);return 0;}

Ahora compárese con este otro:

#include <stdio.h>

int main(void)
{
 char cadena[20];

 printf( "Introduce una cadena:" );
 gets(cadena);
 printf("Has escrito: %s",cadena);

 return 0;
}

Parece claro que la segunda es más conveniente. Desde luego no es la única forma, ni la más correcta; es, simplemente, un estilo. Cada uno tiene su estilo personal, aunque conviene que tampoco sea 'muy personal', si es para compartirlo. Otra forma muy habitual es poner '{' justo después de la función:

#include <stdio.h>

int main(void){
 char cadena[20];

 printf( "Introduce una cadena:" );
 gets(cadena);
 printf("Has escrito: %s",cadena);

 return 0;
 }

Los comentarios

El código fuente debe estar bien documentado, de tal forma que si se lo pasamos a otra persona pueda entenderlo sin grandes dificultades. Quizá se piense: "mi código es mío y nunca se lo voy a dejar a nadie, así que para que voy a comentarlo". Parece lógico, pero imagínese que se abandona temporalmente y en el futuro se quiere retocar el programa. Es muy probable el olvido de por qué se hizo tal o cual cosa, (pasa muy a menudo) y es preciso gastar un montón de tiempo descifrando algo que en su día estaba entendido perfectamente.

Aquí está un ejemplo de un programa mal comentado:

#include <stdio.h>

int main(void)  /* declaro la función main */
{  /* Abro llaves */
 char cadena[20];   /* declaro una variable llamada cadena */

 printf( "Introduce una cadena:" );  /* Imprimo el mensaje 'Introduce una cadena */
 gets(cadena);   /* pregunto por el valor de cadena */
 printf("has escrito: %s",cadena);   /* muestro el valor que han introducido */

 return 0;  /* hago que el programa devuelva el valor 0;
}  /* cierro llaves */

Estos comentarios están bien si el código forma parte de algún curso, pero no de un programa de uso habitual. Todo el mundo (que lleva un tiempo programando en C) sabe que con int main (void) se declara una función y que conchar cadena[20] se declara una variable.

Los comentarios deben decirnos qué es lo que hace el programa, para qué sirven las variables y explicar las partes críticas o confusas del programas. Algo mas correcto sería:

/* Programa ejemplo creado para el curso de C */

#include <stdio.h>

int main(void)
{
 char cadena[20];  /* En la variable cadena se almacenará el valor a introducir */

 printf( "Introduce una cadena:" );
 gets(cadena);
 printf("has escrito: %s",cadena);

 return 0;
}

Este programa es tan sencillo que no tiene puntos oscuros para comentar.

Es importante indicar para qué se van a usar las variables. Cuando tengamos muchas y pase el tiempo es difícil descifrar para que era cada una.

Los nombres de las variables

Cuando hacemos un programa con prisas o por no pensar mucho damos a las variables cualquier nombre. Supongamos un programa con una sección de declaración de variables como la que sigue:

 int i, j, k;
 double x1, x2, x3, x4;
 char a, b;
 /* ... muchas más variables */

¿Cómo podemos acordarnos al cabo de un tiempo de qué era cada variable?. Por eso es conveniente que aparte de indicar para qué sirve cada variable les demos nombres descriptivos:

 int cuenta_x, cuenta_y, cuenta_z;  /* Nº de posiciones x, y, z */
 double x_minimo, x_maximo, 
        y_minimo, y_maximo;    /* Esquinas del rectángulo */
 char tecla_inicio, tecla_fin;    /* Pulsaciones de comienzo y fin */
 /* ... etc */

Puertos y memoria en el Lenguaje C


Para intercambiar información con dispositivos exteriores, el computador utiliza los puertos de entrada y salida (E/S). Estos puertos se caracterizan por la dirección que tienen asignada en el mapa de memoria, y es posible la comunicación con los mismos enviando o recogiendo bytes a/en dicha dirección.

Las funciones de biblioteca que proporciona C para la manipulación de estos puertos son fuertemente dependientes del hardware y del sistema operativo y, por tanto, no demasiado estándar. Así, nos centraremos ahora en las funciones de acceso a los puertos hardware que proporciona TurboC bajo entornos DOS.

Al igual que en determinadas circunstancias es preciso comunicarse con dispositivos externos, también es necesario intercambiar información con el propio PC. Ello se realiza con frecuencia leyendo y escribiendo valores en/a determinadas posiciones de la memoria del mismo. Por ejemplo, podemos conocer el estado en el que se encuentra el teclado del PC sin más que acceder al valor almacenado en el segmento 0x40,offset 0x17 de la memoria. Con él podemos discernir si la tecla "bloq mayús" está pulsada o no, si la tecla "Alt" está pulsada o no, etc. Asimismo, podemos recoger información del hardware actualmente instalado en el PC y, entre otras cosas, determinar en qué direcciones de E/S se hallan los puertos hardwaremencionados en el párrafo anterior.

Como antes, las funciones de biblioteca que proporciona C para el acceso a la memoria no siguen un estándar determinado, y nos concentraremos en las que proporciona TurboC bajo entorno DOS.

Acceso a los puertos hardware
  • Lectura del puerto
  • Escritura en el puerto
Lectura del puerto

Para recoger información procedente de un puerto hardware (lectura del puerto), TurboC proporciona las funciones inport e inportb. Son muy similares; la única diferencia radica en que inportb lee un byte cada vez mientras que inport lee una palabra (2 bytes).

Estas funciones se declaran de la siguiente manera:
int inport(int puerto_dir);
nsigned char inportb(int puerto_dir);
u
donde:
puerto_dir es la dirección del puerto hardware de la cual se quiere leer.
y devuelven un dato de tipo int (2 bytes) o de tipo unsigned char (1 byte), respectivamente..

NOTAS:
  • inport trabaja como la instrucción IN del microprocesador 80x86. Lee el byte bajo de la palabra desde puerto_dir y el byte alto desde puerto_dir+2.
  • inportb es una macro que lee un byte.
Estas funciones se hallan definidas en el archivo de cabecera DOS.H. Si se hace una llamada a inportbdesde programa habiendo incluido este archivo, es tratada como macro y expandida como código inline. Si no se incluye DOS.H, se obtiene la función del mismo nombre.
En el siguiente ejemplo vamos a obtener un byte del puerto paralelo (bidireccional) instalado en el PC (en la dirección de E/S 378h):

#include <stdio.h>
#include <dos.h>

main()
{
unsigned char valor;
int puerto = 0x378; /* dirección del puerto paralelo */

valor = inportb(puerto);
printf("Byte leído del puerto %d = 0x%X\n", puerto, valor);
}

Escritura en el puerto

Para enviar información a un puerto hardware (escritura en el puerto), TurboC proporciona las funcionesoutport e outportb. Son muy similares; la única diferencia radica en que outportb envía un byte cada vez mientras que outport envía una palabra (2 bytes).

Estas funciones se declaran de la siguiente manera:
void outport(int puerto_dir, int valor);

void outportb(int puerto_dir, unsigned char valor);
donde:
  • puerto_dir es la dirección del puerto hardware en la cual se quiere escribir;
  • valor es el byte o la palabra que se envía al puerto.
y no retornan ningún valor.

NOTAS:
  • outport trabaja como la instrucción OUT del microprocesador 80x86. Escribe el byte bajo de valoren puerto_dir y el byte alto en puerto_dir+2.
  • outportb es una macro que lee un byte.
Estas funciones se hallan definidas en el archivo de cabecera DOS.H. Si se hace una llamada a outportbdesde programa habiendo incluido este archivo, es tratada como macro y expandida como código inline. Si no se incluye DOS.H, se obtiene la función del mismo nombre.
En el siguiente ejemplo vamos a enviar la letra C al primer puerto paralelo bidireccional instalado en el PC (en la dirección de E/S 378h):

#include <stdio.h>
#include <dos.h>

main()
{
unsigned char valor = 'C' ;
int puerto = 0x378; /* dirección del puerto paralelo */

outportb(puerto, valor);
printf("Valor %c enviado al puerto %d\n", valor, puerto);
}

Acceso a la memoria:
  • Lectura de la memoria
  • Escritura en la memoria
Lectura de la memoria

Para leer la información almacenada en la memoria, TurboC proporciona las funciones peek y peekb. Ambas devuelven el valor almacenado en la posición designada por segmento:offset (direccionamiento segmentado de la memoria). La única diferencia radica en que peekb devuelve un byte, mientras que peek devuelve una palabra (2 bytes).

Estas funciones se declaran de la siguiente manera:

int peek(unsigned segmento, unsigned offset);

char peekb(unsigned segmento, unsigned offset);

y devuelven un dato de tipo int (2 bytes) o de tipo char (1 byte), respectivamente..
NOTA: Estas funciones se hallan definidas en el archivo de cabecera DOS.H. Si se hace una llamada apeek o a peekb desde programa habiendo incluido este archivo, son tratadas como macros y expandidas como código inline. Si no se incluye DOS.H, se obtienen las funciones del mismo nombre.
Como ejemplo, veamos cómo se determina cuántos puertos paralelo se hallan instalados en un PC, y qué direcciones de E/S tienen asignadas. Para ello, es preciso leer en la posición de memoria 40h:8h una tabla de 3 palabras de 16 bits que contienen las direcciones de los puertos paralelo presentes en el sistema:

#include <stdio.h>
#include <dos.h>

main()
{
 unsigned int puerto;  /* número de puerto paralelo: 
     0 (LPT1), 1 (LPT2), 2 (LPT3)*/
 unsigned int puerto_dir; /* dirección del puerto */

 /* Determina los puertos paralelo instalados y sus direcciones E/S */
 for (puerto=0; puerto < 3; puerto++) {
puerto_dir = peek(0x0040,0x0008 + puerto*2);
if (puerto_dir == 0)
   printf("No hay puerto asignado a LPT%d \n", puerto+1);
  else
   printf("La dirección de LPT%d es 0x%X\n", puerto+1, puerto_dir);
 }
}

Escritura en la memoria

Para almacenar un dato en la posición de memoria designada por segmento:offset, TurboC proporciona las funciones poke y pokeb. pokeb almacena un carácter (1 byte) mientras que poke almacena un entero (2 bytes).

Estas funciones no retornan ningún valor y se declaran de la siguiente manera:
void poke(unsigned segmento, unsigned offset, int valor);

void pokeb(unsigned segmento, unsigned offset, char valor);
NOTA: Estas funciones se hallan definidas en el archivo de cabecera DOS.H. Si se hace una llamada apoke o a pokeb desde programa habiendo incluido este archivo, son tratadas como macros y expandidas como código inline. Si no se incluye DOS.H, se obtienen las funciones del mismo nombre.
Como ejemplo, veamos cómo se fuerza por software la activación de "Scroll Lock". Para ello hay que almacenar el valor 16 en la posición 40h:17h, lugar de las variables de la BIOS donde residen los banderines de estado del teclado:

#include <stdio.h>
#include <conio.h>
#include <dos.h>

main()
{
 printf("Asegúrese de que \"Scroll Lock\" está desactivado \
  y pulse cualquier tecla\n");
 getch(); /* toma un carácter de la consola sin hacer eco */

 pokeb(0x0040, 0x0017, 16); /* escribe 16 en 40h:17h */

printf("\"Scroll Lock\" está ahora activo\n");
}

Pre-procesador en Lenguaje C


El preprocesador es una parte del compilador que se ejecuta en primer lugar, cuando se compila un fuente C, y que realiza unas determinadas operaciones, independientes del propio lenguaje C. Estas operaciones se realizan a nivel léxico y consisten en:
  • la inclusión de otros textos en un punto del archivo fuente,
  • la realización de sustituciones, y
  • la eliminación de ciertas partes del código fuente.
Debemos tener en cuenta que el preprocesador trabaja únicamente con el texto del fuente y no tiene en cuenta ningún aspecto sintáctico ni semántico del lenguaje.

Directivas de preprocesado

El control del preprocesador se realiza mediante determinadas directivas incluidas en el fuente. Una directiva es una palabra que interpreta el preprocesador, y siempre va precedida por el símbolo # situado al principio de línea.

La directiva #define se utiliza para definir una macro. Las macros proporcionan principalmente un mecanismo para la sustitución léxica. Una macro se define de la forma

#define identificador secuencia

Cada ocurrencia de identificador en el código fuente es sustituida por secuencia.

#include <stdio.h>

#define TECLA  'A'
#define MENSAJE1 "Se ha pulsado la tecla 'A'\n"
#define MENSAJE2 "No se ha pulsado la letra 'A'\n"


main()
{
 if( getchar() == TECLA )
  printf(MENSAJE1);

 else
  printf(MENSAJE2);
}

Puede definirse una macro sin una secuencia de caracteres, y una macro se puede indefinir mediante la directiva #undef.

El estado de una macro, si está definida o no, se puede comprobar mediante las directivas #ifdef y#ifndef. Estas dos directivas se deben completar con una #endif y, el texto comprendido entre ambas es procesado si la macro está definida. Todas las directivas deben ser completadas en el mismo fuente y pueden ser anidadas.

#ifndef PI /* Comprueba si está definida la macro p */

 #define PI 3.1415927 /* Si no está definida, lo hace */

#endif

El preprocesador nos permite también incluir también otros ficheros en un fuente C. Esto se consigue con la directiva #include. Esta puede tomar tres formas:

#include <fichero>
#include "fichero"
#include macro

La diferencia entre la primera y la segunda está en el lugar dónde se buscará el fichero en cuestión. Normalmente se utiliza la primera para ficheros proporcionados por la biblioteca del compilador, y la segunda, para ficheros creados por el programador.

Constantes simbólicas (con nombre)

Supongamos que tenemos que hacer un programa en el que haya que escribir unas cuantas veces3.1415927. Es muy fácil que nos confundamos alguna vez al escribirlo. Así, al compilar el programa no recibiremos ningún mensaje de error aunque los resultados no serán correctos. Para evitar esto usamos lasconstantes simbólicas o constantes con nombre. No son nada más que un caso particular de la utilización de macros. Al definir una constante simbólica asignamos un nombre a la secuencia 3.1415927, y parece razonable utilizar el nombre PI. Por ejemplo:

#include <stdio.h>

#define PI 3.1415927

main()
{
 int radio, perimetro;

 radio = 20;
 perimetro = 2 * PI * radio;

 
 printf( "El perímetro es: %i", perimetro  );
}

De esta forma cada vez que el compilador encuentre el nombre PI lo sustituirá por 3.1415927.

A una constante no se le puede dar un valor mientras se ejecuta; no se puede hacer PI=20;. Sólo se le puede dar un único valor con #define, y sólo una vez (salvo que se utilice #undef y de nuevo #define). Tampoco podemos usar scanf para dar valores a una constante:

#define CONSTANTE 14

main()
{
 ...
 scanf( "%i", CONSTANTE );
 ...
}

eso equivaldría a:

 scanf( "%i", 14 );

Esto es muy grave, pues estamos diciendo que el valor que escribamos en la entrada de scanf se almacene en la posición 14 de la memoria, lo que puede bloquear el ordenador.

Las constantes se suelen escribir en mayúsculas, sólo se puede definir una constante por fila y no se añade";" al final.

Las constantes nos proporcionan una mejor comprensión del código fuente. Obsérvese el siguiente programa:

#include <stdio.h>

main()
{
 int precio;

 precio = (4 * 25 * 100) * 1.16;
 
 printf( "El precio total es: %i", precio  );
}

¿Quién entiende lo que quiere decir este programa? Es difícil, si no imposible. Hagámoslo de otra forma.

#include <stdio.h>

#define CAJAS   4
#define UNIDADES_POR_CAJA 25
#define PRECIO_POR_UNIDAD  100
#define IMPUESTOS  1.16

main()
{
 int precio;

 precio = (CAJAS * UNIDADES_POR_CAJA * PRECIO_POR_UNIDAD) * IMPUESTOS;
 
 printf( "El precio total es: %i", precio  );
}

Ahora se entiende mucho mejor. Si revisamos el penúltimo programa un tiempo más tarde ya no recordaremos qué significaba cada número. De esta segunda forma nos ponemos al día rápidamente.

También podemos definir una constante usando el valor de otras. Por supuesto, éstas deben estar definidas con anterioridad:

#include <stdio.h>

#define CAJAS   4
#define UNIDADES_POR_CAJA 25
#define PRECIO_POR_UNIDAD 100 
#define PRECIO_POR_CAJA  UNIDADES_POR_CAJA * PRECIO_POR_UNIDAD
#define IMPUESTOS  1.16

main()
{
 int precio;

 precio = ( CAJAS * PRECIO_POR_CAJA ) * IMPUESTOS ;
 
 printf( "El precio total es: %i", precio  );
}

Archivos o ficheros en el Lenguaje C



Los archivos o ficheros brindan una forma de guardar permanentemente los datos y resultados de nuestros programas. 

Es importante indicar que los ficheros no son únicamente los archivos que guardamos en el disco duro. En C todos los dispositivos del ordenador se tratan como ficheros: la impresora, el teclado, la pantalla, etc.

Lectura de archivos. Operaciones y funciones básicas

Para comenzar, vamos a analizar un ejemplo que lee un fichero de texto (origen.txt) y muestra su contenido en la pantalla:

#include <stdio.h>
#include <stdlib.h>

main()
{
 FILE *fichero;
 char letra;

 fichero = fopen("origen.txt","r");
 if (fichero == NULL) {
  printf( "No se puede abrir el fichero.\n" );
  exit( 1 );
 }

 printf( "Contenido del fichero:\n" );
 letra = getc(fichero);
 while (feof(fichero) == 0) {
  printf( "%c",letra );
  letra = getc(fichero);
 }

 if (fclose(fichero)!= 0)
  printf( "Problemas al cerrar el fichero\n" );
}

Analizaremos este ejemplo poco a poco deteniéndonos en:

El puntero FILE
Apertura del fichero para lectura: fopen
Comprobación de fichero abierto
Lectura de caracteres del fichero: getc
Comprobación de fin de fichero: feof
Cierre del fichero: fclose

y, posteriormente, nos referiremos a:
Lectura de líneas del fichero: fgets
La función fread

El puntero FILE *

Todas las funciones de estrada/salida estándar usan este puntero para conseguir información sobre el fichero abierto. Este puntero no apunta al archivo sino a una estructura que contiene información sobre él. Esta estructura incluye entre otras cosas información sobre el nombre del archivo, la dirección de la zona de memoria donde se almacena el fichero, tamaño del buffer.

Apertura del fichero para lectura: fopen

Ahora es preciso abrir el fichero. Para ello usamos la función fopen. Esta función tiene el siguiente formato:

FILE *fopen(const char *nombre_fichero, const char *modo);

En el ejemplo usábamos: fichero = fopen("origen.txt","r");

El nombre de fichero se puede indicar directamente (como en el ejemplo) o usando una variable y se puede abrir de diversas formas. Esto se especifica con el parámetro modo. Los modos posibles son:

rAbre un fichero existente para lectura.
wCrea un fichero nuevo (o borra su contenido si existe) y lo abre para escritura.
aAbre un fichero (si no existe lo crea) para escritura. El puntero se sitúa al final del archivo, de forma que se puedan añadir datos si borrar los existentes.

Se pueden añadir una serie de modificadores siguiendo a los modos anteriores:

bAbre el fichero en modo binario.
tAbre el fichero en modo texto.
+Abre el fichero para lectura y escritura.

Ejemplos de combinaciones:
  • rb+ - Abre el fichero en modo binario para lectura y escritura.
  • w+ - Crea (o lo borra si existe) un fichero para lectura y escritura.
  • rt - Abre un archivo existente en modo texto para lectura.
Comprobación de fichero abierto

Un aspecto muy importante después de intentar abrir un fichero es comprobar si realmente está abierto. El sistema no es infalible y pueden producirse fallos: el fichero puede no existir, estar dañado o no tener permisos de lectura. Si intentamos realizar operaciones sobre un puntero tipoFILE cuando no se ha conseguido abrir el fichero puede haber problemas.

Si el fichero no se ha abierto, el puntero fichero (puntero a FILE) tendrá el valor NULL, si se ha abierto con éxito tendrá un valor distinto de NULL. Por lo tanto, para comprobar si ha habido errores, nos fijamos en el valor del puntero:

 if (fichero == NULL) {
  printf( "No se puede abrir el fichero.\n" );
  exit( 1 );
 }

Si fichero == NULL significa que no se ha podido abrir por alguna causa. Lo más conveniente es salir del programa. Para salir utilizamos la función exit(), donde el argumento 1 indica al sistema operativo que se han producido errores. Esta función precisa del archivo de cabecera stdlib.h.

Lectura de caracteres del fichero: getc

Ahora ya podemos empezar a leer el fichero. Para ello podemos utilizar la función getc, que lee los caracteres uno a uno. Se puede usar también la función getc (son equivalentes: la diferencia es quegetc está implementada como macro). Además de estas dos, existen otras funciones como fgets,fread que leen más de un carácter.

El formato de la función getc (y de fgetc) es:

int getc(FILE *fichero);

En este caso lo usamos como:

 letra = getc( fichero );

Tomamos un carácter de fichero, lo almacenamos en letra y el puntero del fichero se coloca en el siguiente carácter.

Comprobación de fin de fichero: feof

Cuando entramos en el bucle while, la lectura se realiza hasta que se encuentre el final del fichero. La detección del final del fichero se puede llevar a cabo de dos formas:
  • con la función feof
  • comprobando si el valor de letra es EOF (el último carácter de cualquier archivo).
En el ejemplo hemos usado la función feof. Esta función es de la forma:

int feof(FILE *fichero);

Esta función comprueba si se ha llegado al final de fichero, en cuyo caso devuelve un valor distinto de 0. Si no se ha llegado al final de fichero devuelve un cero. Por eso lo usamos del siguiente modo:

 while ( feof(fichero) == 0 )

o

 while ( !feof(fichero) )

La segunda forma que comentaba arriba consiste en comprobar si el carácter leído es el de fin de fichero EOF:

 while ( letra != EOF )



Sin embargo, cuando trabajamos con ficheros de texto no hay ningún problema, pero si estamos manejando un fichero binario podemos encontrarnos EOF antes del fin de fichero. Por eso es preferible usar feof.

Cierre del fichero: fclose

Una vez realizadas todas las operaciones deseadas sobre el fichero hay que cerrarlo. Es importante no olvidar este paso pues el fichero podría corromperse. Al cerrarlo se vacían los buffers y se guarda el fichero en disco. Un fichero se cierra mediante la función fclose. Esta función tiene el siguiente formato:

FILE *fclose(FILE * stream);

Aquí stream es el puntero a FILE devuelto por fopen cuando el archivo se abrió. Si todo va bien, devuelve un cero, si hay problemas, devuelve otro valor. Estos problemas se pueden producir si el disco está lleno, por ejemplo

 if (fclose(fichero)!= 0)
         printf( "Problemas al cerrar el fichero\n" );

Lectura de líneas del fichero: fgets

Esta función es muy útil para leer líneas completas desde un fichero. Su formato es:

char *fgets(char *buffer, int longitud_max, FILE *fichero);

Esta función lee desde el fichero hasta que encuentra un carácter '\n' o hasta que leelongitud_max-1 caracteres y añade '\0' al final de la cadena (y retiene el carácter '\n'). La cadena leída la almacena en buffer. Si se encuentra EOF antes de leer ningún carácter, o si se produce un error, la función devuelve NULL; en caso contrario devuelve la dirección de buffer.

#include <stdio.h>
#include <stdlib.h>

main()
{
 FILE *fichero;
 char texto[100];

 fichero = fopen("origen.txt","r");
 if (fichero == NULL) {
  printf( "No se puede abrir el fichero.\n" );
  exit( 1 );
 }

 printf( "Contenido del fichero:\n" );
 fgets(texto,100,fichero);
 while (feof(fichero) == 0) {
  printf( "%s",texto );
  fgets(texto,100,fichero);
 }

 if (fclose(fichero)!=0)
  printf( "Problemas al cerrar el fichero\n" );
}

La función fread

Esta función se tratará posteriormente, junto con la función fwrite. Ambas permiten guardar y leer, respectivamente, cualquier tipo de dato, incluso estructuras.

Escritura de archivos. Operaciones y funciones básicas

Vamos a completar ahora la parte que faltaba en la sección anterior: escribir en un fichero. Vamos a hacerlo de nuevo mediante un ejemplo. En éste, abrimos un fichero origen.txt y lo copiamos en otro destino.txt. Además, el fichero se muestra en pantalla (las partes nuevas se han destacado en negrita).

#include <stdio.h>

main()
{
 FILE *origen, *destino;
 char letra;

 origen = fopen("origen.txt","r");
 destino= fopen("destino.txt","w");
 if (origen == NULL || destino == NULL) {
  printf( "Problemas con la apertura de los ficheros.\n" );
  exit( 1 );
 }

 letra = getc(origen);
 while (feof(origen) == 0) {
  putc(letra, destino);
  printf( "%c",letra );
  letra = getc(origen);
 }

 if (fclose(origen)!= 0)
  printf( "Problemas al cerrar el fichero origen.txt\n" );
 if (fclose(destino)!= 0)
  printf( "Problemas al cerrar el fichero destino.txt\n" );
}

Como en el caso de la lectura de archivos, analizaremos este ejemplo poco a poco deteniéndonos en:
  • El puntero FILE
  • Apertura del fichero para escritura: fopen
  • Escritura de caracteres en el fichero: putc
  • Comprobación de fin de fichero
  • Cierre del fichero: fclose
y, posteriormente, nos referiremos a:
  • Escritura de líneas en el fichero: fputs
  • La función fwrite
El puntero FILE *

Como hemos visto en antes, el puntero FILE es la base de la escritura/lectura de archivos. Por eso definimos dos punteros FILE:
  • el puntero origen donde vamos a almacenar la información sobre el fichero origen.txt, y
  • destino donde guardamos la del fichero destino.txt (el nombre del puntero no tiene por qué coincidir con el de fichero).
Apertura del fichero para escritura: fopen

El siguiente paso, como antes, es abrir el fichero usando fopen. La diferencia es que ahora tenemos que abrirlo en modo escritura. Usamos el modo w (crea el fichero, o lo vacía si existe) porque queremos crear un fichero. Recordemos que después de abrir un fichero hay que comprobar si la operación se ha realizado con éxito. En este caso, como es un sencillo ejemplo, hemos comprobado ambos a la vez:
if (origen==NULL || destino==NULL)

pero es más correcto hacerlo por separado, de modo que separemos la posible causa del fallo.

Escritura de caracteres en el archivo: putc

Como se puede observar en el ejemplo, la lectura del fichero se hace igual que antes, con getc. Para la escritura usamos la función putc:, cuya sintaxis es:
int putc(int c, FILE *fichero);


donde c contiene el carácter que queremos escribir en el fichero y el puntero fichero es el fichero sobre el que trabajamos.

En este caso lo usamos como:

 putc(letra, destino);

De esta forma vamos escribiendo en el fichero destino.txt el contenido del fichero origen.txt.

Comprobación fin de fichero

Como siempre que leemos datos de un fichero debemos comprobar si hemos llegado al final. Sólo debemos comprobar si estamos al final del fichero que leemos. No tenemos que comprobar el final del fichero en el que escribimos puesto que lo estamos creando y aún no tiene final.

Cierre del fichero: fclose

Y, por fin, lo que nunca debemos olvidar al trabajar con ficheros: cerrarlos. Debemos cerrar tanto los ficheros que leemos como aquellos sobre los que escribimos.

Escritura de líneas en el fichero: fputs

La función fputs trabaja junto con la función fgets . La sintaxis es:

int fputs(const char *cadena, FILE *fichero);

Esta función escribe en el fichero una cadena y no le añade un carácter '\n' ni el terminador de cadena '\0'. Devuelve el último carácter escrito o EOF si se produce un error.

Veamos un ejemplo en el que se escriben tres líneas de texto al fichero y después se muestra su contenido.

#include <stdio.h>
#include <stdlib.h>

main()
{
 FILE *fichero;
 char texto[100];

 fichero = fopen("destino.txt","w");
 if (fichero == NULL) {
  printf( "No se puede crear el fichero.\n" );
  exit( 1 );
 }

 /* Escribe en el fichero */
 fputs("Esta es la primera línea del fichero\n", fichero);
 fputs("Esta es la segunda línea\n", fichero);
 fputs("Esta es la última línea del fichero\n", fichero);

 if (fclose(fichero)!=0)
  printf( "Problemas al cerrar el fichero\n" );

 fichero = fopen("destino.txt","r");
 if (fichero == NULL) {
  printf( "No se puede crear el fichero.\n" );
  exit( 1 );
 }
 printf( "Contenido del fichero:\n" );
 fgets(texto,100,fichero);
 while (feof(fichero) == 0) {
  printf( "%s",texto );
  fgets(texto,100,fichero);
 }

 if (fclose(fichero)!=0)
  printf( "Problemas al cerrar el fichero\n" );
}

fwrite

Esta función se tratará posteriormente, junto con la función fread. Ambas permiten leer y guardar, respectivamente, cualquier tipo de dato, incluso estructuras.

Otras funciones para el manejo de ficheros
  • Lectura y escritura genéricas: fread y fwrite
  • Posicionamiento en el fichero: fseek y ftell
  • fprintf y fscanf
Lectura y escritura genéricas: fread y fwrite

Las funciones que hemos visto anteriormente (getc, putc, fgets, fputs) son adecuadas para trabajar con caracteres (1 byte) y cadenas. Pero, ¿qué sucede cuando queremos trabajar con otros tipos de datos?. Supongamos que queremos almacenar variables de tipo int en un fichero. Como las funciones vistas anteriormente sólo pueden operar con cadenas, deberíamos convertir los valores a cadenas (función itoa, integer to string). Para recuperar luego estos valores deberíamos leerlos como cadenas y pasarlos a enteros (atoi, string to integer). Pero existe una solución mucho más fácil: las funciones fwrite y fread. Éstas nos permiten tratar con datos de cualquier tipo, incluso con estructuras.

fwrite

Ésta nos permite escribir en un fichero. Tiene el siguiente formato:

size_t fwrite(const void *p_buffer, size_t tamaño, size_t número, FILE *p_fichero);

donde:
  • p_buffer - puntero a la variable que contiene los datos que vamos a escribir en el fichero.
  • tamaño - tamaño del tipo de dato a escribir. Puede ser un int, un float, una estructura, etc. Para conocer su tamaño usamos el operador sizeof.
  • número - número de datos a escribir.
  • p_fichero - puntero al fichero sobre el que trabajamos.
Esta función devuelve el número de elementos de tamaño tamaño (no bytes) escritos realmente al fichero, si no ha ocurrido algún error.

Para que quede más claro, examinemos el siguiente ejemplo: un programa de agenda que guarda el nombre, apellido y teléfono de cada persona:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct {
 char nombre[20];
 char apellido[20];
 char telefono[15];
} registro;

main()
{
 FILE *fichero;

 if ((fichero = fopen( "nombres.txt", "a" )) == NULL) {
  printf( "No se puede abrir el fichero.\n" );
  exit( 1 );
 }

 do {
  printf( "Nombre: " ); gets(registro.nombre);
  if (strcmp(registro.nombre,"")) {
   printf( "Apellido: " ); gets(registro.apellido);
   printf( "Teléfono: " ); gets(registro.telefono);

   /* Guarda el registro en el fichero */
   fwrite( &registro, sizeof(registro), 1, fichero );
  }
 } while (strcmp(registro.nombre,"")!= 0);

 fclose( fichero );
}

Este programa guarda los datos personales mediante fwrite usando la estructura registro. Abrimos el fichero en modo "a" (append, añadir), para que los datos que introducimos se añadan al final del fichero.

Una vez abierto abrimos entramos en un bucle do-while mediante el cual introducimos los datos. Estos se van almacenando en la variable registro (que es una estructura). Cuando tenemos todos los datos de la persona, los introducimos en el fichero con fwrite:

 fwrite( &registro, sizeof(registro), 1, fichero );
  • &registro - es la dirección donde comienza la estructura que contiene la información a escribir en el fichero.
  • sizeof(registro) - es el número de bytes que se escribirán, el tamaño en bytes que ocupa la estructura.
  • 1 - indica que sólo se guardará un elemento cada vez.
  • fichero - el puntero FILE al fichero nombres.txt donde vamos a escribir.
fread

Esta función se utiliza para extraer información de un fichero. Su formato es:
size_t fread(void *p_buffer, size_t tamaño, size_t número, FILE *p_fichero);

donde p_buffer es la dirección de la variable donde se almacenarán los datos leídos del fichero designado por p_fichero.

El valor que devuelve la función indica el número de elementos de tamaño tamaño que ha conseguido leer (podemos pedirle a fread que lea 10 elementos, pero si en el fichero sólo hay 6 devolverá el número 6).

Siguiendo con el ejemplo anterior, vamos a leer los datos que habíamos introducido ennombres.txt .

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct {
 char nombre[20];
 char apellido[20];
 char telefono[15];
} registro;

main()
{
 FILE *fichero;

 if ((fichero = fopen( "nombres.txt", "r" )) == NULL) {
  printf( "No se puede abrir el fichero.\n" );
  exit( 1 );
 }

 while (!feof(fichero)) {
  if (fread( &registro, sizeof(registro), 1, fichero )) {
   printf( "Nombre: %s\n",   registro.nombre );
   printf( "Apellido: %s\n", registro.apellido);
   printf( "Teléfono: %s\n", registro.telefono);
  }
 }

 fclose( fichero );
}

Abrimos el fichero en modo lectura, "r". Con el bucle while aseguramos el recorrido del fichero hasta el final (y que no vamos más allá).

La función fread lee 1 registro del tamaño de la estructura registro. Si realmente ha conseguido leer un registro, la función devolverá 1, en cuyo caso la condición del if será verdadera y se imprimirá el registro en la pantalla. En caso de que no queden más registros en el fichero, freaddevolverá 0 y no se mostrará nada en la pantalla.

Posicionamiento en el fichero: fseek y ftell

fseek

Esta función permite situarnos en la posición deseada de un fichero abierto. Cuando leemos un fichero existe un puntero o cursor que indica en qué lugar del fichero nos encontramos. Cada vez que leemos datos del fichero este puntero se desplaza. Con la función fseek podemos situar este puntero en el lugar que se precise.

El formato de fseek es el siguiente:

int fseek(FILE *p_fichero, long desplazamiento, int modo);

Como siempre, p_fichero es un puntero de tipo FILE que apunta al fichero con el que queremos trabajar.

Desplazamiento es el número de posiciones (o bytes) que queremos desplazar el puntero. Este desplazamiento puede ser de tres tipos, dependiendo del valor de modo:

SEEK_SETEl puntero se desplaza desde el principio del fichero.
SEEK_CUREl puntero se desplaza desde la posición actual del fichero.
SEEK_ENDEl puntero se desplaza desde el final del fichero.

Estas tres constantes están definidas en el fichero <stdio.h>. Como curiosidad, se indican a continuación sus definiciones:

#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2

Si se produce algún error al intentar posicionar el puntero, la función devuelve un valor distinto de 0. Si todo ha ido correctamente el valor devuelto es 0.

En el siguiente ejemplo se muestra el funcionamiento de fseek. Se trata de un programa que lee la letra que hay en la posición que especifica el usuario.

#include <stdio.h>
#include <stdlib.h>

main()
{
 FILE *fichero;
 long posicion;
 int resultado;

 if ((fichero = fopen( "origen.txt", "r" )) == NULL) {
  printf( "No se puede abrir el fichero.\n" );
  exit( 1 );
 }

 printf( "¿Qué posición quieres leer? " );
 scanf( "%li", &posicion );
 resultado = fseek( fichero, posicion, SEEK_SET );
 if (!resultado)
  printf( "En la posición %li está la letra %c.\n", posicion, getc(fichero) );
 else
  printf( "Problemas al posicionar el cursor.\n" );

 fclose( fichero );
}

NOTA: la primera posición del fichero es la 0, no la 1.

ftell

Esta función es complementaria a fseek. Devuelve la posición actual dentro del fichero.

Su formato es el siguiente:

long ftell(FILE *p_fichero);

El valor que devuelve puede ser usado por fseek para volver a la posición actual.

fprintf y fscanf

Estas dos funciones trabajan igual que sus equivalentes printf y scanf. La única diferencia es que podemos especificar el fichero sobre el que operan (si se desea, puede ser la pantalla para fprintfo el teclado para fscanf).

Los formatos de estas dos funciones son:

int fprintf(FILE *p_fichero, const char *formato, ...);
int fscanf(FILE *p_fichero, const char *formato, ...);

Estructuras en el Lenguaje C


Supongamos que queremos hacer una agenda con los números de teléfono de nuestros amigos. Necesitaríamos un array de cadenas para almacenar sus nombres, otro para sus apellidos y otro para sus números de teléfono. Esto puede hacer que el programa quede desordenado y difícil de seguir. Y aquí es donde presenta ventajas el uso de las estructuras.

Para definir una estructura usamos el siguiente formato:
struct nombre_de_la_estructura {
 campos de estructura;
 };

NOTA: Es importante no olvidar el ';' del final. En caso contrario se obtienen, a veces, errores extraños.

Para nuestro ejemplo podemos crear una estructura en la que almacenaremos los datos de cada persona. Vamos a crear una declaración de estructura llamada amigo:

struct estructura_amigo {
 char nombre[30];
 char apellido[40];
 char telefono[10];
 int edad;
 };

A cada elemento de esta estructura (nombre, apellido, teléfono, edad) se le denomina campo o miembro, y al conjunto de los datos se le denomina registro.

Aunque tenemos definida la estructura, todavía no podemos usarla. Necesitamos declarar una variable con esa estructura:

struct estructura_amigo amigo;

Ahora la variable amigo es de tipo estructura_amigo. Para acceder al nombre de amigo usamos: amigo.nombre (al operador '.' le denominamos selector directo de miembro) Vamos a ver un ejemplo de aplicación de esta estructura.

#include <stdio.h>

struct estructura_amigo { /* Definimos la estructura estructura_amigo */
 char nombre[30];
 char apellido[40];
 char telefono[10];
 int edad;
 };

struct estructura_amigo amigo; /* Declaramos la variable amigo con esa estructura */

main()
{
 printf( "Escribe el nombre del amigo: " );
 scanf( "%s", &amigo.nombre );
 printf( "Escribe el apellido del amigo: " );
 scanf( "%s", &amigo.apellido );
 printf( "Escribe el número de teléfono del amigo: " );
 scanf( "%s", &amigo.telefono );
 printf( "Mi amigo %s %s tiene el número: %s.\n", amigo.nombre,
  amigo.apellido, amigo.telefono );
}

Este ejemplo sería más correcto usando gets que scanf, ya que puede haber nombres compuestos que scanf no cogería por los espacios.

Se podría haber declarado directamente la variable amigo:

struct estructura_amigo {
 char nombre[30];
 char apellido[40];
 char telefono[10];
 int edad;
 } amigo;

Arrays de estructuras

Supongamos ahora que queremos guardar la información de varios amigos. Con una variable de estructura sólo podemos guardar los datos de uno. Para manejar los datos de más gente necesitamos declarar arrays de estructuras.

Siguiendo con el ejemplo anterior vamos a crear un array de registros: struct estructura_amigo amigo [ELEMENTOS];

Ahora necesitamos saber cómo acceder a cada elemento del array. La variable definida es amigo; por tanto, para acceder al primer elemento usaremos amigo[0], y a su nombre: amigo[0].nombre. Veámoslo con un ejemplo en el que se supone que tenemos que introducir los datos de tres amigos:

#include <stdio.h>

#define ELEMENTOS 3

struct estructura_amigo {
 char nombre[30];
 char apellido[40];
 char telefono[10];
 int edad;
 };

struct estructura_amigo amigo[ELEMENTOS];

main()
{
 int num_amigo;

 for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) {
  printf( "\nDatos del amigo número %i:\n", num_amigo+1 );

  printf( "Nombre: " );
  gets(amigo[num_amigo].nombre);
  printf( "Apellido: " );
  gets(amigo[num_amigo].apellido);
  printf( "Teléfono: " );
  gets(amigo[num_amigo].telefono);
  printf( "Edad: " );
  scanf( "%i", &amigo[num_amigo].edad );

  while(getchar()!= '\n'); /* Vacía el buffer de entrada */
 }

 /* Impresión de los datos */
 for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) {
  printf( "Mi amigo %s ", amigo[num_amigo].nombre );
  printf( "%s tiene ", amigo[num_amigo].apellido );
  printf( "%i años ", amigo[num_amigo].edad );
  printf( "y su teléfono es el %s.\n" , amigo[num_amigo].telefono );
 }
}

Obsérvese la línea while(getchar()!= '\n'). Esta línea se usa para vaciar el buffer de entrada.

Inicialización de una estructura

A las estructuras se les pueden dar valores iniciales de manera análoga a como se hace con los arrays. Primero debemos definir la estructura y después, cuando declaramos una variable como estructura, le damos el valor inicial que queremos. Por ejemplo, para la estructura que hemos definido antes podría ser:

struct estructura_amigo amigo = {
 "Juanjo",
 "López",
 "983403367",
 30
 };


Por supuesto, hemos de introducir en cada campo el tipo de datos correcto. Por lo tanto el nombre ("Juanjo") debe ser una cadena de no más de 29 caracteres (recordemos que hay que reservar un espacio para el símbolo '\0'), el apellido ("López") una cadena de menos de 39, el teléfono una de 9 y la edad debe ser de tipo int.

Vamos a ver la inicialización de estructuras en acción:


#include <stdio.h>

struct estructura_amigo {
 char nombre[30];
 char apellido[40];
 char telefono[10];
 int edad;
 };

struct estructura_amigo amigo = {
 "Juanjo",
 "López",
 "983403367",
 30
 };

main()
{
 printf( "%s tiene ", amigo.apellido );
 printf( "%i años ", amigo.edad );
 printf( "y su teléfono es el %s.\n" , amigo.telefono );
}

También se puede inicializar un array de estructuras de la forma siguiente:

struct estructura_amigo amigo[] = {
 "Juanjo", "López", "983403367", 30,
 "Marcos", "Ramos", "983427890", 42,
 "Ana", "Martínez", "983254789", 20
 };

En este ejemplo cada línea es un registro. Como sucedía en los arrays, si asignamos valores iniciales al array de estructuras no hace falta indicar cuántos elementos va a tener. En este caso la matriz tiene 3 elementos, que son los que le hemos introducido.

Punteros a estructuras

También se pueden usar punteros con estructuras. Antes de nada, hay que definir la estructura de igual forma que hacíamos antes. La diferencia está en que al declarar la variable de tipo estructura debemos anteponerle el operador '*' para indicarle que es un puntero.

Veamos un ejemplo. Este programa utiliza un puntero para acceder a la información de la estructura:

#include <stdio.h>

struct estructura_amigo {
 char nombre[30];
 char apellido[40];
 char telefono[10];
 int edad;
 };

struct estructura_amigo amigo = {
 "Juanjo",
 "López",
 "983403367",
 30
 };

main()
{
 struct estructura_amigo *p_amigo;

 p_amigo = &amigo;

 printf( "%s tiene ", p_amigo->apellido );
 printf( "%i años ", p_amigo->edad );
 printf( "y su teléfono es el %s.\n" , p_amigo->telefono );
}


Hasta la definición del puntero p_amigo todo resulta igual que antes. Éste es un puntero a la estructura estructura_amigo. Dado que es un puntero, debemos indicarle a dónde debe apuntar; en este caso hacemos que apunte a la variable amigo: p_amigo = &amigo; (recordemos que el operador & significa 'dame la dirección donde está almacenado...').

Ahora queremos acceder a cada campo de la estructura. Antes lo hacíamos usando el operador '.', pero, como muestra el ejemplo, si se trabaja con punteros se debe usar el operador '->'. Este operador, denominado selector indirecto de miembro, viene a significar algo así como: "dame acceso al miembro ... del puntero ...".

Vamos a ver ahora con un ejemplo cómo introducir datos en las estructuras:


#include <stdio.h>

struct estructura_amigo {
 char nombre[30];
 char apellido[40];
 char telefono[10];
 int edad;
 };

main()
{
 struct estructura_amigo *p_amigo;

 p_amigo = &amigo;

 /* Introducimos los datos mediante punteros */
 printf("Nombre: ");
 gets(p_amigo->nombre);
 printf("Apellido: ");
 gets(p_amigo->apellido);
 printf("Edad: ");
 scanf( "%i", &p_amigo->edad );

 /* Mostramos los datos */
 printf( "Mi amigo %s ", p_amigo->nombre );
 printf( "%s tiene ", p_amigo->apellido );
 printf( "%i años.\n", p_amigo->edad );
}

NOTA: p_amigo es un puntero que apunta a la estructura amigo. Sin embargo, p_amigo->edad es una variable de tipo int. Por eso al usar elscanf debemos anteponer &.

Punteros a arrays de estructuras

Por supuesto, también se pueden usar punteros con arrays de estructuras. La forma de trabajar es la misma, aunque hay que asegurarse de que el puntero inicialmente apunte al primer elemento, después saltar al siguiente, etc., hasta llegar al último.

#include <stdio.h>

#define ELEMENTOS 3

struct estructura_amigo {
 char nombre[30];
 char apellido[40];
 char telefono[10];
 int edad;
 };

struct estructura_amigo amigo[] = {
 "Juanjo", "López", "983403367", 30,
 "Marcos", "Ramos", "983427890", 42,
 "Ana", "Martínez", "983254789", 20
 };

main()
{
 struct estructura_amigo *p_amigo;
 int num_amigo;

 p_amigo = amigo; /* apunta al primer elemento del array */

 /* Imprimimos los datos */
 for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) {

  printf( "Mi amigo %s ", p_amigo->nombre );
  printf( "%s tiene ", p_amigo->apellido );
  printf( "%i años ", p_amigo->edad );
  printf( "y su teléfono es el %s.\n" , p_amigo->telefono );

  /* saltamos al siguiente elemento */
  p_amigo++;  
 }
}

En vez de p_amigo = amigo; se podía usar la forma p_amigo = &amigo[0], es decir, que apunte al primer elemento (el elemento 0) delarray. La primera forma es más frecuente pero la segunda, quizás, indica más claramente al principiante lo que se pretende.

Ahora veamos el ejemplo anterior de cómo introducir datos en un array de estructuras mediante punteros:

#include <stdio.h>

#define ELEMENTOS 3

struct estructura_amigo {
 char nombre[30];
 char apellido[40];
 char telefono[10];
 int edad;
 };

main()
{
 struct estructura_amigo amigo[ELEMENTOS], *p_amigo;
 int num_amigo;

 p_amigo = amigo; /* apunta al primer elemento del array */

 /* Introducimos los datos mediante punteros */
 for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) {
  printf( "\nDatos del amigo %i:\n", num_amigo+1 );

  printf( "Nombre: " );
  gets(amigo[num_amigo].nombre);
  printf( "Apellido: " );
  gets(amigo[num_amigo].apellido);
  printf( "Teléfono: " );
  gets(amigo[num_amigo].telefono);
  printf( "Edad: " );
  scanf( "%i", &amigo[num_amigo].edad );

  while(getchar()!= '\n'); /* Vacía el buffer de entrada */

  p_amigo++;   /* Siguiente elemento */

 }

 /* Imprimimos los datos */
 p_amigo = amigo;

 for( num_amigo=0; num_amigo<ELEMENTOS; num_amigo++ ) {

  printf( "Mi amigo %s ", p_amigo->nombre );
  printf( "%s tiene ", p_amigo->apellido );
  printf( "%i años ", p_amigo->edad );
  printf( "y su teléfono es el %s.\n" , p_amigo->telefono );

  p_amigo++;  
 }
}

Es importante no olvidar que al terminar el primer bucle for el puntero p_amigo apunta al último elemento del array de estructuras. Para mostrar los datos debemos hacer que vuelva a apuntar al primer elemento, por eso usamos de nuevo p_amigo = amigo;.

Paso de estructuras a funciones

Las estructuras se pueden pasar directamente a una función igual que se hace con las variables. Por supuesto, en la definición de la función de debe indicar el tipo de argumento que usamos:
tipo nombre_función ( struct nombre_de_la_estructura nombre_de_la variable_estructura )

En el ejemplo siguiente se usa una función llamada suma que calcula cual será la edad 20 años más tarde (simplemente suma 20 a la edad). Esta función toma como argumento la variable estructura arg_amigo. Cuando se ejecuta el programa llamamos a suma desde main y en esta variable se copia el contenido de la variable amigo.

#include <stdio.h>

struct estructura_amigo {
 char nombre[30];
 char apellido[40];
 char telefono[10];
 int edad;
 };

struct estructura_amigo amigo = {
 "Juanjo",
 "López",
 "983403367",
 30
 };

int suma( struct estructura_amigo );

main()
{
 printf( "%s tiene ", amigo.apellido );
 printf( "%i años ", amigo.edad );
 printf( "y dentro de 20 años tendrá %i.\n", suma(amigo) );
}

int suma( struct estructura_amigo arg_amigo )
{
 return arg_amigo.edad + 20;
}

Si dentro de la función suma hubiésemos cambiado algún valor de la estructura, dado que es una copia, no hubiera afectado a la variable amigode main. Es decir, si dentro de suma hacemos, por ejemplo, arg_amigo.edad = 20; el valor de arg_amigo cambiará, pero el de amigoseguirá siendo 30.

También se pueden pasar estructuras mediante punteros o se puede pasar simplemente un miembro (o campo) de la estructura. Si usamos punteros para pasar estructuras como argumentos habrá que hacer unos cambios al código anterior (en negrita):

#include <stdio.h>

struct estructura_amigo {
 char nombre[30];
 char apellido[40];
 char telefono[10];
 int edad;
 };

struct estructura_amigo amigo = {
 "Juanjo",
 "López",
 "983403367",
 30
 };

int suma( struct estructura_amigo * );

main()
{
 printf( "%s tiene ", amigo.apellido );
 printf( "%i años ", amigo.edad );
 printf( "y dentro de 20 años tendrá %i.\n", suma(&amigo) );
}

int suma( struct estructura_amigo *arg_amigo )
{
 return arg_amigo->edad + 20;
}

Lo primero será indicar a la función suma que va a recibir es puntero, por lo cual ponemos * a arg_amigo. Segundo, como dentro de la función suma usamos un puntero a estructura y no una variable estructura, debemos cambiar el '.' por el '->'. Tercero, dentro de main, cuando llamamos a suma, debemos pasar la dirección de amigo, no su valor, por lo tanto debemos anteponer '&'.

Si usamos punteros a estructuras corremos el riesgo (o tenemos la ventaja, según cómo se mire) de poder cambiar los datos de la estructura de la variable amigo de main.

Paso de miembros de una estructura a funciones

Otra posibilidad es no pasar toda la estructura a la función, sino tan sólo los miembros que sean necesarios. El ejemplo anterior sería más correcto usando esta tercera opción, ya que sólo usamos el miembro edad:

int suma( int );

main()
{
 printf( "%s tiene ", amigo.apellido );
 printf( "%i años ", amigo.edad );
 printf( "y dentro de 20 años tendrá %i.\n", suma(amigo.edad) );
}

int suma( int edad )
{
 return edad + 20;
}

Estructuras dentro de estructuras (estructuras anidadas)

Es posible crear estructuras que tengan como miembros otras estructuras. Esto tiene diversas utilidades, por ejemplo contar con estructuras de datos más ordenadas. Imaginemos la siguiente situación: una tienda de música quiere hacer un programa para el inventario de los discos, cintas y cd's. Para cada título se quiere conocer las existencias en cada soporte (cinta, disco, cd), y los datos del proveedor. Podría pensarse en una estructura así:

struct inventario {
 char titulo[30];
 char autor[40];
 int existencias_discos;
 int existencias_cintas;
 int existencias_cd;
 char nombre_proveedor[40];
 char telefono_proveedor[10];
 char direccion_proveedor[100];
 };

Sin embargo, utilizando estructuras anidadas se podría hacer de esta otra forma más ordenada:

struct est_existencias {
 int discos;
 int cintas;
 int cd;
 };

struct est_proveedor {
 char nombre_proveedor[40];
 char telefono_proveedor[10];
 char direccion_proveedor[100];
 };

struct est_inventario {
 char titulo[30];
 char autor[40];
 struct est_existencias existencias;
 struct est_proveedor proveedor;
 } inventario;

Ahora, para acceder al número de cd de cierto título usaríamos:

 inventario.existencias.cd

y para acceder al nombre del proveedor:

 inventario.proveedor.nombre

lunes, 24 de febrero de 2014

Cadena de Textos en el Lenguaje C


Vamos ahora a ver cómo manejar texto con C. Para empezar, es preciso decir que existe un tipo string como en otros lenguajes, pero no existe un tipo de datos específico para almacenar texto, sino que se utilizan arrays de char. Funcionan igual que los demás arrays con la diferencia de que ahora se manejan letras en vez de números. Se les llama cadenas, strings o tiras de caracteres y a partir de ahora les llamaremos cadenas.

Para declarar una cadena se hace como en el caso de un array. Por ejemplo, si queremos declarar una cadena de longitud 20 caracteres se haría: char texto[20];

Al igual que en los arrays, no podemos entonces introducir más de 20 elementos en la cadena. Vamos a ver un ejemplo para mostrar el nombre del usuario en pantalla:

#include <stdio.h>

main()
{
	char nombre[20];

	printf( "Introduzca su nombre (20 letras máximo): " );
	scanf( "%s", nombre );
	printf( "\nEl nombre que ha escrito es: %s\n", nombre );
}

Obsérvese que en la sentencia scanf no se usa el símbolo & delante de nombre. No hace falta porque se trata de un array, de modo que escribir el nombre del array es equivalente a poner &nombre[0].

También puede llamar la atención sobre la forma de imprimir el array. Con sólo usar %s ya se imprime su totalidad. Ya veremos esto más adelante.

Por si alguien está acostumbrado a programar en otro lenguaje es preciso hacer notar que en C no se puede hacer esto:

#include <stdio.h>

main()
{
	char texto[20];

	texto = "Hola";
}

Es interesante saber cómo funciona una cadena por dentro, por eso vamos a ver primero cómo se inicializa:

#include <stdio.h>

main()
{
	char nombre[] = "Gandalf";

	printf( "Texto: %s\n", nombre );
	printf( "Tamaño de la cadena: %i bytes\n", sizeof nombre );
}

Resultado al ejecutar:

Texto: Gandalf
Tamaño de la cadena: 8 bytes

Curiosamente la respuesta nos dice que "Gandalf" ocupa 8 bytes. Como cada elemento char ocupa un byte eso quiere decir que la cadena tiene 8 elementos, a pesar de que "Gandalf" sólo cuenta con 7 letras. La razón de esta aparente paradoja estriba en que la cadena tiene como carácter final el símbolo '\0', cuyo significado es "fin de cadena". De esta forma, cuando queremos escribir la cadena basta con usar %s y el compilador sabe cuántos elementos debe escribir: hasta que encuentre '\0'.

El programa anterior sería equivalente a:

#include <stdio.h>

main()
{
	char nombre[] = { 'G', 'a', 'n', 'd', 'a', 'l', 'f', '\0' };

	printf( "Texto: %s\n", nombre );
	printf( "Tamaño de la cadena: %i bytes\n", sizeof nombre );
}
Aquí ya se observa claramente que nombre tiene 8 elementos. Pero, ¿qué pasaría si no pusiéramos '\0' al final?
#include <stdio.h>

main()
{
	char nombre[] = { 'G', 'a', 'n', 'd', 'a', 'l', 'f' };

	printf( "Texto: %s\n", nombre );
	printf( "Tamaño de la cadena: %i bytes\n", sizeof nombre );
}

En mi ordenador se obtiene:

Texto: Gandalf-
Tamaño de la cadena: 7 bytes



Pero en otro después de "Gandalf" puede aparecer cualquier cosa. Lo que aquí sucede es que printf no encuentra el símbolo '\0' y no sabe cuándo dejar de imprimir. Afortunadamente, cuando introducimos una cadena se hace de la primera forma y el C se encarga de poner el símbolo al final.

Es importante no olvidar que la longitud de una cadena es la longitud del texto más el símbolo de fin de cadena. Por eso cuando definamos una cadena tenemos que reservarle un espacio adicional. Por ejemplo:


char nombre[8] = "Gandalf";



Funciones de manejo de cadenas

Existen unas cuantas funciones el la biblioteca estándar de C para el manejo de cadenas:
  • strlen
  • strcpy
  • strcat
  • sprintf
  • strcmp
Para usar estas funciones en nuestro programa hay que añadir la directiva:

#include <string.h>

strlen

size_t *strlen(const char *cadena);

Esta función devuelve el número de caracteres que tiene la cadena (sin contar el '\0').

#include <stdio.h>
#include <string.h>

main()
{
	char texto[]="Gandalf";
	int longitud;
	longitud = strlen(texto);
	printf( "La cadena \"%s\" tiene %i caracteres.\n", texto, longitud );
}

Como ejemplo, vamos a ver cómo se programaría esta función si no dispusiéramos de ella. Hay más información en Recorrido de cadenas con punteros.

#include <stdio.h>
#include <string.h>

main()
{
	char texto[]="Gandalf";
	char *p;
	int longitud=0;

	p = texto;
	while (*p != '\0') {
		longitud++;
		printf( "%c\n", *p );	/* Mostramos la letra actual */
		p++;			/* Vamos a la siguiente letra */
	}
	printf( "La cadena \"%s\" tiene %i caracteres.\n", texto, longitud );
}

Para medir la longitud de la cadena usamos un puntero para recorrerla (el puntero p). Hacemos que p apunte a texto. Luego entramos en un bucle while. La condición del bucle comprueba si se ha llegado al fin de cadena ('\0'). Si no es así, suma 1 a longitud, muestra la letra por pantalla e incrementa el puntero en 1 (con lo que pasamos a la siguiente letra).

strcpy

char *strcpy(char *cadena1, const char *cadena2);

Copia el contenido de cadena2 en cadena1. cadena2 puede ser una variable o una cadena directa (por ejemplo, "hola"). Debemos tener cuidado de que la cadena destino (cadena1) tenga espacio suficiente para albergar a la cadena origen (cadena2).

#include <stdio.h>
#include <string.h>

main()
{
	char texto[] = "Éste es un curso de C.";
	char destino[50];

	strcpy( destino, texto );
	printf( "Valor final: %s\n", destino );
}

Vamos a ver otro ejemplo en el que la cadena destino es una cadena constante ("Éste es un curso de C.") y no una variable. Además, en este ejemplo vemos que la cadena origen es sustituida por la cadena destino totalmente. Si la cadena origen es más larga que la destino, se eliminan las letras adicionales.

#include <stdio.h>
#include <string.h>

main()
{
	char destino[50]="Éste no es un curso de HTML, sino de C.";

	printf( "%s\n", destino );
	strcpy( destino, "Éste es un curso de C." );
	printf( "%s\n", destino );
}

strcat

char *strcat(char *cadena1, const char *cadena2);

Añade la cadena2 al final de la cadena1 (concatena).

#include <stdio.h>
#include <string.h>

main()
{
	char nombre_completo[50];
	char nombre[]="Gandalf";
	char apellido[]="el Gris";

	strcpy( nombre_completo, nombre );
	strcat( nombre_completo, " " );
	strcat( nombre_completo, apellido );
	printf( "El nombre completo es: %s.\n", nombre_completo );
}

Como siempre, tenemos asegurar que la variable en la que añadimos las demás cadenas tenga el tamaño suficiente. Con la primera línea de este programa introducimos el nombre en nombre_completo. Usamos strcpy para asegurarnos de que queda borrado cualquier dato anterior. Luego usamos un strcat para añadir un espacio y, finalmente, introducimos el apellido.

sprintf

int sprintf(char *destino, const char *format, ...);

Funciona de manera similar a printf pero, en vez de mostrar el texto en la pantalla, lo guarda en una variable (destino). El valor que devuelve (int) es el número de caracteres guardados en la variable destino.

Con sprintf podemos repetir el ejemplo de strcat de manera más sencilla:

#include <stdio.h>
#include <string.h>

main()
{
	char nombre_completo[50];
	char nombre[]="Gandalf";
	char apellido[]="el Gris";

	sprintf( nombre_completo, "%s %s", nombre, apellido );
	printf( "El nombre completo es: %s.\n", nombre_completo );
}

Se puede aplicar a sprintf todo lo indicado para printf.

strcmp

int strcmp(const char *cadena1, const char *cadena2);

Compara cadena1 y cadena2. Si son iguales, devuelve 0. Un número negativo si cadena1 "va" antes que cadena2, y un número positivo si es al contrario:
  • < 0 si cadena1 < cadena2
  • ==0 si cadena1 == cadena2
  • > 0 si cadena1 > cadena2
#include <stdio.h>
#include <string.h>

main()
{
	char nombre1[]="Gandalf";
	char nombre2[]="Frodo";

	printf( "Comparación con strcmp: %i\n", strcmp(nombre1,nombre2));
}

El resultado es:

Comparación con strcmp : 1

Arrays de cadenas

Un array de cadenas puede servirnos para agrupar una serie de mensajes. Por ejemplo, todos los mensajes de error de un programa. Luego, para acceder a cada mensaje, basta con usar su número.

#include <stdio.h>
#include <string.h>

int error( int num_err )
{
	char *errores[] = {
		"No se ha producido ningún error",
		"No hay suficiente memoria",
		"No hay espacio en disco",
		"Me he cansado de trabajar"
		};

	printf( "Error número %i: %s.\n", num_err, errores[num_err] );
	exit( -1 );
}


main()
{
	error( 2 );
}

El resultado será:

Error número 2: No hay espacio en disco.

Un array de cadenas es en realidad un array de punteros a cadenas. El primer elemento de la cadena ("No se ha producido ningún error") tiene un espacio reservado en memoria y errores[0] apunta a ese espacio.

Ordenación de un array de cadenas

Vamos a ver un sencillo ejemplo de ordenación de cadenas. En el ejemplo siguiente tenemos que ordenar una serie de dichos populares:

#include <stdio.h>
#include <string.h>

#define ELEMENTOS 5

main()
{
	char *dichos[ELEMENTOS] = {
		"La avaricia rompe el saco",
		"Más vale pájaro en mano que ciento volando",
		"No por mucho madrugar amanece más temprano",
		"Año de nieves, año de bienes",
		"A caballo regalado no le mires el diente"
		};
	char *temp;
	int i, j;

	printf( "Lista desordenada:\n" );
	for( i=0; i<ELEMENTOS; i++ )
		printf( "  %s.\n", dichos[i] );

	for( i=0; i<ELEMENTOS-1; i++ )
		for( j=i+1; j<ELEMENTOS; j++ )
			if ( strcmp(dichos[i], dichos[j]) > 0 ) {
				temp = dichos[i];
				dichos[i] = dichos[j];
				dichos[j] = temp;
			}

	printf( "Lista ordenada:\n" );
	for( i=0; i<ELEMENTOS; i++ )
		printf( "  %s.\n", dichos[i] );
}

Cómo funciona el programa:

tomamos el primer elemento de la matriz. Lo comparamos con todos los siguientes. Si alguno es anterior, los intercambiamos. Cuando acabe esta primera vuelta tendremos "A caballo regalado no le mires el diente" en primera posición.
Tomamos el segundo elemento. Lo comparamos con el tercero y siguientes. Si alguno es anterior, los intercambiamos. Al final de esta vuelta quedará "A caballo regalado no le mires el diente" en segunda posición.

Para ver con mayor claridad el resultado a partir del desarrollo del proceso, se va a sustituir cada cadena por su primera letra (menos la de "Año de nieves..." que se sustituirá por Añ). Así, el proceso queda:


Recorrido de cadenas con punteros

Las cadenas se pueden recorrer de igual forma que se hace con los arrays, usando punteros. Vamos a ver un ejemplo: el siguiente sencillo programa cuenta los espacios y las letras e (minúsculas) que hay en una cadena.

#include <stdio.h>
#include <string.h>

main()
{
	char cadena[]="El puerto paralelo del PC";
	char *p;
	int espacios = 0, letras_e = 0;

	p = cadena;
	while (*p != '\0') {
		if (*p == ' ') espacios++;
		if (*p == 'e') letras_e++;
		p++;
	}

	printf( "En la cadena \"%s\" hay:\n", cadena );
	printf( "  %i espacios\n", espacios );
	printf( "  %i letras e\n", letras_e );
}

El resultado es:

En la cadena "El puerto paralelo del PC" hay:
  4 espacios
  3 letras e

Para recorrer la cadena necesitamos un puntero p que sea de tipo char. Debemos hacer que p apunte a la cadena (p=cadena). Así, p apunta a la dirección del primer elemento de la misma. El valor de *p sería, por tanto, 'E'. Comenzamos el bucle. La condición comprueba que no se ha llegado al final de la cadena (*p != '\0'). Entonces se comprueba si en la dirección a la que apunta p hay un espacio o una letra e. Si es así, se incrementan las variables correspondientes. Una vez comprobado esto se pasa a la siguiente letra (p++).

En este otro ejemplo substituimos los espacios por guiones:

#include <stdio.h>
#include <string.h>

main()
{
	char cadena[]="El puerto paralelo del PC";
	char *p;

	p = cadena;
	while (*p != '\0') {
		if (*p == ' ') *p = '-';
		p++;
	}

	printf( "La cadena queda: \"%s\" \n", cadena );
}

y se obtiene:

La cadena queda: "El-puerto-paralelo-del-PC"

Aprende a Programar tus propias aplicaciones