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)

Funciones

Las funciones son bloques de código utilizados para dividir un programa en partes más pequeñas, cada una de las cuáles tendrá una tarea determinada.
     Su sintaxis es:


tipo_función nombre_función (tipo y nombre de argumentos)
{
bloque de sentencias
}


tipo_función: puede ser de cualquier tipo de los que conocemos. El valor devuelto por la función será de este tipo. Por defecto, es decir, si no indicamos el tipo, la función devolverá un valor de tipo entero ( int ). Si no queremos que retorne ningún valor deberemos indicar el tipo vacío ( void ).


nombre_función: es el nombre que le daremos a la función.


tipo y nombre de argumentos: son los parámetros que recibe la función. Los argumentos de una función no son más que variables locales que reciben un valor. Este valor se lo enviamos al hacer la llamada a la función. Pueden existir funciones que no reciban argumentos.


bloque de sentencias: es el conjunto de sentencias que serán ejecutadas cuando se realice la llamada a la función.


     Las funciones pueden ser llamadas desde la función main o desde otras funciones. Nunca se debe llamar a la función main desde otro lugar del programa. Por último recalcar que los argumentos de la función y sus variables locales se destruirán al finalizar la ejecución de la misma.



Paso de parámetros a una función


     Como ya hemos visto, las funciones pueden retornar un valor. Esto se hace mediante la instrucción return, que finaliza la ejecución de la función, devolviendo o no un valor.


     En una misma función podemos tener más de una instrucción return. La forma de retornar un valor es la siguiente:




return ( valor o expresión );


     El valor devuelto por la función debe asignarse a una variable. De lo contrario, el valor se perderá.

    



Existen dos formas de enviar parámetros a una función:

Por valor: cualquier cambio que se realice dentro de la función en el argumento enviado, NO afectará al valor original de las variables utilizadas en la llamada. Es como si trabajaramos con una copia, no con el original. No es posible enviar por valor arrays, deberemos hacerlo por referencia.


Por referencia: lo que hacemos es enviar a la función la dirección de memoria donde se encuentra la variable o dato. Cualquier modificación SI afectará a las variables utilizadas en la llamada. Trabajamos directamente con el original.



 



Para enviar un valor por referencia se utiliza el símbolo & ( ampersand ) delante de la variable enviada. Esto le indica al compilador que la función que se ejecutará tendra que obtener la dirección de memoria en que se encuentra la variable.


     Vamos a fijarnos en los ejemplos. En el ejemplo anterior podrás comprobar que antes y después de la llamada, las variables mantienen su valor. Solamente se modifica en la función intercambio ( paso por valor ).


     En el siguiente ejemplo podrás ver como las variables intercambian su valor tras la llamada de la función ( paso por referencia ).


     Las variables con un * son conocidas como punteros, el único dato en 'C' que puede almacenar una dirección de memoria.

Bucles

Los bucles son estructuras que permiten ejecutar partes del código de forma repetida mientras se cumpla una condición.
     Esta condición puede ser simple o compuesta de otras condiciones unidas por operadores lógicos.
Sentencia WHILE
     Su sintaxis es:


while (condición) sentencia;


     Con esta sentencia se controla la condición antes de entrar en el bucle. Si ésta no se cumple, el programa no entrará en el bucle.

     Naturalmente, si en el interior del bucle hay más de una sentencia, éstas deberán ir entre llaves para que se ejecuten como un bloque.



Sentencia DO...WHILE


     Su sintaxis es:




do{
sentencia1;
sentencia2;
}while (condición);


     Con esta sentencia se controla la condición al final del bucle. Si ésta se cumple, el programa vuelve a ejecutar las sentencias del bucle.

     La única diferencia entre las sentencias while y do...while es que con la segunda el cuerpo del bucle se ejecutará por lo menos una vez.



Sentencia FOR


     Su sintaxis es:




for (inicialización;condición;incremento){
sentencia1;
sentencia2;
}
      La inicialización indica una variable (variable de control) que condiciona la repetición del bucle. Si hay más, van separadas por comas:


for (a=1,b=100;a!=b;a++,b- -){


Sentencia BREAK


     Esta sentencia se utiliza para terminar la ejecución de un bucle o salir de una sentencia SWITCH.


Sentencia CONTINUE


     Se utiliza dentro de un bucle. Cuando el programa llega a una sentencia CONTINUE no ejecuta las líneas de código que hay a continuación y salta a la siguiente iteración del bucle.

Operadores Lógicos

Los operadores lógicos básicos son tres:

	&&	AND
|| OR
! NOT (El valor contrario)


     Estos operadores actúan sobre expresiones lógicas. Permiten unir expresiones lógicas simples formando otras más complejas.

Sentencia Condicionales

Este tipo de sentencias permiten variar el flujo del programa en base a unas determinadas condiciones.
     Existen varias estructuras diferentes:
Estructura IF...ELSE
     Sintaxis:


if (condición) sentencia;
      La sentencia solo se ejecuta si se cumple la condición. En caso contrario el programa sigue su curso sin ejecutar la sentencia.


     Otro formato:


if (condición) sentencia1;
else sentencia2;


     Si se cumple la condición ejecutará la sentencia1, sinó ejecutará la sentencia2. En cualquier caso, el programa continuará a partir de la sentencia2.



Estructura SWITCH


     Esta estructura se suele utilizar en los menús, de manera que según la opción seleccionada se ejecuten una serie de sentencias.


     Su sintaxis es:




switch (variable){
case contenido_variable1:
sentencias;
break;
case contenido_variable2:
sentencias;
break;
default:
sentencias;
}
      Cada case puede incluir una o más sentencias sin necesidad de ir entre llaves, ya que se ejecutan todas hasta que se encuentra la sentencia BREAK. La variable evaluada sólo puede ser de tipo entero o caracter. default ejecutará las sentencias que incluya, en caso de que la opción escogida no exista.

Operadores Relacionales

Los operadores relacionales se utilizan para comparar el contenido de dos variables.
     En C existen seis operadores relacionales básicos:

	>	Mayor que
< Menor que
>= Mayor o igual que
<= Menor o igual que
== Igual que
!= Distinto que
      El resultado que devuelven estos operadores es 1 para Verdadero y 0 para Falso.


     Si hay más de un operador se evalúan de izquierda a derecha. Además los operadores == y != están por debajo del resto en cuanto al orden de precedencia.

Sentencia scanf( )

     La rutina scanf permite entrar datos en la memoria del ordenador a través del teclado.
     El prototipo de la sentencia scanf es el siguiente:


scanf(control,arg1,arg2...);
      En la cadena de control indicaremos, por regla general, los modificadores que harán referencia al tipo de dato de los argumentos. Al igual que en la sentencia printf los modificadores estarán formados por el caracter % seguido de un caracter de conversión. Los argumentos indicados serán, nuevamente, las variables.


     La principal característica de la sentencia scanf es que necesita saber la posición de la memoria del ordenador en que se encuentra la variable para poder almacenar la información obtenida. Para indicarle esta posición utilizaremos el símbolo ampersand ( & ), que colocaremos delante del nombre de cada variable. ( Esto no será necesario en los arrays ).

Sentencia printf( )

     La rutina printf permite la aparición de valores numéricos, caracteres y cadenas de texto por pantalla.
     El prototipo de la sentencia printf es el siguiente:


printf(control,arg1,arg2...);


     En la cadena de control indicamos la forma en que se mostrarán los argumentos posteriores. También podemos introducir una cadena de texto ( sin necesidad de argumentos ), o combinar ambas posibilidades, así como secuencias de escape.


     En el caso de que utilicemos argumentos deberemos indicar en la cadena de control tantos modificadores como argumentos vayamos a presentar.


     El modificador está compuesto por el caracter % seguido por un caracter de conversión, que indica de que tipo de dato se trata.



 



Los modificadores más utilizados son:



	%c	Un único caracter
%d Un entero con signo, en base decimal
%u Un entero sin signo, en base decimal
%o Un entero en base octal
%x Un entero en base hexadecimal
%e Un número real en coma flotante, con exponente
%f Un número real en coma flotante, sin exponente
%s Una cadena de caracteres
%p Un puntero o dirección de memoria


El formato completo de los modificadores es el siguiente:




% [signo] [longitud] [.precisión] [l/L] conversión




Signo: indicamos si el valor se ajustará a la izquierda, en cuyo caso utilizaremos el signo menos, o a la derecha ( por defecto ).


Longitud: especifica la longitud máxima del valor que aparece por pantalla. Si la longitud es menor que el número de dígitos del valor, éste aparecerá ajustado a la izquierda.


Precisión: indicamos el número máximo de decimales que tendrá el valor.


l/L: utilizamos l cuando se trata de una variable de tipo long y L cuando es de tipo double.

Jerarquía de los Operadores


     Será importante tener en cuenta la precedencia de los operadores a la hora de trabajar con ellos:

	( )	Mayor precedencia
++, - -
*, /, %
+, - Menor precendencia
       Las operaciones con mayor precedencia se realizan antes que las de menor precedencia.

Operadores de Asignación


     La mayoría de los operadores aritméticos binarios explicados en el capítulo anterior tienen su correspondiente operador de asignación:

	=	Asignación simple
+= Suma
-= Resta
*= Multiplicación
/= División
%= Módulo (resto)



     Con estos operadores se pueden escribir, de forma más breve, expresiones del tipo:

	n=n+3 se puede escribir n+=3


k=k*(x-2) lo podemos sustituir por k*=x-2

Operadores Aritméticos

     Existen dos tipos de operadores aritméticos:
     Los binarios:

	+	Suma
- Resta
* Multiplicación
/ División
% Módulo (resto)
       y los unarios:

	++	Incremento (suma 1)
- - Decremento (resta 1)
- Cambio de signo

Incluir Ficheros Externos

Inclusión de ficheros
     En la programación en C es posible utilizar funciones que no estén incluidas en el propio programa. Para ello utilizamos la directiva #include, que nos permite añadir librerías o funciones que se encuentran en otros ficheros a nuestro programa.
     Para indicar al compilador que vamos a incluir ficheros externos podemos hacerlo de dos maneras (siempre antes de las declaraciones).
     1. Indicándole al compilador la ruta donde se encuentra el fichero.


#include "misfunc.h"
#include "c:\includes\misfunc.h"
      2. Indicando que se encuentran en el directorio por defecto del compilador.


#include <misfunc.h>

Secuencias de Salidas

Secuencias de escape
     Ciertos caracteres no representados gráficamente se pueden representar mediante lo que se conoce como secuencia de escape.
     A continuación vemos una tabla de las más significativas:

	\n	salto de línea
\b retroceso
\t tabulación horizontal
\v tabulación vertical
\\ contrabarra
\f salto de página
\' apóstrofe
\" comillas dobles
\0 fin de una cadena de caracteres

Variables y Constantes

Las variables
     Una variable es un tipo de dato, referenciado mediante un identificador (que es el nombre de la variable). Su contenido podrá ser modificado a lo largo del programa.
     Una variable sólo puede pertenecer a un tipo de dato. Para poder utilizar una variable, primero tiene que ser declarada:

<tipo> <nombre>



     Es posible inicializar y declarar más de una variable del mismo tipo en la misma sentencia:




<tipo><nombre1>,<nombre2>=<valor>,<nombre4>




Constantes


     Al contrario que las variables, las constantes mantienen su valor a lo largo de todo el programa.


     Para indicar al compilador que se trata de una constante, usaremos la directiva #define:

 




#define <identificador> <valor>




Nota:     Observa que no se indica el punto y coma de final de sentencia ni tampoco el tipo de dato.


     La directiva #define no sólo nos permite sustituir un nombre por un valor numérico, sinó también por una cadena de caracteres.


     El valor de una constante no puede ser modificado de ninguna manera.



Ejemplo



 



/* Uso de las constantes y variables */



#include <stdio.h>



#define pi 3.1416



#define escribe printf



main() /* Calcula el perímetro */



{



               int r;



               escribe("Introduce el radio: ");



              scanf("%d",&r);



              escribe("El perímetro es: %f",2*pi*r);



}

Tipo de Datos

En 'C' existen básicamente cuatro tipos de datos, aunque como se verá después, podremos definir nuestros propios tipos de datos a partir de estos cuatro. A continuación se detalla su nombre, el tamaño que ocupa en memoria y el rango de sus posibles valores.

TIPO Tamaño Rango de valores

nombre. tamaño. rango.

char 1 byte -128 a 127

int 2 bytes -32768 a 32767

float 4 bytes 3'4 E-38 a 3'4 E+38

double 8 bytes 1'7 E-308 a 1'7 E+308

Calificadores de tipo
Los calificadores de tipo tienen la misión de modificar el rango de valores de un determinado tipo de variable. Estos calificadores son cuatro:

  • signed
    Le indica a la variable que va a llevar signo. Es el utilizado por defecto.

nombre tamaño rango.

signed char 1 byte -128 a 127

signed int 2 bytes -32768 a 32767

  • unsigned
    Le indica a la variable que no va a llevar signo (valor absoluto).
nombre            tamaño            rango
unsigned char 1 byte  0 a 255

unsigned int 2 bytes 0 a 65535


  • short
    Rango de valores en formato corto (limitado). Es el utilizado por defecto.
    nombre          tamaño  rango de valores

    short char
    1 byte -128 a 127

    short int 2 bytes -32768 a 32767



    • long
      Rango de valores en formato largo (ampliado).


    nombre tamaño rango de valores

    long int
    4 bytes -2.147.483.648 a 2.147.483.647

    long double 10 bytes -3'36 E-4932 a 1'18 E+4932

    Estructura de un programa en C

    Ejemplo de la estructura de un programa en C

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

    //variables globales
    int contador=0;

    //prototipo-declaracion de las funciones
    int incrementar(int i);

    //funcion principal
    void main(){
         //variables locales
       char msg[]="Hola mundo!";
       printf("\n%s",msg);
       printf("\nContador: %i",contador);
       contador=incrementar(contador);
       printf("\nContador: %i",contador);
       getch();
    }

    //implementacion de las funciones
    int incrementar(int i){
         return ++i;
    }