jueves, 4 de septiembre de 2008

Recursividad

Es el proceso de definir algo en términos de si mismo, es decir que las funciones pueden llamarse a si mismas, esto se consigue cuando en el cuerpo de la función hay una llamada a la propia función, se dice que es recursiva. Una función recursiva no hace una nueva copia de la función, solo son nuevos los argumentos.
La principal ventaja de las funciones recursivas es que se pueden usar para crear versiones de algoritmos más claras y sencillas. Cuando se escriben funciones recursivas, se debe tener una sentencia if para forzar a la
función a volver sin que se ejecute la llamada recursiva.

#include <stdio.h>
int fact(int numero)
{
int resp;
if(numero==1)
return 1;
resp=fact(numero-1)*numero;
return(resp);
}
int main()
{
int num;
printf("Deme un numero y le dare el factorial: ");
scanf("%d",&num);
printf("%d\n", fact(num));
return 0;
}

Librerías

Librería stdio.h
printf
     Función: Escribe en la salida estándar con formato.
     Sintaxis: printf(formato , arg1 , ...);
scanf
     Función: Lee de la salida estándar con formato.
     Sintaxis: scanf(formato , arg1 , ...);
puts
     Función: Escribe una cadena y salto de linea.
     Sintaxis: puts(cadena);
gets
     Función: Lee y guarda una cadena introducida por teclado.
     Sintaxis: gets(cadena);
fopen
     Función: Abre un fichero en el modo indicado.
     Sintaxis: pf=fopen(fichero , modo);
fclose
     Función: Cierra un fichero cuyo puntero le indicamos.
     Sintaxis: fclose(pf);
fprintf
     Función: Escribe con formato en un fichero.
     Sintaxis: fprintf(pf , formato , arg1 , ...);
fgets
     Función: Lee una cadena de un fichero.
     Sintaxis: fgets(cadena , longitud , pf);

 

Librería stdlib.h
atof
     Función: Convierte una cadena de texto en un valor de tipo float.
     Sintaxis: numflo=atof(cadena);
atoi
     Función: Convierte una cadena de texto en un valor de tipo entero.
     Sintaxis: nument=atoi(cadena);
itoa
     Función: Convierte un valor numérico entero en una cadena de texto. La base generalmente será 10, aunque se puede indicar otra distinta.
     Sintaxis: itoa(número , cadena , base);
exit
     Función: Termina la ejecución y abandona el programa.
     Sintaxis: exit(estado); /* Normalmente el estado será 0 */

 

Librería conio.h
clrscr
     Función: Borra la pantalla.
     Sintaxis: clrscr( );
clreol
     Función: Borra desde la posición del cursor hasta el final de la linea.
     Sintaxis: clreol( );
gotoxy
     Función: Cambia la posición del cursor a las coordenadas indicadas.
     Sintaxis: gotoxy(columna , fila);
textcolor
     Función: Selecciona el color de texto (0 - 15).
     Sintaxis: textcolor(color);
textbackground
     Función: Selecciona el color de fondo (0 - 7).
     Sintaxis: textbackground(color);
wherex
     Función: Retorna la columna en la que se encuentra el cursor.
     Sintaxis: col=wherex( );
wherey
     Función: Retorna la fila en la que se encuentra el cursor.
     Sintaxis: fila=wherey( );
getch
     Función: Lee y retorna un único caracter introducido mediante el teclado por el usuario. No muestra el caracter por la pantalla.
     Sintaxis: letra=getch( );
getche
     Función: Lee y retorna un único caracter introducido mediante el teclado por el usuario. Muestra el caracter por la pantalla.
     Sintaxis: letra=getche( );

 

strlen
     Función: Calcula la longitud de una cadena.
     Sintaxis: longitud=strlen(cadena);
strcpy
     Función: Copia el contenido de una cadena sobre otra.
     Sintaxis: strcpy(copia , original);
strcat
     Función: Concatena dos cadenas.
     Sintaxis: strcat(cadena1 , cadena2);
strcmp
     Función: Compara el contenido de dos cadenas. Si cadena1 < cadena2 retorna un número negativo. Si cadena1 > cadena2, un n£mero positivo, y si cadena1 es igual que cadena2 retorna 0 ( o NULL ).
     Sintaxis: valor=strcmp(cadena1 , cadena2);

 

Librería dir.h
     En esta librería encontraremos una serie de rutinas que nos permitirán realizar operaciones básicas con directorios y unidades de disco.
chdir
     Función: Cambia el directorio actual.
     Sintaxis: chdir(ruta); /* Podemos indicar la unidad: chdir("a:\\DATOS"); */
getcwd
     Función: Lee del sistema el nombre del directorio de trabajo.
     Sintaxis: getcwd(directorio,tamañocad) /* Lee el directorio y la unidad */
getdisk
     Función: Lee del sistema la unidad actual.
     Sintaxis: disk=getdisk( ) + 'A'; /* Retorna un entero: 0 = A: , 1 = B: ... */
mkdir
     Función: Crea un directorio.
     Sintaxis: mkdir(nombre);

 

Funciones interesantes
fflush(stdin)
     Función: Limpia el buffer de teclado.
     Sintaxis: fflush(stdin);
     Prototipo: stdio.h
sizeof
     Función: Operador que retorna el tamaño en bytes de una variable.
     Sintaxis: tamaño=sizeof(variable);
cprintf
     Función: Funciona como el printf pero escribe en el color que hayamos activado con la función textcolor sobre el color activado con textbackground.
     Sintaxis: cprintf(formato , arg1 , ...);
     Prototipo: conio.h
kbhit
     Función: Espera la pulsación de una tecla para continuar la ejecución.
     Sintaxis: while (!kbhit( )) /* Mientras no pulsemos una tecla... */
     Prototipo: conio.h
random
     Función: Retorna un valor aleatorio entre 0 y num-1.
     Sintaxis: valor=random(num); /* También necesitamos la función randomize */
     Prototipo: stdlib.h
randomize
     Función: Inicializa el generador de números aleatorios. Deberemos llamarlo al inicio de la función en que utilicemos el random. También deberemos utilizar el include time.h, ya que randomize hace una llamada a la función time, incluída en este último archivo.
     Sintaxis: randomize( );
     Prototipo: stdio.h
system
     Función: Ejecuta el comando indicado. Esto incluye tanto los comandos del sistema operativo, como cualquier programa que nosotros le indiquemos. Al acabar la ejecución del comando, volverá a la linea de código situada a continuación de la sentencia system.
     Sintaxis: system(comando); /* p.ej: system("arj a programa"); */
     Prototipo: stdlib.h

Gestión Dinámica de Memoria

Funciones
     Como veremos después, la gestión dinámica memoria se realiza mediante estructuras dinámicas de datos. Fíjate que se repite la palabra dinámica. Estas estructuras se diferencian de las estáticas ( arrays y estructuras ), en que no tienen un tamaño fijo, es decir, no tenemos que indicar su tamaño al declararlas, sino que podremos aumentarlo o disminuirlo en tiempo de ejecución, cuando se esté ejecutando la aplicación. Como puedes ver, las estructuras dinámicas son de gran utilidad. A continuación veremos las funciones que se encargan de reservar y liberar memoria durante la ejecución, que se encuentran en la librería alloc.h:
malloc( tamaño );
     Esta función reserva en memoria una zona de tamaño bytes, y devuelve un puntero al inicio de esa zona. Si no hubiera suficiente memoria retornaría NULL. Más adelante veremos algunos ejemplos.
free( puntero );
     Esta función libera de la memoria la zona que habíamos reservado anteriormente con la función malloc. También podremos ver algún ejemplo en la página siguiente.

 

Estructuras dinámicas de datos
     En función de la forma en que se relacionan existen varios tipos de estructuras de datos. Este tipo de estructuras son autorreferenciadas, es decir, contienen entre sus campos un puntero de su mismo tipo. Las más utilizadas son:


- pilas
- colas
- listas


Las pilas


     Este tipo de estructuras se caracteriza porque todas las operaciones se realizan en el mismo lado. Es de tipo LIFO ( Last In First Out ), el último elemento en entrar es el primero en salir.



/* Ejemplo de una pila. */



#include <stdio.h>

#include <conio.h>


#include <stdlib.h>


#include <alloc.h>



void insertar(void);

void extraer(void);


void visualizar(void);



struct pila

{


    char nombre[20];


    struct pila *ant;


}*CAB=NULL,*AUX=NULL;



main() /* Rellenar, extraer y visualizar */

{


    char opc;


    do


    {


        clrscr(); /* borramos la pantalla */


        gotoxy(30,8); /* columna 30, fila 8 */


        printf("1.- Insertar");


        gotoxy(30,10);


        printf("2.- Extraer");


        gotoxy(30,12);


        printf("3.- Visualizar la pila");


        gotoxy(30,14);


        printf("4.- Salir");


        opc=getch( );


        switch(opc)


        {


            case '1':


                insertar( );


                break;


            case '2':


                extraer( );


                break;


            case '3':


                visualizar( );


        }


    }while (opc!='4');


}



void insertar(void)

{


    AUX=(struct pila *)malloc(sizeof(struct pila));


    clrscr();


    printf("Nombre: ");


    gets(AUX->nombre);


    if (CAB==NULL)


    {


        CAB=AUX;


        AUX->ant=NULL;


    }


    else


    {


        AUX->ant=CAB;


        CAB=AUX;


    }


}



void extraer(void)

{


    if (CAB==NULL) return;


    AUX=CAB;


    CAB=CAB->ant;


    free(AUX);


}



void visualizar(void)

{


    if (CAB==NULL) return;


    clrscr();


    AUX=CAB;


    while (AUX!=NULL)


    {


        printf("Nombre: %s\n",AUX->nombre);


        AUX=AUX->ant;


    }


    getch( );


}

Estructura y Funciones

Estructuras y funciones
     Podemos enviar una estructura a una función de las dos maneras conocidas:
1.- Por valor: su declaración sería:


void visualizar(struct trabajador);
      Después declararíamos la variable fijo y su llamada sería:


visualizar(fijo);
      Por último, el desarrollo de la función sería:


void visualizar(struct trabajador datos)


/* Paso de una estructura por valor. */



#include <stdio.h>



struct trabajador

{


    char nombre[20];


    char apellidos[40];


    int edad;


    char puesto[10];


};



void visualizar(struct trabajador);

main() /* Rellenar y visualizar */


{


    struct trabajador fijo;


    printf("Nombre: ");


    scanf("%s",fijo.nombre);


    printf("\nApellidos: ");


    scanf("%s",fijo.apellidos);


    printf("\nEdad: ");


    scanf("%d",&fijo.edad);


    printf("\nPuesto: ");


    scanf("%s",fijo.puesto);


    visualizar(fijo);


}



void visualizar(struct trabajador datos)

{


    printf("Nombre: %s",datos.nombre);


    printf("\nApellidos: %s",datos.apellidos);


    printf("\nEdad: %d",datos.edad);


    printf("\nPuesto: %s",datos.puesto);


}



 



2.- Por referencia: su declaración sería:




void visualizar(struct trabajador *);
      Después declararemos la variable fijo y su llamada será:


visualizar(&fijo);
      Por último, el desarrollo de la función será:


void visualizar(struct trabajador *datos)


     Fíjate que en la función visualizar, el acceso a los campos de la variable datos se realiza mediante el operador ->, ya que tratamos con un puntero. En estos casos siempre utilizaremos el operador ->. Se consigue con el signo menos seguido de mayor que.



/* Paso de una estructura por referencia. */



#include <stdio.h>



struct trabajador

{


    char nombre[20];


    char apellidos[40];


    int edad;


    char puesto[10];


};



void visualizar(struct trabajador *);

main() /* Rellenar y visualizar */


{


    struct trabajador fijo;


    printf("Nombre: ");


    scanf("%s",fijo.nombre);


    printf("\nApellidos: ");


    scanf("%s",fijo.apellidos);


    printf("\nEdad: ");


    scanf("%d",&fijo.edad);


    printf("\nPuesto: ");


    scanf("%s",fijo.puesto);


    visualizar(&fijo);


}



void visualizar(struct trabajador *datos)

{


    printf("Nombre: %s",datos->nombre);


    printf("\nApellidos: %s",datos->apellidos);


    printf("\nEdad: %d",datos->edad);


    printf("\nPuesto: %s",datos->puesto);


}



 



Arrays de estructuras


     Es posible agrupar un conjunto de elementos de tipo estructura en un array. Esto se conoce como array de estructuras:




struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
};

struct trabajador fijo[20];
      Así podremos almacenar los datos de 20 trabajadores. Ejemplos sobre como acceder a los campos y sus elementos: para ver el nombre del cuarto trabajador, fijo[3].nombre;. Para ver la tercera letra del nombre del cuarto trabajador, fijo[3].nombre[2];. Para inicializar la variable en el momento de declararla lo haremos de esta manera:


struct trabajador fijo[20]={{"José","Herrero Martínez",29},{"Luis","García Sánchez",46}};


Typedef


     El lenguaje 'C' dispone de una declaración llamada typedef que permite la creación de nuevos tipos de datos. Ejemplos:




typedef int entero; /* acabamos de crear un tipo de dato llamado entero */
entero a, b=3; /* declaramos dos variables de este tipo */
      Su empleo con estructuras está especialmente indicado. Se puede hacer de varias formas:


Una forma de hacerlo:

struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;

};

typedef struct trabajador datos;
datos fijo,temporal;


Otra forma:

typedef struct
{
char nombre[20];
char apellidos[40];
int edad;
}datos;

datos fijo,temporal;

Estructuras

Concepto de estructura
     Una estructura es un conjunto de una o más variables, de distinto tipo, agrupadas bajo un mismo nombre para que su manejo sea más sencillo.
     Su utilización más habitual es para la programación de bases de datos, ya que están especialmente indicadas para el trabajo con registros o fichas.
    La sintaxis de su declaración es la siguiente:


struct tipo_estructura
{
tipo_variable nombre_variable1;
tipo_variable nombre_variable2;
tipo_variable nombre_variable3;
};
      Donde tipo_estructura es el nombre del nuevo tipo de dato que hemos creado. Por último, tipo_variable y nombre_variable son las variables que forman parte de la estructura.


     Para definir variables del tipo que acabamos de crear lo podemos hacer de varias maneras, aunque las dos más utilizadas son éstas:


Una forma de definir la estructura:

struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
char puesto[10];
};
struct trabajador fijo, temporal;


Otra forma:

struct trabajador
{
char nombre[20];
char apellidos[40];
int edad;
char puesto[10];
}fijo, temporal;
      En el primer caso declaramos la estructura, y en el momento en que necesitamos las variables, las declaramos. En el segundo las declaramos al mismo tiempo que la estructura. El problema del segundo método es que no podremos declarar más variables de este tipo a lo largo del programa. Para poder declarar una variable de tipo estructura, la estructura tiene que estar declarada previamente. Se debe declarar antes de la función main.


     El manejo de las estructuras es muy sencillo, así como el acceso a los campos ( o variables ) de estas estructuras. La forma de acceder a estos campos es la siguiente:


variable.campo;
      Donde variable es el nombre de la variable de tipo estructura que hemos creado, y campo es el nombre de la variable que forma parte de la estructura. Lo veremos mejor con un ejemplo basado en la estructura definida anteriormente:


temporal.edad=25;
      Lo que estamos haciendo es almacenar el valor 25 en el campo edad de la variable temporal de tipo trabajador.


     Otra característica interesante de las estructuras es que permiten pasar el contenido de una estructura a otra, siempre que sean del mismo tipo naturalmente:


fijo=temporal;
      Al igual que con los otros tipos de datos, también es posible inicializar variables de tipo estructura en el momento de su declaración:

      struct trabajador fijo={"Pedro","Hernández Suárez", 32, "gerente"};
      Si uno de los campos de la estructura es un array de números, los valores de la inicialización deberán ir entre llaves:


struct notas
{
char nombre[30];
int notas[5];
};

struct notas alumno={"Carlos Pérez",{8,7,9,6,10}};

Punteros

Un puntero es una variable que contiene la dirección de memoria de otra variable. Se utilizan para pasar información entre una función y sus puntos de llamada.
Declaración
     Su sintaxis es la siguiente:


tipo *nombre;
      Donde nombre es, naturalmente, el nombre de la variable, y tipo es el tipo del elemento cuya dirección almacena el puntero.


Operadores


     Existen dos operadores especiales para trabajar con punteros: & y *.


     El primero devuelve la dirección de memoria de su operando. Por ejemplo, si queremos guardar en el puntero x la dirección de memoria de la variable num, deberemos hacer lo siguiente:


x=&num;
      El segundo devuelve el valor de la variable cuya dirección es contenida por el puntero. Este ejemplo sitúa el contenido de la variable apuntada por x, es decir num, en la variable a:


a=*x;


Asignación


     Los punteros se asignan igual que el resto de las variables. El programa ejemplo mostrará las direcciones contenidas en p1 y p2, que será la misma en ambos punteros.



/* Asignaciones de punteros. */



#include <stdio.h>



main() /* Asignamos direcciones */

{


    int a;


    int *p1,*p2;


    p1=&a;


    p2=p1;


    printf("%p %p",p1,p2);


}



Aritmética de direcciones


     Es posible desplazar un puntero recorriendo posiciones de memoria. Para ello podemos usar los operadores de suma, resta, incremento y decremento (+, -, ++, - -). Si tenemos un puntero ( p1 ) de tipo int ( 2 bytes ), apuntando a la posición 30000 y hacemos: p1=p1+5; el puntero almacenará la posición 30010, porque apunta 5 enteros por encima ( 10 bytes más ).

Arreglos

Un array es un identificador que referencia un conjunto de datos del mismo tipo. Imagina un tipo de dato int; podremos crear un conjunto de datos de ese tipo y utilizar uno u otro con sólo cambiar el índice que lo referencia. El índice será un valor entero y positivo. En C los arrays comienzan por la posición 0.
Vectores
     Un vector es un array unidimensional, es decir, sólo utiliza un índice para referenciar a cada uno de los elementos. Su declaración será:


tipo nombre [tamaño];


 



Podemos inicializar (asignarle valores) un vector en el momento de declararlo. Si lo hacemos así no es necesario indicar el tamaño. Su sintaxis es:




tipo nombre []={ valor 1, valor 2...}
      Ejemplos:


int vector[]={1,2,3,4,5,6,7,8};
char vector[]="programador";
char vector[]={'p','r','o','g','r','a','m','a','d','o','r'};


Una particularidad con los vectores de tipo char (cadena de caracteres), es que deberemos indicar en que elemento se encuentra el fin de la cadena mediante el caracter nulo (\0). Esto no lo controla el compilador, y tendremos que ser nosotros los que insertemos este caracter al final de la cadena.


     Por tanto, en un vector de 10 elementos de tipo char podremos rellenar un máximo de 9, es decir, hasta vector[8]. Si sólo rellenamos los 5 primeros, hasta vector[4], debemos asignar el caracter nulo a vector[5]. Es muy sencillo: vector[5]='\0'; .



 



Podemos ver que en el for se encuentran dos condiciones:


1.- Que no se hayan rellenado todos los elementos (i<19).


2.- Que el usuario no haya pulsado la tecla ENTER, cuyo código ASCII es 13. (cadena[x-i]!=13).


     También podemos observar una nueva función llamada getche( ), que se encuentra en conio.h. Esta función permite la entrada de un caracter por teclado. Después se encuentra un if, que comprueba si se ha rellenado todo el vector. Si es cierto, coloca el caracter nulo en el elemento nº20 (cadena[19]). En caso contrario tenemos el else, que asigna el caracter nulo al elemento que almacenó el caracter ENTER.


     En resumen: al declarar una cadena deberemos reservar una posición más que la longitud que queremos que tenga dicha cadena.


.- Llamadas a funciones con arrays


     Como ya se comentó en el tema anterior, los arrays únicamente pueden ser enviados a una función por referencia. Para ello deberemos enviar la dirección de memoria del primer elemento del array. Por tanto, el argumento de la función deberá ser un puntero.




/* Envío de un array a una función. */

#include <stdio.h>

void visualizar(int []); /* prototipo */
main() /* rellenamos y visualizamos */
{
int array[25],i;
for (i=0;i<25;i++)
{
printf("Elemento nº %d",i+1);
scanf("%d",&array[i]);
}
visualizar(&array[0]);
}

void visualizar(int array[]) /* desarrollo */
{
int i;
for (i=0;i<25;i++) printf("%d",array[i]);
}


En el ejemplo se puede apreciar la forma de enviar un array por referencia. La función se podía haber declarado de otra manera, aunque funciona exactamente igual:



	declaración o prototipo
void visualizar(int *);

desarrollo de la función
void visualizar(int *array)