Técnicas de Programación 3.1.- Lenguaje de programación C Introducción Aunque nosotros vamos a programar en C++ haremos una descripción completa de programación en C. Es por ello que en primer lugar diremos que C++ puede ser considerado como una extensión de C y que casi cualquier programa escrito en ANSI C puede ser compilado con un compilador de C++, es decir que un programa con extensión.c puede ser convertido en un programa C++ simplemente cambiando su extensión a.cpp, aunque C++ tiene muchas más posibilidades que C. Vamos a recordar también que la memoria de un ordenador está constituida por unidades elementales, los bits, que no son más que unos o ceros. Aunque un bit aislado tiene muy escasa utilidad; un conjunto adecuado de bits puede almacenar casi cualquier tipo de información. Para facilitar el acceso a la memoria esta se organiza por grupos de 8 bits denominados bytes. La memoria se mide en kbytes (1024 bytes), Mbytes (1024 Kbytes) y Gbytes (1024 Mbytes). La CPU de un ordenador accede o direcciona unidades de memoria denominadas word (palabra) de varios bytes (2, 4, 8 bytes o lo que es lo mismo 16, 32, 64 bits); y es aquí donde se almacén tanto programas como datos, siendo el sistema operativo, y nuestro propio programa, el encargado de gestionar esa memoria. Las necesidades de memoria dependen del tipo de dato (por ejemplo, un carácter alfanumérico ocupa un byte, mientras que un número real puede ocupar 8 bytes). Cada posición de memoria se identifica mediante un número que es su dirección, pero esto no resulta ni cómodo ni práctico ya que no existe relación nemotécnica entre la dirección de memoria y el dato que contiene y además esta dirección puede cambiar en el transcurso de una misma ejecución del programa. 1
Introducción Dichas estas dificultades para referirse a un dato por medio de su dirección de memoria, lo habitual es usar identificadores, que son nombres simbólicos para referirse a datos o programas determinados. Por ejemplo, es lógico utilizar un dato denominado Precio para representar lo que cuesta un determinado producto. El lenguaje C tiene sus propias reglas para elegir estos identificadores dando gran libertad para nombrar variables y programas, teniendo la precaución de respetar las reglas del lenguaje y de no usar palabras reservadas o keywords (utilizadas por el propio lenguaje). El lenguaje C fué desarrollado por Denis Ritchie para Bell Labs y fue posteriormente estandarizado por un comité del ANSI (American National Standard Institute) con objeto de garantizar su portabilidad entre distintos ordenadores, originándose el universal ANSI C. Funciones en C Una función es una porción de código o programa que realiza una determinada tarea. Las funciones de C constituyen uno de sus aspectos más potentes, siendo muy importante entender bien su funcionamiento y sus posibilidades. Las aplicaciones informáticas suelen contener un número muy elevado (hasta cientos de miles) de líneas de código fuente. A medida que los programas se desarrollan y aumentan de tamaño, se convierten en sistemas poco manejables. Por esto surge la necesidad de dividir en módulos más pequeño el gran programa. Son estos módulos los que en lenguaje C se denominan funciones o functions (en otros lenguajes se denominan (subprogramas, subrutinas o procedimientos). En definitiva la idea va a ser: dividir un programa grande en funciones más pequeñas que serán llamadas por el programa principal; éstas a su vez pueden llamar a otras funciones y así sucesivamente. Una función debe tener su identificador o nombre, que será el que se utilice para referirse a ella desde el resto del programa. En una función de C debemos distinguir tres aspectos: Definición Declaración Llamada. Para poder explicar estos aspectos debemos primero conocer los conceptos de valor de retorno y argumentos. 2
Definición, Declaración, Llamada, Valor de retorno y argumentos de una función. Una funciones en C se llama por su nombre, seguido de los argumentos, en una sentencia del programa principal o desde otra función. Los argumentos son datos que se envían a la función incluyéndolos entre paréntesis a continuación del nombre y separados por comas. Por ejemplo, existe una función denominada pow(x,y) que calcula x elevado a y, que podemos llamar escribiendo la siguiente sentencia: pow(x,y); Siendo: pow el nombre de la función x e y los argumentos, que son los datos necesarios para calcular el resultado deseado. Podemos ahora preguntarnos y el resultado?. Pues bien, en el ejemplo el resultado es el valor de retorno de la función. Otra forma de llamar a esta función utilizando el resultado podría ser la siguiente: cubos = pow(x, 3); Para poder llamar a una función es necesario que su definición este en algún sitio, ya sea programa o en un fichero fuente. La definición de una función es el código (conjunto de sentencias o instrucciones) necesario para que la función pueda realizar su tarea cuando la llamamos; estando precisamente en esa definición el tipo del valor de retorno y de los argumentos. En concreto la función pow está definida en un fichero de cabecera llamado math.h que incluye otras muchas funciones matemáticas. Entrada y salida estándar En lenguaje C no existen palabras reservadas para realizar entradas por teclado y salidas por pantalla. Para ello debemos usar dos funciones, una de entrada y otra de salida, proporcionadas por la biblioteca estándar de C, estas funciones son printf, para mostrar datos en pantalla, y scanf, para obtener datos desde el teclado, aunque existen otras que estudiaremos más adelante. La función printf. Esta función permite mostrar por pantalla (salida estándar) los valores o datos obtenidos de la evaluación de una lista de argumentos. Para llamar a esta función utilizaremos la siguiente sintaxis: printf(cadena de control [, argumento, argumento, --- ]); 3
La función printf. Los argumentos o parámetros se emplean para transferir datos de un programa a otro, por lo que cuando invocamos a la función printf, a ésta se le pasa una lista de argumentos (pueden ser expresiones). Los valores o datos obtenidos de la evaluación de esa lista de expresiones son los que se van a mostrar por la pantalla. En la cadena de control (una cadena de caracteres que debemos escribir entre comillas dobles) es donde debemos indicar el formato de salida de los datos que se van a mostrar por la pantalla. Para ello tenemos las siguientes posibilidades: Texto ordinario. Especificadores de formato. Secuencias de escape. Texto ordinario. Se trata de texto normal y corriente. Un ejemplo básico de uso de la función printf es el siguiente: #include <stdio.h> int main() { printf( "Hola" ); //función printf sin ningún argumento, excepto la cadena de control. return 0; } Especificadores de formato. Cuando a la función printf se le pasa una lista de argumentos, debemos escribir un especificador de formato para cada argumento. Estos especificadores de formato establecen el formato de salida por pantalla de los argumentos. Una especificación de formato se compone de: %[flags] [ancho] [.precisión] tipo 4
La función printf. Especificadores de formato. Para indicar un formato comenzamos con % y algunos de los elementos siguientes: Elemento flags Significado - Justifica el resultado a la izquierda que por defecto se hace a la derecha. + Antepone + o - al valor de salida. Por defecto solo se pone el signo - a los valores negativos. 0 Rellena con ceros no significativos hasta el ancho especificado. Blanco Ancho # Precisión * Antepone un espacio en blanco al valor positivo de salida. Usado junto con + se ignora. Si se usa con los especificadores de formato o, x o X antepone al valor de salida 0, 0x o 0X respectivamente. Si se usa con los especificadores de formato e, E o f fuerza que el valor de salida tenga en todos los casos el punto decimal. Si se usa con los especificadores de formato g o G fuerza que el valor de salida tenga en todos los casos el punto decimal no truncando los ceros arrastrados. Con los especificadores de formato c, d, i, u o s se ignora. Minimo número de posiciones para la salida. Si el valor a escribir usa más posiciones el ancho es autoincrementado. Su significado depende del tipo de salida. Explicaremos seguidamente el significado de la precisión en función del tipo. El ancho y la precisión pueden ser sustituidos por un * tomando estos campos el valor correspondiente al siguiente argumento entero. 5
La función printf. Especificadores de formato. Elemento tipo d (int) enteros con signo en base 10 i (int) enteros con signo en base 10 u (int) enteros sin signo en base 10 o (int) enteros sin signo en base 8 Significado x (int) enteros sin signo en base 16 (0123456789abcdef ) X f e E g G c s (int) enteros sin signo en base 16 (0123456789ABCDEF) (double) valor con signo de la forma -nnn.ddd. El número de digitos antes del punto depende del número y el de decimales de la precisión, que si no se especifica se establece por defecto en 6. (double) valor con signo de la forma -n.dddde±eee (double) valor con signo de la forma -n.dddde±eee (double) valor con signo en formato f o e según convenga para el valor y la precisión dados. Es identico a g con la salvedad de que si tiene que introducir el exponente lo hace con E en lugar de con e. (int) caracter correspondiente al byte menos significativo. Escribir una cadena de caracteres hasta encontrar el primer carácter nulo ( \0'). 6
La función printf. Especificadores de formato. A continuación describimos el significado de precisión en función del tipo. Tipo d i u o x X e E f Significado de precisión Especifica el número mínimo de digitos que se tienen que escribir rellenando con ceros a la izquierda si es necesario. Especifica el número de dígitos a escribir después del punto decimal. g G Especifica el número máximo de dígitos significativos que se tienen que escribir, que por defecto es de 6. c s h l L La precisión no tiene efecto. Especifica el número máximo de caracteres que se escribirán ignorando los sobrantes. Prefijo para los tipos d, i, o, x y X que especifica el argumento como short int o con una u para especificar short unsigned int. Prefijo para los tipos d, i, o, x y X que especifica el argumento como long int o con una u para especificar long unsigned int. Prefijo para los tipos e, E, f, g y G para especificar tipo double antes que float. Prefijo para los tipos e, E, f, g y G para especificar tipo long double. El siguiente ejemplo comentado nos aclarará más todos los conceptos descritos. El código completo del programa para una aplicación de consola es el siguiente: // Para usar printf debemos incluir el fichero de cabecera stdio.h (stdio proviene de STanDar Input Output) #include <stdio.h> // Para poder detener la ejecución del programa usaremos la // función getch() para lo que debemos incluir el //fichero conio.h ( conio proviene de CONsole Input Output) #include <conio.h> //--------------------------------------------------------------------------- int main() { 7
La función printf. //**************************************************************************** // Declaramos variables int a = 12345, ancho=10, precision=2; float b=67.8989f; double valor = -30.125; //**************************************************************************** // En primer lugar vamos a escribir el dato a usando la siguiente linea de comandos:printf(%d\n,a): printf("%d\n",a); // El formato %d especifica el entero a en base decimal. El formato \n provoca un avance a la linea siguiente //**************************************************************************** // Vamos a escribir una cadena de caracteres sobre un ancho especificado mediante la siguiente linea de comandos: printf("\n%10s\n%10s\n%10s\n","abc","abcdef","1234567890"); // %10s para escribir las cadenas ajustadas a la derecha sobre un ancho de 10 printf("\n%-10s\n%-10s\n","abc","abcdef"); // %-10s para escribir las cadenas ajustadas a la izquierda printf("\n"); // avanza una linea //**************************************************************************** // Vamos ahora a escribir el valor real b mediante la siguiente linea: printf("%.22f\n",b); // La f indica un valor real de tipo float o double. El formato no especifica el ancho, por lo que se usan tantas // posiciones como sean necesarias para visualizar el resultado, pero si se da el número de decimales, 2. // La parte decimal se escribe truncando las cifras que sobran y redondeando // el resultado aumentando en uno la // cifra anterior si la truncada es >= 5. printf("%15.2f\n",b); 8
La función printf. //**************************************************************************** // Veamos el uso de * para especificar formato printf("%*.*f\n", ancho,precision,valor); // El resultado queda justificado a la derecha con un ancho de 10 posiciones, de // las cuales dos son decimales. printf("%-*.*f", ancho,precision,valor); // El resultado queda justificado a la izquierda //**************************************************************************** // Finalizacíon de la función main printf("\n%s","pulse una tecla para salir"); // Muestra el mensaje Pulse una tecla para salir getch(); // detiene la ejecución del programa hasta que pulsemos una tecla return 0; } Además de implementar el ejemplo con estos y otros especificadores de formato podemos convertir los comentarios en cadenas que se muestren por pantalla. A continuación vemos un ejemplo descriptivo del uso de printf para mostrar por pantalla el resultado de 2 al cubo. La parte que aparece entre comillas indica los caracteres que queremos visualizar en pantalla con el formato que especifica el modificador % para ser sustituido por el valor correspondiente de la lista de valores (lf indica que el formato es long float). 9
La función printf. Secuencias de escape. Una secuencia de escape siempre representa a un carácter del código ASCII. Dichos caracteres se pueden dividir en imprimibles (símbolos usados para escribir) y no imprimibles (representan acciones o secuencias de escape). La forma más sencilla de escribir una secuencia de escape es con el carácter barra invertida (\), seguido de un carácter especial. Por tanto, cuando en la cadena de control de la función printf se escribe una secuencia de escape, o bien se mostrará un carácter por pantalla, o bien se realizará una acción. Las secuencias de escape en C son: Secuancia de escape '\n' '\r' '\f' '\t' '\b' '\'' '\ ' '\\' '\?' Significado Nueva línea Return Nueva página Tabulación horizontal Retroceso Comilla simple Comilla doble Contrabarra Interrogación La función scanf. La función scanf permite asignar a una o más variables valores o datos obtenidos desde la entrada estándar o teclado. Su sintaxis es: scanf(cadena de control [, argumento, argumento, --- ]); En la cadena de control debemos indicar el formato de entrada de los datos que vamos a entrar mediante teclado. Para ello tenemos las posibilidades de especificadores de formato vistos para la función printf. Por ahora no nos ocuparemos más de aspectos referentes a declaración y uso de funciones que veremos más adelante. Hemos introducido aquí estos conceptos porque los necesitamos para explicar la función main que vemos seguidamente y para poder desarrollar los ejemplos básicos de programación en C que iremos viendo. 10
La función scanf. En un ejemplo como el siguiente: #include <stdio.h> int main() { int var1,var2; printf( "Introducir un numero: " ); scanf( "%d", &var1 ); printf( "Introducir otro numero: " ); scanf( "%d", &var2 ); printf( "Los valores introducidos son: %d, %d ", var1, var2 ); printf("\n%s","una tecla para salir"); getch(); return 0; } Obtendremos un resultado similar a: Si creamos la aplicación podemos observar que cuando se ejecuta scanf la primera vez el programa se detiene esperando que el usuario teclee un dato de entrada (este se almacena temporalmente, en el buffer o memoria intermedia de la entrada estándar), y es cuando pulsamos la tecla Enter cuando a la variable se le asigna el valor. Además, se produce un salto de línea automático, de forma que, después de introducir el número 5, la siguiente instrucción se muestra una línea más abajo. 11
La función scanf. De la misma forma, después de la segunda instrucción scanf también se produce un salto de línea automático. Vemos que con este ejemplo todo ha ido muy bien, pero veamos otro ejemplo en el que lo que se solicita son caracteres y no datos numéricos. #include <stdio.h> #include <conio.h> int main() { char car1, car2, car3; printf( "Introducir un caracter: " ); scanf( "%c", &car1); printf( "Introducir un segundo caracter: " ); scanf( "%c", &car2 ); printf( "Introducir un tercer caracter: " ); scanf( "%c", &car3 ); printf( "Los valores son: %c, %c, %c ", car1, car2, car3 ); printf("\n%s","una tecla para salir"); getch(); return 0; } Obtendremos un resultado similar a: 12
La función scanf. Vamos que en esta ocasión el programa no se ejecuta correctamente y, además por qué no se ejecuta la segunda instrucción scanf?. Lo que ocurre en realidad es que cuando se ejecuta la primera instrucción de entrada scanf después de asignar el carácter 'a' a la variable car1, se produce un salto de línea automático, pero, en el buffer del teclado también se ha quedado almacenada la secuencia de escape (\n), que es, precisamente, un carácter. En consecuencia, cuando se ejecuta la instrucción scanf( "%c", &var2 ); a la variable car2 se le asigna el salto de línea almacenado en el buffer de la entrada estándar, y la ejecución del programa continua con la siguiente instrucción. Ahora, el buffer vuelve a estar vacío y, por tanto, la entrada de la variable car3 sí que se ejecuta de forma correcta. Este extremos lo podemos comprobar si sustituimos la instrucción por esta: En pantalla veremos algo similar a: printf( "Los valores son: %c, %c, %c ", car1, car2, car3 ); printf( "Los valores son: %d, %d, %d ", car1, car2, car3 ); Los números 97, 10 y 99 que aparecen se corresponden a los caracteres ASCII 'a', LF (Salto de Línea) y 'c', respectivamente. 13
La función fflush. Para resolver el problema anterior lo que debemos hacer antes de leer un carácter con scanf es limpiar o vaciar el buffer del teclado. Para este fin se utiliza la función fflush, que veremos como funciona modificando el código del ejemplo anterior de la siguiente forma: #include <stdio.h> #include <conio.h> int main() { char car1, car2, car3; printf( "Introducir un caracter: " ); scanf( "%c", &car1); fflush(stdin); printf( "Introducir un segundo caracter: " ); scanf( "%c", &car2 ); fflush(stdin); printf( "Introducir un tercer caracter: " ); scanf( "%c", &car3 ); printf( "Los valores son: %d, %d, %d ", car1, car2, car3 ); printf("\n%s","una tecla para salir"); getch(); return 0; } Con lo que obtenemos el siguiente resultado: Por ahora no nos ocuparemos más de aspectos referentes a declaración y uso de funciones que veremos más adelante. Hemos introducido aquí estos conceptos porque los necesitamos para explicar la función main que vemos seguidamente y para poder desarrollar los ejemplos básicos de programación en C que iremos viendo. 14
La función main Todo programa C debe tener un programa principal con el que comience la ejecución del mismo, siendo este programa principal una función denominada main() que está por encima de todas cualquier otra. La función main() tiene la forma siguiente: void main(void) { instrucción 1; instrucción 2;... } Las llaves de apertura y cierre es la forma que utiliza el lenguaje C para agrupar sentencias de modo que se comporten como una sentencia única debiendo todo el cuerpo de la función estar encerrado en estas llaves. Sintaxis en C Los componentes sintácticos (también denominados tokens) del lenguaje C se pueden dividir en: 0.- Palabras clave 1.- Identificadores 2.- Constantes 3.- Cadenas 4.- Operadores Antes de entrar en la definición de cada uno de ellos vamos a definir los elementos separadores, que pueden ser: uno o varios espacios en blanco, tabuladores, sangrías, caracteres de retorno de línea, etc. y los comentarios escritos por el programador. Estos elementos se usan para separar el resto de elementos y dar un aspecto más legible al código siendo ignorados por el compilador. 15
En C existe un número determinado de palabras clave o keywords que no podemos utilizar como identificadores. Estas palabras sirven para indicar determinadas tareas de cuyo detalle nos Sintaxis en C 1.- Palabras clave ocuparemos más adelante. La lista de las 32 palabras clave del ANSI C es: auto double int struct break else long switch case enum register typedef char extern return union const float short unsigned continue for signed void default goto sizeof volatile do if static while 2.- Identificadores En ANSI C las reglas para nombrar identificadores son: Se forman como una secuencia de letras minúsculas, mayúsculas del alfabeto sajón y números del 0 al 9. El carácter de subrayado (_) se considera como una letra. No pueden contener espacios en blanco, ni otros caracteres distintos de los citados, como (, * ;. : - + ñ, etc.). El primer carácter debe ser siempre una letra o un (_). Se distingue entre mayúsculas y minúsculas. Es decir, Cubo, cubo y CUBO son identificadores distintos. La longitud máxima para nombrar identificadores es de 31 caracteres. Es aconsejable dedicar un tiempo a elegir los identificadores de forma que nos permitan conocer a simple vista qué representan aunque tengamos que utilizar un número elevado de caracteres. Esto facilita la tarea de programación y, SOBRE TODO, la de corrección y mantenimiento de los programas. 16
Sintaxis en C 3.- Constantes Son valores que no cambian durante la ejecución de un programa como por ejemplo el número π. Las constantes en C pueden ser de los siguientes tipos: Numéricas. Valores numéricos, enteros o de coma flotante y números octales y hexadecimales. Carácter. Cualquier carácter individual encerrado entre comillas simples ('a', 'N', '-', etc.) se considera en C como una constante de tipo carácter, que es en realidad un número entero entre 0 y 255, o entre - 128 y 127. El código ASCII es el que establece la equivalencia entre cada carácter y su valor numérico correspondiente. Cadenas de caracteres. Cualquier conjunto de caracteres alfanuméricos encerrados entre comillas dobles. Por ejemplo: "numero 9". Constantes simbólicas. Se pueden definir mediante el preprocesador o por con la palabra clave const. En C++ se utiliza preferentemente esta segunda forma. 4.- Operadores Son signos que indican determinadas operaciones a realizar con las variables y/o constantes sobre las que actúan en el programa. Algunos tipos de operadores son: Aritméticos: +, -, *, /, % De asignación: =, +=, -=, *=, /= Relacionales: ==, <, >, <=, >=,!=) Lógicos: &&,,! y otros que veremos junto con estos con mucho más detalle posteriormente. Comentarios en C Los comentarios tienen como misión documentar o servir de explicación o aclaración sobre cómo está hecho el programa, de forma que pueda ser entendido por otra persona o por el propio programador transcurrido algún tiempo. Existen dos formas básicas de introducir comentarios en nuestros programas: en una sola línea o en varias líneas. 17
Comentarios en C Para una sola línea precederemos al comentario de los caracteres // y para introducir varias líneas de comentario comenzando por /* y finalizaremos con */. Ejemplos: pow(x,y); //Este comentario acompaña a una sentencia // Este comentario es de una linea. // Este comentario también es de un linea. /* Este comentario se compone de esta primera linea y de esta otra linea, y de esta tercera linea */ 18
Fin de la presentación 19