UNIDAD II FUNDAMENTOS DE PROGRAMACIÓN ......UNIDAD II FUNDAMENTOS DE PROGRAMACIÓN ESTRUCTURADA...

UNIDAD II FUNDAMENTOS DE PROGRAMACIÓN ESTRUCTURADA

Autores: Alejandra Gutierrez Reyes - Enrique Martínez Roldán - Academia de Computación – Ingenieria Eléctrica ESIME Zacatenco IPN

9

2.1. Estructura General de un Programa Es muy útil, sobre todo cuando se empieza a trabajar con un nuevo lenguaje, disponer de una plantilla con la estructura habitual y general de un programa en dicho lenguaje. Es de lo que tratará este tema. Se dice que C es un lenguaje estrictamente modular: todo el código debe estar ubicado en el interior de funciones. La función llamada main() es sólo eso, una función. Pero una función especial. Existe en todos los programas, porque contiene el algoritmo o módulo principal del programa. La ejecución de un programa siempre empieza por la primera línea de la función main(). La función main(), como todas las funciones de C, puede devolver un valor. El valor devuelto por main() debe ser de tipo entero. Esto se utiliza para pasar algún valor al programa que haya llamado al nuestro, que suele ser el sistema operativo. Si main() no devuelve un número entero al sistema operativo mediante una sentencia return, entonces nuestro programa devolverá un número desconocido. Moraleja: es una buena idea incluir un return al final de la función main(). Generalmente, la devolución de un 0 indica al sistema operativo que el programa a finalizado sin problemas, mientras que cualquier otro valor señala que se ha producido algún error.

Por lo tanto, la forma habitual de la función main() será: int main(void) { ...instrucciones del algoritmo principal... return 0; }

Observa que main() no tiene argumentos, por lo que aparece el identificador void entre paréntesis en la declaración.

Es posible que se vea una definición de main() con argumentos, algo así:

int main(int argc, char* argv[]) { ...instrucciones del algoritmo principal... return 0; }

Esos dos argumentos sirven para capturar parámetros de entrada desde la línea de comandos.

En general, un programa en C consta de las siguientes partes:

• Directivas al procesador. • Definición de tipos de datos. • Declaración de variables. • Definición de funciones.

Aspectos importantes a definir:

1.- Comentarios:

Los comentarios en C comienzan con la secuencia '/*' y termina con la secuencia '*/'. Todo lo que se encuentre entre estas dos secuencias es omitido por el compilador y solo nos sirve para poner notas o anotaciones que nos sean útiles para ayuda a nuestro código (jamás serán compiladas ni ejecutadas por C). Algunos compiladores (no todos) soportan el anidamiento de comentarios (comentarios dentro de comentarios), pero por no ser una facilidad común, no se



1

aconseja su utilización. El uso de comentarios en un programa es fundamental para su entendimiento. Una proporción 50%-50% (código-comentario) no es exagerada.

Existen dos maneras de colocar un comentario, el de un párrafo completo deben estar comprendido entre /*.....*/, y aquellos comentarios que son de una sola línea van con doble //. void main() /* Esta parte del programa es la cabecera principal */ { /* Llave que da inicio a la programación del cuerpo del

programa */ // Comentarios de 1 sola línea // Cuerpo del programa principal } // Llave que da fin a la programación del cuerpo del programa

2.- Directivas al procesador:

Las directivas al procesador se refiere, a que la etapa de compilación se realiza en dos fases, una en la que un procesador atiende todas las directivas que contiene el código fuente y la otra etapa es la traducción a código objeto.

Todas las directivas al procesador comienzan con el caracter '#', también llamadas bibliotecas, es un archivo que contiene las funciones estándar que se pueden usar en los programas. Entre esas funciones se encuentran todas las operaciones de entrada y salida de datos.

Cada función definida en la biblioteca estándar tiene asociada una cabecera (#include).

// Zona de ficheros de cabecera de las librerías #include <....... . h> // h de Head #include <....... . h>

Cabeceras de Programa Cabecera Propósito

<ctype.h> Manejo de caracteres <errno.h> Informes de error <float.h> Define valores en coma flotante dependientes de la implementación <math.h> Definiciones usadas en la biblioteca matemática <setjmp.h> Soporte para saltos no locales <stddef.h> Define algunas constantes de uso común <stdio.h> Soporte para E/S de archivos <stdlib.h> Declaraciones variables <string.h> Soporte para las funciones de cadena <time.h> Soporte para las funciones de tiempo del sistema

Tabla 2. Cabeceras

3.- Definición de funciones:

Todas las funciones se definen colocando primero el tipo de retorno (void significa que la función no retorna nada como resultado de su ejecución. Por defecto si no se coloca tipo de retorno, se asume que la función retorna un valor entero); al tipo de retorno le sigue el nombre (la función main posee un significado especial, ya que es la función que toma el control cuando se ejecuta el programa); le siguen los argumentos separados por comas y encerrados entre



1

paréntesis (aunque la función no reciba argumentos, se colocan los paréntesis vacios); y por último el cuerpo de la función encerrado entre llaves.

void main (void) // Programa principal típico de Turbo C {

// Llave de inicio del programa // Código del programa ....... ....... .......

} // fin del programa

4.- Definición de Tipos de Datos:

La definición o declaración de datos se hace de dos tipos; una llamada declaración global, que se hace antes del void main ( ) y la cual es reconocida por todo el programa y la declaración local que es conocida en el programa principal, y se incluye dentro del void main ( ).

// Zona de variables globales int valor; float media_total; /* Variables locales del algoritmo principal */ int a, b; float x, y;

Todo programa en C, desde el más pequeño hasta el más complejo, tiene una función principal denominada main(),que es la función que toma el control cuando se corre el programa. Además, por encima de main() deben aparecer los prototipos de funciones (y esto implica a los archivos de cabecera, si se utilizan funciones de librería) y las variables y constantes globales, si las hay. Por debajo de main() encontraremos el código del resto de funciones.

Por lo tanto, la estructura habitual de nuestros programas en C debería ser esta:

/* Comentario inicial: nombre del programa, del programador, fecha, etc. */ /* Archivos de cabecera (prototipos de funciones de librería) */ #include <archivo_cabecera.h> #include <archivo_cabecera.h> /* Prototipos de funciones escritas por nosotros */ float función1 (argumentos); float función2 (argumentos); /* Variables y constantes globales */ int variable_global; const char constante_global; #define PI 3.14



1

/* Algoritmo principal */ int main(void) { /* Variables locales del algoritmo principal */ int a, b; float x, y; ... ... /* Instrucciones del algoritmo principal */ ... función1(argumentos); ... función2(argumentos); ... return 0; } /* Código completo de las funciones escritas por nosotros */ float función1 (argumentos) { /* Variables locales e instrucciones de este subalgoritmo */ } float función2 (argumentos) { /* Variables locales e instrucciones de este subalgoritmo */ } El tema de funciones se verá posteriormente a detalle en el tema 2.3. Un punto importante es enfatizar que todas las líneas de las sentencias terminan con el carácter de ( ; ).

2.2. Tipos de Datos y Operadores Operadores Un operador es un carácter o grupo de caracteres que actúa sobre una, dos o más variables para realizar una determinada operación con un determinado resultado. Ejemplos comúnes de operadores son la suma (+), la diferencia (-), el producto (*), etc. Los operadores pueden ser unarios, binarios y ternarios, según actúen sobre uno, dos o tres operandos, respectivamente. En C existen muchos operadores de diversos tipos, que se verán a continuación. Ahora solo mencionaré los tipos de operadores que hay, ya que posteriormente se explicará con un poco mas de detalle cada uno de ellos. Operadores Aritméticos Los operadores aritméticos son los más sencillos de entender y de utilizar. Todos ellos son operadores binarios. En C se utilizan los cinco operadores siguientes: - Suma (+) - Resta (–) - Multiplicación (*) - División (/)



1

El quinto operador es el que proporciona el resto de la división (residuo) - Módulo (%) Todos estos operadores se pueden aplicar a constantes, variables y expresiones. El resultado es el que se obtiene de aplicar la operación correspondiente entre los dos operandos. El único operador que requiere una explicación adicional es el operador Módulo ( %). En realidad su nombre completo es resto o residuo de la división entera. Este operador se aplica solamente a constantes, variables o expresiones de tipo int. Con el objeto de dejar mas en claro lo anterior, su significado es evidente: 23 % 4 es 3, ya que el resto de dividir 23 por 4 es 3. Otro ejemplo seria; si a % b es cero entonces a es múltiplo de b. Como se verá más adelante, en los otros subtemas una expresión es un conjunto de variables y constantes y también de otras expresiones más sencillas relacionadas mediante distintos operadores. Un ejemplo de expresión en la que intervienen operadores aritméticos es el siguiente polinomio de grado 2 en la variable y: 9.0 - 5.0 * y + y * y / 3.0 Las expresiones pueden contener paréntesis (...) que agrupan a algunos de sus términos. Puede haber paréntesis contenidos dentro de otros paréntesis. El significado de los paréntesis coincide con el que se usa en las expresiones matemáticas, con algunas características importantes que se verán más adelante. En ocasiones, la introducción de caracteres espacio mejora la legibilidad de las expresiones. Operadores De Asignación Aritmética Estos resultan de la unión de los operadores aritméticos con el operador de asignación el signo (=), o sea: - Igual (=) - Suma igual (+=) - Resta igual (– =) - Multiplicación igual (*=) - División igual (/=) Estos operadores se aplican de la siguiente manera: ( x += 5 ), en este ejemplo se toma el operando de la izquierda lo suma con el operando de la derecha y lo asigna al operando de la izquierda, en este caso la variable x. Operadores de Incremento y Decremento El operador de incremento es el (++) y el de decremento es el (--), son operadores unarios los cuales tienen prioridad mas alta que otros operadores y sirven para incrementar o decrementar una unidad el valor de la variable a la que afectan. Ahora describiremos algunas características de los operadores; pre-incremento y post-incremento: Estos operadores pueden ir inmediatamente delante o detrás de la variable. Si preceden a la variable, ésta es incrementada antes de que el valor de dicha variable sea utilizado en la expresión en la que aparece. Si es la variable la que precede al operador, la variable es incrementada después de ser utilizada en la expresión. A continuación se presenta un ejemplo de estos operadores: i = 2; j = 2;



1

m = i++; /* después de ejecutarse esta sentencia m=2 e i=3*/ n = ++j; /* después de ejecutarse esta sentencia n=3 y j=3*/ Estos operadores son muy utilizados. Es importante entender muy bien por qué los resultados m y n del ejemplo anterior son diferentes. Operadores Relaciónales Estos establecen la magnitud relativa de dos elementos y son los siguientes:

Expresiones Lógicas: Expresión Significado a < b Es a menor que b a > b Es a mayor que b a == b Es a igual a b a != b Es a diferente o no igual a b a <= b Es a menor o igual a b a >=b Es a mayor o igual a b

Tabla 3. Expresiones Lógicas

Recordemos que estas operaciones nos dan resultados lógicos de 1 ó 0 es decir valores de verdadero o falso; lenguaje C considera todo valor no cero como un valor verdadero. Operadores Lógicos C proporciona operadores lógicos para combinar los resultados de varias condiciones. Una expresión compuesta es aquella que utiliza operadores como estos y que se pueden evaluar para obtener un único resultado de verdadero o falso. Dos de los operadores lógicos son binarios porque usan dos operandos, devuelven un resultado basado en los operandos recibidos y en el operador. AND ( && ): Este operador conocido como producto lógico retorna un valor de verdadero si los operandos son verdaderos. OR ( || ): El operador de suma lógica retorna un valor de verdadero si los operandos o uno de los operandos es verdadero. NOT ( ! ): Operador de negación, tiene por efecto invertir el resultado de la expresión que le sigue es decir si la expresión es verdadera después de aplicar este operador la expresión será falsa y viceversa. Los operadores lógicos tienen una prioridad bastante baja, menos que los operadores de igualdad pero mayor que el operador de asignación.

Jerarquía o Precedencia de Operadores Operadores Unario / Binario Comentario !, &, +, -, sizeof() *, /, % +, - <, <=, >, >= ==, != && || =

Unario Binario Binario Binario Binario Binario Binario Binario

Operadores Unarios Multiplicador Aritmético Adición Aritméticos Operadores Relaciónales Operadores de Igualdad Multiplicador Lógico Aditivo Lógico Operador de Asignación

Tabla 4. Jerarquía de Operadores



1

Los lenguajes de programación disponen de una serie de tipos de datos básicos, y proporcionan herramientas para crear estructuras a medida que faciliten el acceso a la información. Así en nuestro caso ficticio de resolver un sistema de ecuaciones podemos almacenar los coeficientes de cada ecuación con lo que utilizaríamos como tipo de dato los números, si planteásemos el problema desde un punto de vista matricial nos interesaría tener un tipo de datos matriz y lo ideal sería tener un tipo de datos ecuación. En este apartado describiremos los tipos básicos que proporciona el lenguaje C y dejaremos para temas posteriores la declaración de tipos complejos. El C dispone de estos tipos básicos: Para el sistema operativo MSDOS , en el símbolo del sistema de Windows XP (En TC++ 3.0 y Borland C++ 5.0):

Tipos de Datos y Rango: TIPOS FORMATO RANGO TAMAÑO DESCRIPCIÓN

Char %c -128 a 127 1 Para una letra o un dígito. unsigned char %u 0 a 255 1 Letra o número positivo. Short -32.768 a 32.767 2 Entero corto con signo unsigned %u 0 a 65.535 2 Entero corto sin signo Int %d, %i -32.768 a 32.767 2 Entero con signo unsigned int %u 0 a 65.535 2 Entero sin signo short int %d -32.768 a 32.767 2 Entero con signo Long %ld -2.147.483.648a 4 Entero largo con signo unsigned long %ld 0 a 4.294.967.295 4 Entero largo sin signo long int %ld -2.147.483.648a

2 147 483 6474 Entero largo con signo

unsigned longi t

%ld 0 a 4.294.967.295 4 Entero largo sin signo Float %f, %g,

%e, %E 3.4E-38 a 3.4E+38 decimales(6)

4

Para números con decimales

Double %f, %g, %e, %E

1.7E-308 a 1.7E+308 decimales(10)

8


long double %f, %g, %e, %E

3.4E-4932 a 1.1E+4932decimales(10)

10


Tabla 5. Tipos de datos y su rango Todos estos tipos salvo void son tipos numéricos. Incluso el tipo char. Además de estos tipos podemos utilizar los modificadores signed y unsigned, los cuales son aplicables a los tipos de datos enteros Aunque el tipo char represente caracteres internamente para la computadora no es más que un número comprendido entre 0 y 255 que identifica un carácter dentro del código especificado para tal propósito en el sistema en el que nos encontremos trabajando. El código más utilizado para este tipo de representación es el ASCII. Según la máquina, el compilador empleado y las opciones de compilación , "char" puede interpretarse con signo o sin signo. Esto es, de -128 a 127 o desde 0 a 255. Si se requiere una representación que no dependa de las opciones del compilador, etc., se puede poner "signed char" o "unsigned char", según el caso. Variables Como decíamos antes la computadora debe de disponer de los datos necesarios para resolver el problema para el que lo queramos programar. Difícilmente se podría resolver un sistema de



1

ecuaciones si no se dispone de éstas. Para ello podemos definir variables. Las variables almacenan valores de un tipo especificado y en ellas almacenamos los datos de nuestro problema, se denominan variables por que su valor puede cambiar 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. Para referenciar una variable especificada es necesario que la podamos identificar para ello se utiliza un nombre o identificador. Las variables no se conservan después de que un programa termina su ejecución. Cuando finaliza un programa, los datos son borrados. Si quieres que datos permanezcan puedes usar archivos para almacenarlos. Declaración de Variables Las variables se utilizan para almacenar temporalmente datos dentro del programa. En C Hay que declarar todas las variables antes de usarlas. Cada variable tiene un tipo. Es posible inicializar y declarar más de una variable del mismo tipo en la misma sentencia: La declaración es:

tipo nombre ; Ejemplo: int pepe; /* tipo de variable: int y nombre de la variable: a */ float b; double c,d; /* tipo de las variables: double y nombre de las variables: c y d */ char x; Nota: La declaración de variables debe hacerse al principio de la función. (Aunque algunos compiladores lo admitan, no debe hacerse en cualquier lugar). Asignación de Valores Para la asignación de valores se utiliza el signo ( = ) igual, por ejemplo: A = 5; B = 4; X = 43.453; En C es posible asignar a varias variables un solo valor ejemplo: a = b = c = 7; x = y = n = 34; p = d = m = 56.8; k = i = 23; Algunos lenguajes automáticamente inicializan variables numéricas a cero y variables tipo carácter a blanco o a carácter nulo, en C no es así ya que se puede declarar la variable e inicializarla al mismo tiempo, por ejemplo: int x = 5, y = 1; Hay que tener cuidado con lo siguiente: Podríamos pensar que x e y son igual a 20, pero no es así. La variable x está sin valor inicial y la variable 'y' tiene el valor 20. Ejemplo: Suma dos valores



1

Algoritmo: inicio declarar variables enteras num1=4, num2, num3 = 6 escribir (‘ El valor de num1 es: ‘, num1) escribir (‘ El valor de num3 es:’, num3) num2 ← num1+num3 escribir (‘ num1 + num3 = ‘, num2) pausa fin Programa: #include <stdio.h> int main (void) { int num1=4, num2, num3=6; printf(" El valor de num1 es %d", num1); printf("\n El valor de num3 es %d", num3); num2=num1+num3; printf("\n num1 + num3 = %d\n", num2); system(“pause”); return 0; } Alcance o Ámbito de las Variables (tipos de declaración de variables) Según el lugar donde se declaren las variables tendrán un ámbito. Según el ámbito de las variables pueden ser utilizadas desde cualquier parte del programa o únicamente en la función donde han sido declaradas. Las variables pueden ser: - locales: Cuando se declaran dentro de una función. Las variables locales sólo pueden ser referenciadas (utilizadas) por sentencias que estén dentro de la función que han sido declaradas. No son conocidas fuera de su función. Pierden su valor cuando se sale y se entra en la función. La declaración es como siempre. -globales: Son conocidas a lo largo de todo el programa, y se pueden usar desde cualquier parte del código del programa. Mantienen sus valores durante toda la ejecución. Deban ser declaradas fuera de todas las funciones incluida main (void). La sintaxis de creación no cambia nada con respecto a las variables locales. Inicialmente toman el valor 0 o nulo, según el tipo. -de registro: Otra posibilidad es, que en vez de ser mantenidas en posiciones de memoria de la computadora, se las guarde en registros internos del microprocesador. De esta manera el acceso a ellas es más directo y rápido. Para indicar al compilador que es una variable de registro hay que añadir a la declaración la palabra register delante del tipo. Solo se puede utilizar para variables locales. -estáticas: Las variables locales nacen y mueren con cada llamada y finalización de una función, sería útil que mantuvieran su valor entre una llamada y otra sin por ello perder su ámbito. Para conseguir eso se añade a una variable local la palabra static delante del tipo. 2.2.1. Tamaño, declaración y modificadores El Tipo de dato “int”



1

En una variable de este tipo se almacenan números enteros (sin decimales). Una variable tipo int se almacena en 2 bytes (16 bits), aunque algunos compiladores utilizan 4 bytes (32 bits). El ANSI C no tiene esto completamente normalizado y existen diferencias entre unos compiladores y otros. Con 16 bits se pueden almacenar 216 = 65536 números enteros diferentes: de 0 al 65535 para variables sin signo, y de -32768 al 32767 para variables con signo (que pueden ser positivas y negativas), que es la opción por defecto. Este es el rango de las variables tipo int. Para poder usar una variable primero hay que declararla (definirla). Hay que decirle al compilador que queremos crear una variable y hay que indicarle de qué tipo. Por ejemplo: unsigned int numero; int nota = 10; Esto hace que declaremos una variable llamada número que va a contener un número entero sin signo y una variable nota con signo. En este caso la variable numero podrá estar entre 0 y 65535, mientras que nota deberá estar comprendida entre -32768 al 32767. Cuando a una variable int se le asigna en tiempo de ejecución un valor que queda fuera del rango permitido (situación de overflow o valor excesivo), se produce un error en el resultado de consecuencias tanto más imprevisibles cuanto que de ordinario el programa no avisa al usuario de dicha circunstancia. Cuando el ahorro de memoria es muy importante puede asegurarse que el computador utiliza 2 bytes para cada entero declarándolo en una de las formas siguientes: int numero; Como se ha dicho antes, ANSI C no obliga a que una variable int ocupe 2 bytes, pero declarándola como int sí que necesitará sólo 2 bytes (al menos en los PC’s). Mostrar variables por pantalla Vamos a ir u poco más allá con la función printf. Supongamos que queremos mostrar el contenido de la variable x por pantalla: printf( "%i", x ); Suponiendo que x valga 10 (x=10) en la pantalla tendríamos: 10 Aquí se describe brevemente el significado de "%i" el cual no se muestra por pantalla, se sustituye por el valor de la variable que va detrás de las comillas. ( %i, de integer = entero en inglés). Para ver el contenido de dos variables, por ejemplo x e y, podemos hacer: printf( "%i ", x ); printf( "%i", y ); resultado (suponiendo x=10, y=20): 10 20 Pero hay otra forma mejor: printf( "%i %i", x, y );



1

y así podemos poner el número de variables que queramos. Obtenemos el mismo resultado con menos trabajo. No olvidemos que por cada variable hay que poner un %i dentro de las comillas. También podemos mezclar texto con enteros: printf( "El valor de x es %i, ¡excelente! \n", x ); que quedará como: El valor de x es 10, ¡excelente! Como vemos %i al imprimir se sustituye por el valor de la variable. Veamos un ejemplo para resumir todo: Algoritmo: inicio declara variables

enteras x ← 20 escribir ( ‘ El valor inicial de x es ‘, x ) x ← 60 escribir ( ‘Ahora el valor es ‘, x ); pausa fin Programa: #include <stdio.h> int main() { int x = 20; prinft( "El valor inicial de x es %i \n", x ); x = 60; printf( "Ahora el valor es %i \n", x ); system(“pause”); return 1; } Cuya salida será: El valor inicial de x es 20 Ahora el valor es 60 Si imprimimos una variable a la que no hemos dado ningún valor no obtendremos ningún error al compilar pero la variable tendrá un valor cualquiera. El Tipo de dato “char” Las variables de tipo char sirven para almacenar caracteres y se almacenan en un byte de memoria (8 bits). En un bit se pueden almacenar dos valores (0 y 1); con dos bits se pueden almacenar 22 = 4 valores (00, 01, 10, 11 en binario; 0, 1 2, 3 en decimal). Con 8 bits se podrán almacenar 28 = 256 valores diferentes (normalmente entre 0 y 255; con ciertos compiladores entre -128 y 127).



2

Los 128 primeros (0 a 127) son el ASCII estándar. El resto es el ASCII extendido y depende del idioma y de la computadora. Para declarar una variable de tipo char hacemos: char letra; char a, b, caracter; Se puede declarar más de una variable de un tipo determinado en una sola sentencia. Se puede también inicializar la variable en la declaración. Por ejemplo, para definir la variable carácter letra a y asignarle el valor ‘A’, se puede escribir: char letra = ’A’; o letra = 65; A partir de ese momento queda definida la variable letra con el valor correspondiente a la letra A. Recuérdese que el valor ’A’ utilizado para inicializar la variable letra es una constante carácter. En realidad, letra se guarda en un solo byte como un número entero, el correspondiente a la letra A en el código ASCII, (existe un código ASCII extendido que utiliza los 256 valores y que contiene caracteres especiales y caracteres específicos de los alfabetos de diversos países, como por ejemplo las vocales acentuadas y la letra ñ para el español latinoamericano). En una variable char sólo podemos almacenar solo una letra, no podemos almacenar ni frases ni palabras. En el ejemplo anterior, en ambos casos se almacena la letra 'A' en la variable. Esto es así porque el código ASCII de la letra 'A' es el 65. Para imprimir un char usamos el símbolo %c (c de character=caracter en inglés): letra = 'A'; printf( "La letra es: %c.", letra ); Resultado: La letra es A. También podemos imprimir el valor ASCII de la variable usando %i en vez de %c: letra = 'A'; printf( "El código ASCII de la letra %c es: %i.", letra, letra ); Resultado: El código ASCII de la letra A es 65. Como vemos la única diferencia para obtener uno u otro es el modificador (%c ó %i) que usemos. Las variables tipo char se pueden usar (y de hecho se usan mucho) para almacenar enteros. Si necesitamos un número pequeño (entre -127 y 127) podemos usar una variable char (8bits) en vez de una int (16bits), con el consiguiente ahorro de memoria. Todo lo demás dicho para los datos de tipo int se aplica también a los de tipo char. Una curiosidad:



2

letra = 'A'; printf( "La letra es: %c y su valor ASCII es: %i\n", letra, letra ); letra = letra + 1; printf( "Ahora es: %c y su valor ASCII es: %i\n", letra, letra ); En este ejemplo letra comienza con el valor 'A', que es el código ASCII 65. Al sumarle 1 pasa a tener el valor 66, que equivale a la letra 'B' (código ASCII 66). La salida de este ejemplo sería: La letra es A y su valor ASCII es 65 Ahora es B y su valor ASCII es 66 El Tipo de dato “long” Existe la posibilidad de utilizar enteros con un rango mayor si se especifica como tipo long en su declaración: long int numero _ grande; o, ya que la palabra clave int puede omitirse en este caso, long numero _ grande; El rango de un entero long puede variar según el computador o el compilador que se utilice, pero de ordinario se utilizan 4 bytes (32 bits) para almacenarlos, por lo que se pueden representar 232 = 4.294.967.296 números enteros diferentes. Si se utilizan números con signo, podrán representarse números entre -2.147.483.648 y 2.147.483.647. También se pueden declarar enteros long que sean siempre positivos con la palabra unsigned: unsigned long numero_positivo_muy_grande; En algunos computadores una variable int ocupa 2 bytes (coincidiendo con short) y en otros 4 bytes (coincidiendo con long). Lo que garantiza el ANSI C es que el rango de int no es nunca menor que el de short ni mayor que el de long. El Tipo de dato “float” En muchas aplicaciones hacen falta variables reales, capaces de representar magnitudes que contengan una parte entera y una parte fraccionaria o decimal. Estas variables se llaman también de punto flotante. De ordinario, en base 10 y con notación científica, estas variables se representan por medio de la mantisa, que es un número mayor o igual que 0.1 y menor que 1.0, y un exponente que representa la potencia de 10 por la que hay que multiplicar la mantisa para obtener el número considerado. Por ejemplo, π se representa como 0.3141592654 . 101. Tanto la mantisa como el exponente pueden ser positivos y negativos. Las computadoras trabajan en base 2. Por eso un número de tipo float se almacena en 4 bytes (32 bits), utilizando 24 bits para la mantisa (1 para el signo y 23 para el valor) y 8 bits para el exponente (1 para el signo y 7 para el valor). Es interesante ver qué clase de números de punto flotante pueden representarse de esta forma. En este caso hay que distinguir el rango de la precisión. La precisión hace referencia al número de cifras con las que se representa la mantisa. Declaración de una variable de tipo float: float numero; Para imprimir valores tipo float Usamos %f.



2

float num=4060.80; printf( "El valor de num es : %f", num ); El resultado será: El valor de num es: 4060.80 Si queremos escribirlo en notación exponencial usamos %e: float num = 4060.80; printf( "El valor de num es: %e", num ); Que da como resultado: El valor de num es: 4.06080e003 El Tipo de dato “double” Las variables tipo float tienen un rango y sobre todo una precisión muy limitada, insuficiente para la mayor parte de los cálculos técnicos y científicos. Este problema se soluciona con el tipo double, que utiliza 8 bytes (64 bits) para almacenar una variable. Se utilizan 53 bits para la mantisa (1 para el signo y 52 para el valor) y 11 para el exponente (1 para el signo y 10 para el valor). Las variables tipo double se declaran de forma análoga a las anteriores: double numero_real_grande; Por último, existe la posibilidad de declarar una variable como long double, aunque el ANSI C no garantiza un rango y una precisión mayores que las de double. Eso depende del compilador y del tipo de computador. Estas variables se declaran en la forma: long double real_muy_grande; cuyo rango y precisión no está normalizado. Los compiladores de Microsoft para PC’s utilizan 10 bytes (64 bits para la mantisa y 16 para el exponente). Overflow: Qué pasa cuando nos saltamos el rango El overflow es lo que se produce cuando intentamos almacenar en una variable un número mayor del máximo permitido. El comportamiento es distinto para variables de números enteros y para variables de números en coma flotante.

Tabla de tipos de datos

Tipo Definición Bits

Char Short

Carácter Entero corto con signo

(normalmente 8 bits) (normalmente 16 bits)

Int Entero con signo (depende de la implementación) Unsigned Entero sin signo (depende de la implementación) Long Entero largo con signo (normalmente 32 bits) Float Flotante simple (normalmente 32 bits) Double Flotante doble (normalmente 64 bits)

Tabla 6. Tipos de datos



2

Con números enteros si corremos este programa Algotimo: inicio declarar variables Enteras num1 num1 ← 2147483648 escribir ( ‘ El valor de num1 es: ‘, num1 ) pausa fin Programa: #include <stdio.h> int main(void) { int num1; num1 = 2147483648; printf( "El valor de num1 es: %i \n", num1 ); getch(); } El resultado que obtenemos es: El valor de num1 es: -2147483648 Comprueba si quieres que con el número anterior (2.147.483.647) no pasa nada. Con números en coma flotante El comportamiento con números en coma flotante es distinto. Dependiendo de la computadora si nos pasamos del rango al ejecutar un programa se puede producir un error y detenerse la ejecución. Con estos números también existe otro error que es el underflow. Este error se produce cuando almacenamos un número demasiado pequeño. Conversión de tipos: Cuando escribimos una expresión aritmética a+b, en la cual hay variables o valores de distintos tipos, el compilador realiza determinadas conversiones antes de que evalúe la expresión. Estas conversiones pueden ser para 'aumentar' o 'disminuir' la precisión del tipo al que se convierten los elementos de la expresión. Un ejemplo claro, es la comparación de una variable de tipo int con una variable de tipo double. En este caso, la de tipo int es convertida a double para poder realizar la comparación. Los tipos pequeños son convertidos de la forma siguiente: un tipo char se convierte a int, con el modificador signed si los caracteres son con signo, o unsigned si los caracteres son sin signo. Un unsigned char es convertido a int con los bits más altos puestos a cero. Un signed char es convertido a int con los bits más altos puestos a uno o cero, dependiendo del valor de la variable. Para los tipos de mayor tamaño: si un operando es de tipo double, el otro es convertido a double. Si un operando es de tipo float, el otro es convertido a float. Si un operando es de tipo unsigned long, el otro es convertido a unsigned long. Si un operando es de tipo long, el otro es convertido a long. Si un operando es de tipo unsigned, el otro es convertido a unsigned. Si no, los operandos son de tipo int. Otra clase de conversión implícita tiene lugar cuando el resultado de una expresión es asignado a una variable, pues dicho resultado se convierte al tipo de la variable (en este caso,



2

ésta puede ser de menor rango que la expresión, por lo que esta conversión puede perder información y ser peligrosa). Por ejemplo, si i y j son variables enteras y x es double: x = i*j – j + 1; En C existe también la posibilidad de realizar conversiones explícitas de tipo (llamadas casting, en ingles). El casting es pues una conversión de tipo, forzada por el programador. Para ello basta preceder la constante, variable o expresión que se desea convertir por el tipo al que se desea convertir, encerrado entre paréntesis. En el siguiente ejemplo, k = (int) 1.7 + (int) masa; la variable masa es convertida a tipo int, y la constante 1.7 (que es de tipo double) también. El casting se aplica con frecuencia a los valores de retorno de las funciones. Ejemplo: Algoritmo: inicio declarar variables reales a enteras b a ← 2.8 b ← 10 escribir ( ‘ a (real) = ‘, a) escribir ( ‘ a convertido en entero: ‘, (int) a) escribir ( ‘ b (entero): ‘, b) escribir (‘ b convertido en real: ‘, (float) b) pausa fin Programa: #include <stdio.h> int main (void) { float a; int b; a = 2.8; b = 10; printf("\n a (real) = %f", a); /* a = 2.8000 */ printf("\n a convertido en entero: %d", (int) a); /* a convertido en entero : 2 */ printf("\n b (entero): %d", b); /* b : 10 */ printf("\n b convertido en real: %f", (float) b); /* b convertido en real : 10.0000 */ system(“pause”); return 1; } Constantes Se entiende por constantes aquel tipo de información numérica o alfanumérica que no puede cambiar más que con una nueva compilación del programa. Como ya se ha dicho anteriormente, en el código de un programa en C pueden aparecer diversos tipos de constantes que se van a explicar a continuación.



2

Constantes Enteras Un constante entero decimal está formado por una secuencia de dígitos del 0 al 9, constituyendo un número entero. Las constantes enteros decimales están sujetas a las mismas restricciones de rango que las variables tipo int y long, pudiendo también ser unsigned. El tipo de una constante se puede determinar automáticamente según su magnitud, o de modo explícito posponiendo ciertos caracteres, como en los ejemplos que siguen:

Constantes de tipo entero Longitud Constante

23484 45815 253u ó 253U 739l ó 739L 583ul ó 583UL

constante tipo int constante tipo long (es mayor que 32767) constante tipo unsigned int constante tipo long constante tipo unsigned long

Tabla 7. Constantes Enteras

En C se pueden definir también constantes enteras octales, esto es, expresadas en base 8 con dígitos del 0 al 7. Se considera que una constante está expresada en base 8 si el primer dígito por la izquierda es un cero (0). Análogamente, una secuencia de dígitos (del 0 al 9) y de letras (A, B, C, D, E, F) precedida por 0x o por 0X, se interpreta como una constante entera hexadecimal, esto es, una constante numérica expresada en base 16. Por ejemplo:

Ejemplos conversiones Conversión Código

011 11 0xA 0xFF

constante octal (igual a 9 en base 10) constante entera decimal (no es igual a 011) constante hexadecimal (igual a 10 en base 10) constante hexadecimal (igual a 162-1=255 en base 10)

Tabla 8. Ejemplos de Conversiones Es probable que no haya necesidad de utilizar constantes octales y hexadecimales, pero conviene conocer su existencia y saber interpretarlas por si hiciera falta. La ventaja de los números expresados en base 8 y base 16 proviene de su estrecha relación con la base 2 ( 8 y 16 son potencias de 2), que es la forma en la que la computadora almacena la información. Constantes de punto flotante Como es natural, existen también constantes de punto flotante, que pueden ser de tipo float, double y long double. Una constante de punto flotante se almacena de la misma forma que la variable correspondiente del mismo tipo. Por defecto si no se indica otra cosa las constantes de punto flotante son de tipo double. Para indicar que una constante es de tipo float se le añade una f o una F; para indicar que es de tipo long double, se le añade una l o una L. En cualquier caso, el punto decimal siempre debe estar presente si se trata de representar un número real. Estas constantes se pueden expresar de varias formas. La más sencilla es un conjunto de dígitos del 0 al 9, incluyendo un punto decimal. Para constantes muy grandes o muy pequeñas puede utilizarse la notación científica; en este caso la constante tiene una parte entera, un punto decimal, una parte fraccionaria, una e o E, y un exponente entero (afectando a



2

la base 10), con un signo opcional. Se puede omitir la parte entera o la fraccionaria, pero no ambas a la vez. Las constantes de punto flotante son siempre positivas. Puede anteponerse un signo (-), pero no forma parte de la constante, sino que con ésta constituye una expresión, como se verá más adelante. A continuación se presentan algunos ejemplos válidos:

Ejemplos de Constantes Ejemplo Constante

1.23 23.963f .00874 23e2 .874e-2 .874e-2f

constante tipo double (opción por defecto) constante tipo float constante tipo double constante tipo double (igual a 2300.0) constante tipo double en notación científica (=.00874) constante tipo float en notación científica

Tabla 9. Ejemplos de Constantes Seguidos de otros que no son correctos:

Ejemplos incorrectos de constantes

1,23 23963f

error: la coma no esta permitida error: no hay punto decimal ni carácter e ó E

.e4 -3.14

error: no hay ni parte entera ni fraccionaria error: sólo el exponente puede llevar signo

Tabla 10. Ejemplos incorrectos de constantes Constantes carácter Una constante carácter es un carácter cualquiera encerrado entre apóstrofos (tal como 'x' o 't'). El valor de una constante carácter es el valor numérico asignado a ese carácter según el código ASCII. Conviene indicar que en C no existen constantes tipo char; lo que se llama aquí constantes carácter son en realidad constantes enteras. Hay que señalar que el valor ASCII de los números del 0 al 9 no coincide con el propio valor numérico. Por ejemplo, el valor ASCII de la constante carácter '8' es 56. Ciertos caracteres no representables gráficamente, el apóstrofo (') y la barra invertida (\) y otros caracteres, se representan mediante tabla de secuencias de escape con ayuda de la barra invertida (\). Los caracteres ASCII pueden ser también representados mediante el número octal correspondiente, encerrado entre apóstrofos y precedido por la barra invertida. Por ejemplo, '\07' y '\7' representan el número 7 del código ASCII (sin embargo, '\007' es la representación octal del carácter '7'). El ANSI C también admite secuencias de escape hexadecimales, por ejemplo '\x1a'.



2

Cadenas de caracteres Una cadena de caracteres es una secuencia de caracteres delimitada por comillas ("), como por ejemplo: "Esto es una cadena de caracteres". Dentro de la cadena, pueden aparecer caracteres en blanco y se pueden emplear las mismas secuencias de escape válidas para las constantes carácter. Por ejemplo, las comillas (") deben estar precedidas por (\), para no ser interpretadas como fin de la cadena; también la propia barra invertida (\). Es muy importante señalar que el compilador sitúa siempre un byte nulo (\0) adicional al final de cada cadena de caracteres para señalar el final de la misma. Así, la cadena "mesa" no ocupa 4 bytes, sino 5 bytes. A continuación se muestran algunos ejemplos de cadenas de caracteres: "Informática I" "'A'" " cadena con espacios en blanco " "Esto es una \"cadena de caracteres".\n" 2.2.2. Operadores Lógicos Aritméticos y de Asignación Constantes de tipo Enumeración: En C existen una clase especial de constantes, llamadas constantes enumeración. Estas constantes se utilizan para definir los posibles valores de ciertos identificadores o variables que sólo deben poder tomar unos pocos valores. Por ejemplo, se puede pensar en una variable llamada dia_de_la_semana que sólo pueda tomar los 7 valores siguientes: lunes, martes, miércoles, jueves, viernes, sábado y domingo. Es muy fácil imaginar otros tipos de variables análogas, una de las cuales podría ser una variable booleana con sólo dos posibles valores: SI y NO, o TRUE y FALSE, u ON y OFF. El uso de este tipo de variables hace más claros y legibles los programas, a la par que disminuye la probabilidad de introducir errores. En realidad, las constantes enumeración son los posibles valores de ciertas variables definidas como de ese tipo concreto. Las enumeraciones se crean con enum: enum nombre_de_la_enumeración { }; Ejemplo 1: nombres de las constantes enum día {lunes, martes, miércoles, jueves, viernes, sábado, domingo}; Esta declaración crea un nuevo tipo de variable el tipo de variable día que sólo puede tomar uno de los 7 valores encerrados entre las llaves. Estos valores son en realidad constantes tipo int: lunes es un 0, martes es un 1, miércoles es un 2, etc. Ahora, es posible definir variables, llamadas dia1 y dia2, que sean de tipo día, en la forma (observe que en C deben aparecer las palabras enum día) enum día dia1, dia2; y a estas variables se les pueden asignar valores en la forma dia1 = martes; Los valores enteros que se asocian con cada constante tipo enumeración pueden ser controlados por el programador. Por ejemplo, la declaración,



2

enum día {lunes=1, martes, miércoles, jueves, viernes, sábado, domingo}; asocia un valor 1 a lunes, 2 a martes, 3 a miércoles, etc., mientras que la declaración, enum día {lunes=1, martes, miércoles, jueves=7, viernes, sábado, domingo}; asocia un valor 1 a lunes, 2 a martes, 3 a miércoles, un 7 a jueves, un 8 a viernes, un 9 a sábado y un 10 a domingo.

Tabla de operadores lógicos, aritméticos y de asignación:

Operador Definición

+, - ++, --

suma, resta incremento, decremento

*, /, % multiplicación, división, módulo >>, << rotación de bits a la derecha, izquierda. & AND booleano | OR booleano ^ EXOR booleano ~ complemento a 1 ! complemento a 2, NOT lógico ==, != igualdad, desigualdad &&, || AND, OR lógico <, <= menor, menor o igual >, >= mayor, mayor o igual

Tabla 11. Operadores

2.3. Funciones de Biblioteca Uno de los principales objetivos de la programación modular es la reutilización de código, esto es escribir una función de manera que cualquier otra persona puede utilizarla en sus códigos. En el estándar de C, se establecen una serie de funciones, denominadas de biblioteca; que cualquier compilador debe incorporar, de forma que cualquier programa que utilice dichas funciones pueda ser compilado sin errores en cualquier máquina. Existen funciones predefinidas, que se encuentran disponibles en la biblioteca estándar de C y nos sirven para; manipulación de cadenas, manipulación de caracteres, entrada/salida, verificación de errores, y muchas otras operaciones útiles para cualquier programador de C. Esto hace que el trabajo del programador sea más sencillo debido a que estas funciones proporcionan muchas de las capacidades que se requieren. Las funciones de la biblioteca estándar son parte del ambiente de programación en C. Para usar las bibliotecas de funciones y las llamadas al sistema en un programa de C simplemente se debe llamar la función apropiada de C. Ejemplos de las funciones de la biblioteca estándar que han sido vistas son las funciones de E/S de alto nivel -fprintf(), malloc(), entrada y salida simples printf(), scanf(), operadores aritméticos, generadores de números aleatorios como random(), srandom(), lrand48(), drand48(), etc. y funciones para conversión de cadenas a los tipos básicos de C (atoi(), atof(), etc.) son miembros de la biblioteca estándar stdlib.h.



2

Todas las funciones matemáticas como sin(), cos(), sqrt() son funciones de la biblioteca estándar de matemáticas (math.h). Para muchas llamadas del sistema y funciones de las bibliotecas se tiene que incluir el archivo cabecera apropiado, por ejemplo: stdio.h, math.h. Para usar una función se debe asegurar de haber puesto los correspondientes #include en el archivo de C. De esta forma la función puede ser llamada correctamente, es importante asegurarse que los argumentos tengan los tipos esperados, de otra forma la función probablemente producirá resultados extraños. La mayoría de las bibliotecas contienen cientos de funciones utilizables que nos pueden ahorrar una cantidad importante de tiempo de programación. Una biblioteca es una colección de funciones, proporcionadas por el compilador para utilizarse dentro de un programa, para usar una función de estas bibliotecas (“librerías”), se debe incluir el archivo de encabezado correspondiente que contiene el prototipo de la función y una vez listo; la función solo se usa (entonces la función realiza la operación para lo que fue creada), y listo. El prototipo de encabezado contiene los prototipos correctos y simplemente tendrás que incluir el archivo de encabezado mediante la declaración #include y luego se podrá llamar a la función que se desee. Ejemplo: #include <stdio.h> Donde #include es el prototipo de encabezado y <stdio.h> es la biblioteca de C, en donde dentro de ella se encontrarán muchas funciones de biblioteca que se pueden usar dentro de un programa, las cuales ya realizan una función determinada, Ejemplos de algunas funciones que se encuentran en las diferentes bibliotecas: Biblioteca math.h

Funciones Funciones acos ceil

asin cos

atan cosh

atan2 exp

fabs floor fmod frexp ldexp log log10 modf pow sin sinh sqrt tan tanh

Tabla 12. Función math.h Biblioteca string.h

Funciones Funciones memchr memset

memcmp strcat

memcpy strchr

memmove strcmp

strcoll strcpy strcspn strerror strlen strncat strncmp strncpy strpbrk strrchr strspn strstr strtok strxfrm

Tabla 13. Función string.h Biblioteca stdlib.h

Funciones Funciones abort atoi

abs atol

atexit bsearch

atof calloc



3

div exit free getenv labs ldiv malloc mblen mbstowcs mbtowc qsort rand realloc srand strtod strtol strtoul system wctomb

Tabla 14. Función stdlib.h Biblioteca stdio.h

Funciones Funciones clearerr fflush

fclose fgetc

feof fgetpos

ferror fgets

fopen formato fprintf fputc fputs fread freopen fscanf fseek fsetpos ftell fwrite getc getchar gets perror printf putc putchar puts remove rename rewind scanf setbuf setvbuf sprintf sscanf tmpfile tmpnam ungetc vfprintf vprintf vsprintf

Tabla 15. Función stdio.h Biblioteca time.h

Funciones Funciones asctime gmtime

clock localtime

ctime mktime

difftime strftime

time Tabla 16. Función time.h

Un ejemplo de un programa donde se usan dos funciones de biblioteca llamadas getchar() y putchar(), las cuales se encuentran respectivamente en la biblioteca stdio.h, sería el siguiente. Algoritmo: inicio declarar variables Entera c c ← getchar( ) mientras (c != EOF) hacer putchar(c) c ← getchar() fin_mientras pausa fin Programa: #include <stdio.h> void main() { int c; c = getchar(); while (c != EOF) {



3

putchar(c); c = getchar(); } getch(); } El mismo ejemplo solo un poco más simple de realizar. Algoritmo: inicio declarar variables enteras c mientras ((c = getchar()) != EOF) hacer putchar(c) fin_mientras pausa fin Programa: #include <stdio.h> void main() { int c; while ((c = getchar()) != EOF) { putchar(c); } } Ejemplo que cuenta el número de caracteres de una cadena. Algoritmo: inicio declarer variables float nc nc ← 0 mientras ((getchar()) != EOF) hacer incrementar en uno nc escribir ( ‘ nc ‘) fin_mientras pausa fin Programa: #include <stdio.h> void main() { long nc; nc = 0; while ((getchar()) != EOF) ++nc;



3

printf("%ld\n", nc); } 2.3.1 funciones de entrada y salida Cuando nos referimos a entrada/salida estándar (E/S estándar) queremos decir que los datos o bien se están leyendo del teclado, ó bien se están escribiendo en el monitor de video. Como se utilizan muy frecuentemente se consideran como los dispositivos de E/S por default y no necesitan ser nombrados en las instrucciones de E/S.

En C no existe ninguna palabra clave para realizar la entrada y salida de datos (E/S). Se realizan a través de funciones de biblioteca específicamente stdio.h.

Las funciones principales que realizan la entrada y salida sin formato son:

getchar(): Lee un carácter del teclado, espera hasta que se pulsa una tecla y entonces devuelve su valor.

putchar(): Imprime un carácter en la pantalla en la posición actual del cursor.

gets(): Lee una cadena de caracteres introducida por el teclado y la sitúa en una dirección apuntada por su argumento de tipo puntero a carácter.

puts(): Escribe su argumento de tipo cadena en la pantalla seguida de un carácter de salto de línea.

El siguiente fragmento de código lee un carácter del teclado y lo muestra por pantalla. A continuación lee una cadena (de 10 caracteres incluido el carácter nulo) y también la muestra por pantalla:

Algoritmo:

inicio declarar variables

carácter cadena[10] entera i

i ← getchar( ) putchar( i ) escribir ( ‘ Digita una cadena de caracteres ‘) gets (cadena) escribir ( ‘ Imprime la cadena de caracteres ‘ ) puts (cadena) pausa fin

Programa:

#include <stdio.h> main() { char cadena[10]; int i; i=getchar(); putchar(i); printf(“ Digita una cadena de caracteres \n “);



3

gets(cadena); printf(“ Imprime la cadena de caracteres \n”); puts(cadena); getch(); } Las funciones principales que realizan la entrada y salida con formato, es decir, se pueden leer y escribir en distintas formas controladas, son: printf(): Escribe datos en la consola con el formato especificado. scanf(): Función de entrada por consola con el formato especificado. Su sintaxis es la siguiente: printf (" caracteres de transmisión y escape", lista de argumentos); scanf (" caracteres de transmisión y escape", lista de argumentos); Ejemplos: código en C Impresión en pantalla printf(“ Hola como estas “); Hola como estas int j; j=100; printf(“ Tu resultado es: %d “, j ); Tu resultado es: 100 flota y; y=45.45; printf(“ El valor %f , corresponde a la variable y ”, y); El valor 45.45, corresponde a la variable y Los caracteres de transmisión son precedidos de un % para distinguirlos de los normales: Caracteres de transmisión y el argumento que transmite:

Caracteres de transmisión Modificador Tipo de dato %c %s

Int: un carácter simple Char *: una cadena de caracteres

%d %i Int: un número decimal %o octal sin signo %x %X hexadecimal sin signo %u decimal sin signo %f Float o double, en notación fija %e %E Float o double, en notación científica %g %G Float o double en notación científica si el exponente es

menor de diez a la menos cuatro, o fija en caso contrario.

%p escribe el número que corresponde al puntero %% Escribe un signo de %

Tabla 17. Modificador y su argumento .



3

Una l precediendo al tipo (por ejemplo, %l5d) significa que transmitiremos un long int, si, por el contrario, es una h significa que transmitiremos un short int. Existe otro tipo de carácter especial, los caracteres de escape, que tienen un significado especial. Los caracteres de escape son los siguientes:

Caracteres de escape Carácter de escape Significado \n \t

Nueva línea Tabulador

\b Espacio atrás \r Retorno de carro \f Comienzo de página \a Pitido sonoro \¿ Comilla simple \" Comilla doble \\ Barra invertida \xdd Código ASCII en notación hexadecimal

(cada d representa un dígito)

\ddd Código ASCII en notación octal (cada d representa un dígito)

Tabla 18. Caracteres de escape La lista de argumentos estará separada por comas. Debe existir una correspondencia directiva entre los caracteres de transmisión (aquellos que comienzan con un %) y la lista de argumentos a transmitir. Cabe destacar una diferencia en la lista de argumentos entre las funciones printf() y scanf(). En está ultima función (scanf()), la lista de argumentos va precedida por el operador de dirección(&), puesto que scanf() requiere que los argumentos sean las direcciones de las variables, en lugar de ellas mismas. Ejemplo de printf() con scanf(); Algoritmo: Inicio Declarar variables Enteras ent1 Enteras ent2 Enteras suma Escribir ( ‘ Introducir el primer número ‘ ) Leer ent1 escribir ( ‘ Introducir el segundo número ‘ ) leer ent2 suma ← ent1 + ent2 escribir ( ‘ La suma es ‘, suma ) pausa fin Programa: ama suma /* Programa suma */ #include <stdio.h>



3

int main() { int ent1; /* declaración de variable, es el primer número */ int ent2; /* segundo número a introducir por el usuario */ int suma; /* variable en donde se guardará la suma */ printf(“Introducir el primer número \n”); /* Indicación */ scanf(“%d”,&ent1); /* Lectura de primer entero*/ printf(“Introducir el segundo número \n”); /* Indicación */ scanf(“%d”,&ent2); /* Lectura del segundo entero*/ suma=ent1+ent2; /* Realiza la suma */ printf(“La suma es %d \n”); /* Imprime la suma */ return 0; /* Indica que el programa terminó con éxito*/ getch(); } scanf(“%d”,&ent1); %d es una cadena de control de formato, en éste caso indica que el usuario introducirá un entero (int ent1;) printf(“La suma es %d \n”, suma); %d es una cadena de control de formato, en éste caso indica que se imprimirá el valor numérico de la variable suma Al declarar las variables enteras ent1, ent2, suma en C, en realidad corresponde a lugares en la memoria de la computadora. int ent1; Toda variable en C tiene un nombre, un tipo, y un valor. Cuando la instrucción scanf(“%d”,&ent1); se ejecuta el valor escrito por el usuario se colocará en una dirección o localidad de la memoria donde se le haya asignado a la variable ent1. 2.3.2. Funciones matemáticas

Para poder usar las funciones matemáticas, se debe usar la biblioteca de funciones matemáticas que permite al programador reutilizar ciertos cálculos matemáticos comunes, esta es biblioteca <math.h>.

La biblioteca de matemáticas es relativamente fácil de usar, al igual que las vistas previamente. Se debe incluir la directiva de preprocesamiento #include <math.h>, y entonces se podrán utilizar todas las funciones que se encuentren en dicha librería, como las que se enlistaron en las funciones de biblioteca anteriormente.

Se muestra a continuación una lista de funciones matemáticas. Son fáciles de usar y algunas de ellas han sido ya usadas previamente.

Funciones Matemáticas double acos(double x) Calcula el arco coseno de x. double asin(double x) Calcula el arco seno de x. double atan(double x) Devuelve el arco tangente en radianes.



3

double atan2(double y, double x)

Calcula el arco tangente de las dos variables x e y. Es similar a calcular el arco tangente de y / x, excepto en que los signos de ambos argumentos son usados para determinar el cuadrante del resultado.

double ceil(double x) Redondea x hacia arriba al entero más cercano.

double cos(double x) Devuelve el coseno de x, donde x está dado en radianes.

double cosh(double x) Devuelve el coseno hiperbólico de x. double exp(double x) Devuelve el valor de e (la base de los

logaritmos naturales) elevado a la potencia x.

double fabs(double x) Devuelve el valor absoluto del número en punto flotante x.

double floor(double x) Redondea x hacia abajo al entero más cercano.

double fmod(double x, double y)

Calcula el resto de la división de x entre y. El valor devuelto es x - n * y, donde n es el cociente de x / y.

double frexp(double x, int *exp)

Se emplea para dividir el número x en una fracción normalizada y un exponente que se guarda en exp.

long int labs(long int j) double ldexp(double x, int exp) double log(double x); double log10(double x) double modf(double x, double *iptr)

Divide el argumento x en una parte entera y una parte fraccional. La parte entera se guarda en iptr.

double pow(double x, double y)

Devuelve el valor de x elevado a y.

double sin(double x) double sinh(double x) double sqrt(double x) double tan(double x) double tanh(double x)

Tabla 19. Funciones Matemáticas Estas funciones matemáticas, realizan una función específica para lo que fueron creadas y el programador no tiene que preocuparse por crear el código para realizar dicha función, únicamente las tiene que utilizar dentro del programa que lo desee.

2.4. Funciones Generadas por el usuario La experiencia ha demostrado que la mejor manera de desarrollar y mantener un programa grande es construirlo a partir de piezas o componentes mas pequeños, esta técnica se llama divide y vencerás. Las funciones son bloques de programa que definen tareas específicas, las cuales pueden utilizarse en diversos puntos del programa, estas funciones es en donde se produce toda la actividad que realiza un programa. C fué diseñado como un lenguaje de programación estructurado, también llamado programación modular. Por esta razón, para escribir un programa se divide éste en varios



3

módulos, en lugar de uno solo largo. El programa se divide en muchos módulos (rutinas pequeñas llamadas funciones). Ejemplo de ello se muestra en el esquema siguiente, como los procesos (funciones) están aparte del programa principal y son llamados por él, en el lugar adecuado. PRINCIPAL PROCESO A PROCESO B

Figura 1. Funciones Una función es un conjunto de líneas de código que realizan una tarea específica y puede retornar un valor. Las funciones pueden tomar parámetros que modifiquen su funcionamiento. Las funciones son utilizadas para descomponer grandes problemas en tareas simples y para implementar operaciones que son comúnmente utilizadas durante un programa y de esta manera reducir la cantidad de código. Cuando una función es invocada se le pasa el control a la misma, una vez que esta finalizó con su tarea el control es devuelto al punto desde el cual la función fue llamada. Así pues, un programa en C se compone de varias funciones, cada una de las cuales realiza una tarea principal.

Una función es, sencillamente, un conjunto de sentencias que se pueden llamar desde cualquier parte de un programa. Las funciones permiten al programador un grado de abstracción en la resolución de un problema.

Las funciones en C no se pueden anidar. Esto significa que una función no se puede declarar dentro de otra función. La razón para esto es permitir un acceso muy eficiente a los datos. En C todas las funciones son externas o globales, es decir pueden ser llamadas desde cualquier punto del programa.

Si un programa contiene varias funciones, sus definiciones deben aparecer en cualquier orden, pero deben ser independientes unas de otras. Existen dos tipos de funciones: funciones predefinidas (de biblioteca) y las funciones creadas por el programador. Una función se invoca (es decir, se hace que realice la tarea para la que fue creada) mediante una llamada a la función. La llamada a la función especifica el nombre de la función y proporciona información (como argumentos) que la función invocada necesita para hacer su trabajo. Todas las variables definidas dentro de una función, son variables locales que solo se conocen dentro de la función en la que se definen, esta comienza a existir cuando se entra a la función y se destruye al salir de ella. Así, las variables locales no pueden conservar sus valores entre distintas llamadas a la función. Los dos puntos importantes para la creación de una función son los siguientes: la reutilización de código (ya que la función se puede utilizar cuantas veces

INICIO

FIN

INICIO INICIO

FIN FIN

PROCESO A

PROCESO B

PROCESO A PROCESO B



3

sea necesario dentro de un programa y así no escribirla mas de una vez), y la otra es que un programa se pueda dividir en bloques de sentencias mas simples y pequeñas, para su mejor solución. Cada función se debe limitar para que realice una tarea sencilla y bien definida, y el nombre de la función debe expresar de manera efectiva dicha tarea, ya que este tipo de funciones son creadas dependiendo de la necesidad del usuario sobre un determinado problema. Esto promueve la reutilización de código que es esencial en la programación. El tipo devuelto por una función, debe ser compatible con el tipo que se espera que devuelva en la función de llamada, o el compilador dará un warning. Forma general de una función: tipo_dev nombre_de_la_función (lista de parámetros) { Cuerpo de la función } El tipo_dev especifica el tipo de dato que devuelve la función. Una función puede devolver cualquier tipo de dato excepto un array. El nombre de la función es cualquier identificador válido, la lista de parámetros es una lista de nombres de variables separados por comas con sus tipos asociados. Los parámetros reciben los valores de los argumentos cuando se llama a la función. Una función puede no tener parámetros, en cuyo caso la lista de parámetros está vacía y por lo tanto se puede usar la palabra clave void entre los paréntesis. Por ejemplo, aquí se muestra una declaración de funciones con parámetros correcta ya que a cada variable le corresponde un tipo e incorrecta porque a algún parámetro le hace falta su tipo y esto es un error: void F(float r, int v, flota j); /* correcto */ void F(float t,g, float h); /* incorrecto */ Los parámetros de una función también se conocen dentro de ella únicamente, estos comienzan a existir cuando se entra a la función y se destruyen al salir de ella. Ejemplos de funciones sin parámetros Algoritmo: declarar función cuadrado( ) inicio declara variable real res y N limpiar pantalla escribir ( ‘ Programa que obtiene mediante una función el cuadrado de un numero ‘) llamar a función cuadrado( ) escribir ( ‘ Fin de nuestro programa ‘) pausa fin función cuadrado( ) inicio escribir ( ‘ Función Cuadrado ‘) escribir ( ‘ Da el numero a evaluar ‘) leer N res ← N * N escribir ( ‘ El cuadrado de ‘, N ,’ es: ‘, res) escribir ( ‘ Fin de la Función ‘) fin_cuadrado



3

Programa: #include <stdio.h> #include <stdlib.h> #include <conio.h> void cuadrado( ); void main( ) { float res,N; clrscr( );

printf(“Programa que obtiene mediante una función el cuadrado de un numero \n “);

cuadrado( ); printf(“ Fin de nuestro programa “); getch( ); } void cuadrado( ) { printf(“ \n Función Cuadrado \n “); printf(“ Da el numero a evaluar \n “); scanf(“%f”,&N); res = N * N; printf(“ El cuadrado de %f es: %f “, N,res); printf(“ \n Fin de la Función “); } El siguiente programa nos muestra a dos funciones sin parámetros, las cuales se mandan llamar dentro del programa principal main( ). Algoritmo: declarar función1( ) declarar funcion2( ) inicio limpiar pantalla escribir ( ‘ Programa que desarrolla dos funciones ‘) llamar a función1( ) llamar a funcion2( ) return 0 escribir ( ‘ Fin de nuestro programa ‘) pausa fin función funcion1( ) inicio escribir ( ‘ Función Uno ‘) escribir ( ‘ La función uno no toma argumentos ‘) escribir ( ‘ Fin de la función uno ‘) fin_funcion1 función funcion2( ) inicio escribir ( ‘ Función Dos ‘) escribir ( ‘ La función dos tampoco toma argumentos ‘) escribir ( ‘ Fin de la función dos ‘ )



4

fin_funcion2 Programa: #include <stdio.h> #include <stdlib.h> #include <conio.h> void funcion1( ); /* declaración de una función */ void funcion2( void); /* declaración de una función */ int main( ) { clrscr( ); printf(“Programa que desarrolla dos funciones \n “); Funcion1( ); /* llama a la función 1 sin argumentos */ Funcion2( ); /* llama a la función 2 sin argumentos */ return 0; /* indica terminación exitosa */ printf(“ Fin de nuestro programa “); getch( ); } /* fin del main */ void funcion1( ) { printf(“ \n Función Uno \n “); printf(“ La función uno no toma argumentos \n “); printf(“ \n Fin de la Función uno “); } /* La función dos en su lista de parámetros tiene la palabra void para especificar que la función no recibe parámetros */ void funcion2(void ) { printf(“ \n Función Dos \n “); printf(“ La función dos tampoco toma argumentos \n “); printf(“ \n Fin de la Función dos “); } En caso de tener una lista de parámetros la función, su forma general sería: tipo_dev función ( tipo var1, tipo var2, tipo var3, … , tipo varN ) Por ejemplo, a continuación se muestran unos ejemplos de declaraciones correctas e incorrectas de los parámetros de una función: void f( int i, int l, int m); /* declaraciones correctas */ void f( float g, int h, float y); void f( int k, float u, float k, int r); void f( int g,h,j ); /* declaraciones incorrectas,

cada variable debe */ void flota(float f,j,r ); /* tener su propio tipo

*/ void f( float g,t, int g,h );



4

Los parámetros formales tienen que ser del mismo tipo que los argumentos usados al llamar una función (el compilador no dará error pero los resultados serán inesperados).

Al igual que con variables locales, se pueden hacer asignaciones a los parámetros de una función o usarlos en cualquier expresión válida. Se pueden usar como cualquier otra variable.

Una función es visible para ella misma y otras funciones desde el momento en que se define. Es visible para el propio cuerpo de la función, es decir, la recursividad esta permitida. El código de una función es privado a esa función y sólo se puede acceder a él mediante una llamada a esa función. Las variables definidas dentro de una función son locales (a no ser que las definamos globales) por lo que no conservan su valor de una llamada a otra.

Ámbito de una función: El ámbito en un lenguaje son las reglas que controlan si un fragmento de código conoce o tiene acceso a otro fragmento de código o de datos. El ámbito de una función determina no sólo en qué partes de un programa se puede llamar a esa función, sino también a qué definiciones tiene acceso la función. Las mismas reglas de ámbito que se aplican a los identificadores de variable se aplican a los identificadores de función. Una función declarada en el ámbito global estará disponible en todo el código.

Llamada a una función:

Las funciones son llamadas para su ejecución desde cualquier parte del código, teniendo en cuenta que antes deben haber sido declaradas (y por supuesto definidas).

nombre_función (void); // sin parámetros

nombre_función ( m, t); //con parámetros

La llamada de una función se produce mediante el uso de su nombre en una sentencia, pasando una lista de argumentos que deben coincidir en número y tipo con los especificados en la declaración (en otro caso se produciría una conversión de tipos o resultados inesperados). Las llamadas a las funciones solo cambian si estas contiene parámetros o no, si no tienen simplemente se pone la palabra void dentro de los paréntesis y si tienen parámetros se pone la lista de las variables en cuyo espacio caerá el valor dado en el programa principal.

A continuación se muestra un programa ejemplo, con parámetros.

Ejemplo de función con parámetros Algoritmo: declarar función haz_algo( entero alas, real pies, entero ojos ) inicio declara variable entera ala ← 10 real pie ← 100.55 entero ojo ← 20 limpiar pantalla escribir ( ‘ Programa de dos funciones con parámetros ‘) llamar a función haz_algo( 3, 12.5, 4 ) llamar a la función haz_algo ( ala, pie, ojo ) escribir ( ‘ Fin de nuestro programa ‘) pausa fin



4

función haz_algo(entero alas, real pies, entero ojos ) inicio escribir ( ‘ Hay ‘ ala ‘ alas ‘ ) escribir ( ‘ Hay ‘ pie ‘ pies ‘ ) escribir ( ‘ Hay ‘ ojo ‘ ojos ‘ ) fin_haz_algo Programa: #include <conio.h> #include <stdio.h> #include <iostream.h> void haz_algo (int alas, float pies, int ojos); void main( ) {

int ala = 10; float pie = 100.55; int ojo = 20; clrscr(); printf( “ Programa de dos funciones con parámetros \n “) haz_algo (3, 12.5, 4); haz_algo (ala, pie, ojo); printf( “ Fin de nuestro programa “); getch();

} void haz_algo (int alas, float pies, int ojos) {

printf ( " \n Hay %d alas. \n ", alas); printf ( " \n Hay %f pies. \n ", pies); printf ( " \n Hay %d ojos. \n ", ojos);

} La salida de este programa será: Hay 3 alas. Hay 12.5 pies. Hay 4 ojos. Hay 10 alas. Hay 100 55 pies. Hay 20 ojos. 2.4.1. Argumentos y Parámetros Formales

Llamamos parámetros a la lista de argumentos que dentro de una función se encuentran encerrados entre paréntesis ejemplo de ellos es:

float Promedio(int A, int B) { float r; r=(A+B)/2.0; return r; }



4

En donde (int A, int B) es la lista de parámetros que tiene esta función, los cuales son utilizados dentro de ella para realizar un determinado cálculo, en lenguaje C se contemplan dos formas de pasar argumentos a las subrutinas, esto es pasarle valores a los parámetros que tiene la función, tantos parámetros tenga serán los argumentos que se enviarán a la función.

Características de los parámetros:

Representados por variables de un tipo dados

Incluyen información que es válida únicamente dentro de la función

Esta información puede modificarse a nivel local, (dentro de la función). Según el tipo de paso de parámetros la información volverá a tomar el valor con que entró, o el de la última modificación.

Existen dos tipos de paso con parámetros:

1.- Por valor: valor que entra es el mismo que con el que sale

2.- Por dirección: si el parámetro es modificado, este tomará el de la última modificación.

Los métodos son dos: llamadas por valor y por referencia. En general, se pueden pasar argumentos a las funciones de dos formas, por valor y por referencia.

La llamada por valor copia el valor de un argumento en el parámetro formal de la función. De esta forma, los cambios en los parámetros de la función no afectan a las variables que se usan en la llamada (es la llamada más usual, es decir, en general no se pueden alterar las variables usadas para llamar a la función).

La llamada por referencia copia la dirección del argumento en el parámetro. Dentro de la función se usa la dirección para acceder al argumento usado, significando que los cambios hechos a los parámetros afectan a la variable usada en la llamada.

Ejemplos de función con parámetros:

Sintaxis:

Tipo_Retorno nombre_función (argumentos)

{

Sentencias;

}

Algoritmo: función entera suma(entero a, entero b ) inicio retorna ( a + b ) fin_suma inicio declara variable

entera x ← 6



4

entero y ← 7 limpiar pantalla resultado ← suma ( 6 , 7 ) escribir ( ‘ Resultado: ‘, resultado ) escribir ( ‘ Fin de nuestro programa ‘) return 0 pausa fin Programa: #include <stdio.h> int suma(int a,int b) {

return (a + b); } int main {

int x = 6,y = 7; int resultado; clrscr(); resultado = suma(6,7); printf(" Resultado: %d\n",resultado); printf(“ Fin de nuestro programa “); return 0; getch();

} Ejemplo de paso por valor: Algoritmo: función entera valor_a(entero var_1 ) inicio escribir ( ‘ Valor de la Var_1 : ‘, decremento var_1 ) retorna 0 fin_valor_a inicio declara variable

entera var_1 ← 5 limpiar pantalla escribir ( ‘ Valor de var_1 : ‘, var_1 ) llamar a función valor_a ( var_1 ) escribir ( ‘ Fin de nuestro programa ‘) return 0 pausa fin Programa: #include <stdio.h> int valor_a (int var_1) {

printf(“ Valor de a Var_1 : %d \n “,-- var_1); return 0;

} int main (void)



4

{ int var_1 = 5; clrscr(); printf(“ Valor de a Var_1 : %d \n “,var_1); valor_a(var_1); printf( “ Fin de nuestro programa “); return 0;

}

El valor que debe devolver una función se indica con la palabra return. La evaluación de la expresión debe dar una valor del mismo tipo de dato que el que se ha definido como resultado. La declaración de una variable puede incluir una inicialización en la misma declaración.

Se debe tener muy en cuenta que en C todos los argumentos son pasados 'por valor'. No existe el concepto de paso de parámetros 'por variable' o 'por referencia'. Veamos un ejemplo:

Algoritmo de la función:

función entera incremento (entero v ) inicio retorna ( v + 1 ) fin_incremento inicio declara variable

entera a , b limpiar pantalla b ← 3 a ← incremento ( b ) / * a = 4 mientras que b = 3 por lo tanto ‘b’ no ha cambiado su valor después de la llamada a la función * / pausa fin Programa de la función: int incremento ( int v )

{ return v + 1; }

main (void )

{

int a, b;

clrscr();

b = 3;

a = incremento(b);

/* a = 4 mientras que b = 3 por lo tanto ‘b’ no ha cambiado su valor después de la llamada a la función */

getch();

}

En el ejemplo anterior el valor del parámetro de la función incremento, aunque se modifique dentro de la función, no cambia el valor de la variable b de la función main. Todo el texto comprendido entre los caracteres /* y */ son comentarios al programa y son ignorados por el compilador.



4

Si quisiéramos modificar el valor de los argumentos sería necesario pasar como argumento su dirección de memoria esto se haría utilizando punteros. A esto se le llama paso de parámetros por referencia. 2.4.2. Funciones con y sin argumentos Las funciones que no tienen dentro de los paréntesis del nombre de la función ningún parámetro (variable), se dice que son funciones sin argumentos, por lo tanto este tipo de funciones no devuelve ningún valor al programa principal, esto es; el programa principal no recibe ningún resultado para mostrarlo en su ejecución. Entonces los programas que tienen funciones que no tienen argumentos, solo realizan sus líneas y al momento de mandar llamar a la función realizan todo lo que este dentro de la función, después devuelven el mando al programa principal y este continúa con sus propias líneas, un ejemplo de un programa con una función que no tienen argumentos, sería algo como lo siguiente: Algoritmo: Declarar función hola( ) inicio limpiar pantalla escribir ( ‘ Que tal… ‘ ) llamar a la función hola( ) pausa fin función hola ( ) inicio escribir ( ‘ Hola a todos, este es un ejemplo de mensaje de una función ‘ ) escribir ( ‘ Hasta pronto amigos ‘ ) fin_hola Programa: #include<stdio.h> #include<conio.h> void hola(); /* Declaración de la función hola() */ void main( ) { clrscr(); printf(“ Que tal… \n “); hola(); getch(); } void hola() /* No existen parámetros dentro de los paréntesis del

nombre de la función */ {

printf(“ Hola a todos, este es un ejemplo de mensaje de una función \n “);

printf(“ Hasta pronto amigos “); } Al correr el siguiente programa se vería como sigue:



4

Que tal… Hola a todos, este es un ejemplo de mensaje de una función Hasta pronto amigos

Otro ejemplo de funciones sin argumentos, es el siguiente programa; que calcula la diferencia en minutos entre dos horas distintas dadas desde el teclado por el usuario. La función se llama minutos(), si observan dentro de los paréntesis no va ningún tipo de parámetros, esto la hace una función sin argumentos que no devuelve al compilador ningún valor, para después mostrarlo, acepta el tiempo que el usuario introduce en horas y minutos y lo convierte a minutos, devolviendo este valor en un tipo entero. La función presenta la particularidad de no tener argumentos.

Ejemplo Algoritmo:

Declarar función minutos( ) inicio limpiar pantalla declarar variables enteras minutos1, minutos2 escribir ( ‘ Escribe la primer hora (formato 3:22): ‘ ) minutos1 ← minutos( ) escribir ( ‘ Escribe la segunda hora (posterior): ‘ ) minutos2 ← minutos( ) escribir ( ‘ La diferencia es ‘, minutos2 – minutos1 , ‘ minutos ‘ ) pausa fin función entera minutos ( ) inicio declarar variables enteras horas, mins escribir ( ‘ Da las horas y los minutos ‘ ) leer ( horas , mins ) return ( horas * 60 + mins ) fin_minutos

Programa:

/* Programa que calcula la diferencia entre dos horas distintas */ #include <stdio.h> int minutos(void); void main(void) { clrscr(); int minutos1, minutos2; printf("Escribe la primera hora (formato 3:22): "); minutos1=minutos(); /* obtiene los minutos */ printf("Escribe la segunda hora (posterior): "); minutos2=minutos(); /* obtiene los minutos*/ printf("La diferencia es %d minutos.\n", minutos2-minutos1); getch(); } int minutos(void) { int horas, mins; printf(“Da las horas y los minutos \n “); scanf("%d:%d", &horas, &mins);



4

return (horas*60+mins); } La función return, le sirve al compilador para regresar al comando principal del programa la operación ahí expuesta, en este ejemplo devolverá al programa principal la operación que resulta de (horas*60+mins) Por otro lado las funciones con argumentos son aquellas que dentro del paréntesis si tienen valores o variables, las cuales se usan dentro de cada función para realizar algo, y después devolverlo al programa principal par mostrarlo. En C todos los argumentos que se pasan a una función se pasan por valor. En otras palabras, se pasa una copia del valor del argumento y no el argumento en sí (por ello, este procedimiento se conoce en algunas ocasiones como paso por copia). Al pasar una copia del argumento original a la función, cualquier modificación que se realice sobre esta copia no tendrá efecto sobre el argumento original utilizado en la llamada de la función. Se puede considerar un argumento pasado por valor como una variable local de la función a la que se ha pasado, de tal modo que los cambios que se realicen sobre ésta tendrán efecto sólo dentro de la función.

Supongamos que en un determinado programa debemos calcular repetidamente el valor medio de dos variables, una solución razonable sería crear una función que realice dicho cálculo, y llamarla cada vez que se necesite. Para ello será necesario, en cada llamada, pasarle los valores de las variables para que calcule su valor medio. Esto se define en la declaración de la función especificando, no solo su valor de retorno sino también el tipo de argumentos que recibe:

double valor_medio(double x, double y) ;

De esta declaración vemos que la función valor_medio recibe dos argumentos ( x e y ) del tipo double, por lo tanto devuelve un resultado de ese mismo tipo .

Cuando definamos a la función en sí, deberemos incluir parámetros para que alberguen los valores recibidos, así escribiremos:

double valor_medio(double x, double y ) { return ( (x + y) / 2.0 ) }

No es necesario que los nombres de los parámetros coincidan con los declarados previamente, es decir que hubiera sido equivalente escribir: double valor_medio(double a, double b) etc, sin embargo es una buena costumbre mantenerlos igual. En realidad en la declaración de la función, no es necesario incluir el nombre de los parámetros, bastaría con poner solo el tipo, sin embargo es práctica generalizada, explicitarlos a fin de hacer más legible al programa. Por ejemplo, en la creación de la función se puede poner de estas dos maneras y es totalmente correcto:

double valor_medio(double x, double y) ó

double valor_medio(double, double)

Sin embargo es preferible utilizar la nomenclatura moderna, ya que esta facilita la rápida comprensión del programa. Veamos un ejemplo, para determinar el comportamiento de los parámetros, supongamos desear un programa que calcule el valor medio de dos variables incrementadas en un valor fijo, es decir:



4

( ( x + incremento ) + ( y + incremento ) ) / 2.0

Lo podríamos resolver de la siguiente forma :

Algoritmo:

declarar función double valor_medio(double p_valor, double s_valor, double inc ) inicio limpiar pantalla declarar variables double x, y, z escribir ( ‘ Ingresa el primer valor ‘ ) lee x escribir ( ‘ Ingresa el segundo valor ‘ ) leer y escribir ( ‘ ingresa el incrementeo ‘ ) leer z llamar a la función valor_medio ( x, y. z ) escribir ( ‘ Valor con que quedaron las variables ‘ ) escribir ( ‘ Primer valor: ‘ , x ) escribir ( ‘ Segundo valor: ‘ y ) escribir ( ‘ Incremento: ‘, z ) pausa fin función double valor_medio (double p_valor, double s_valor, double inc ) inicio declarar variable double resultado p_valor ← p_valor + inc s_valor ← s_valor + inc res ← (p_valor + s_valor ) / 2.0 escribir ( ‘ Tu resultado del valor medio es: ‘, res ) fin_valor_medio

Programa:

#include <stdio.h> /* Declaración de la función y el tipo de sus parámetros */ double valor_medio(double p_valor, double s_valor, double inc); void main() { clrscr(); double x, y, z; printf(”Ingrese el primer valor: “) ; scanf(”% lf”, &x ) ; printf(”\n Ingrese el segundo valor: “); scanf(”% lf”, &y ) ; printf(”\n Ingrese el incremento : “); scanf(”% lf”, &z) ; valor_medio( x, y, z ); /* llamada a la función y pasaje de argumentos */ printf(”\n\n Valor con que quedaron las variables: “) ;



5

printf(”\n Primer valor : %lf “, x ) ; printf(”\n Segundo valor: %lf “, y ) ; printf(”\n Incremento : %lf “, z ) ; getch(); } /* Definición de la función y sus parámetros */ double valor_medio( double p_valor, double s_valor, double inc ) { double resultado; p_valor += inc; s_valor += inc; resultado =( (p_valor + s_valor ) / 2.0 ); printf(“ Tu resultado del valor medio es: %lf “, resultado); } Cabe destacar que el resultado de esta función esta dado dentro de la misma, en la función se van los valores dados desde el teclado, en ella se evalúan y se despliega el valor ahí mismo, por lo tanto al mandar llamarla, desglosa todo y luego el programa principal continúa desglosando los valores individuales de las variables. 2.4.3. Funciones que regresan valores La función en si misma es llamada definición de la función y generalmente contiene un pequeño programa. La primera línea de la definición de la función se llama encabezado de la función y es idéntico al prototipo de la función con la diferencia que no termina con ; El cuerpo de la función se encierra entre llaves { }. Su sintaxis dentro de lenguaje C es la siguiente:

Tipo_dato nombre_función(argumento formal 1, argumento formal 2, ... argumento N );

La especificación del tipo de valor devuelto por la función, seguido del nombre de la función y (opcionalmente) un conjunto de argumentos, separados por comas y cerrados entre paréntesis y punto y coma al final del prototipo. Después del nombre de la función deben seguir un par de paréntesis vacíos si la definición de la función no incluye ningún argumento con o sin la palabra void. El estándar ANSI C permite que el tipo de datos de cada argumento sea seguido del nombre del argumento dentro de la declaración de la función, es decir, tipo_dato nombre_función (tipo1 arg1, tipo2 arg2, ... , tipoN argN); en donde arg1, .., argN hacen referencia al primer argumento, al segundo , etc. Las declaraciones de funciones escritas de está forma se llaman prototipos de funciones. Después del encabezado y de abrir la llave de inicio se deberán declarar las variables locales. La función termina con la sentencia return(0) que marca el final de la función. Cuando la función termina el control del programa retorna a la función main a el mismo lugar donde fue llamada la función. La definición de la función se define después de cerrar la llave del main. La sentencia return también hace que se devuelva el control al punto de llamada. Sólo se puede incluir una expresión (variable u operación) en la sentencia return. Por lo tanto, una función sólo puede devolver un valor al punto de llamada mediante la sentencia return. Una definición de función puede incluir varias sentencias return, conteniendo cada una de ellas una expresión distinta. Las funciones que incluyen varias bifurcaciones suelen requerir varias sentencias return. La sentencia return puede no incluirse en la definición de una función, aunque esto se considera generalmente como una programación pobre. Si una función alcanza el final del bloque sin encontrarse una sentencia return, se devuelve el control al punto de llamada sin devolverse ninguna información. Se recomienda utilizar en estos casos una sentencia return vacía. Cuando una función no va a regresar ningún valor se antecede la



5

palabra void al nombre de la función, pero si esta si va a devolver un valor, entonces se antecede la palabra del tipo de dato que devolverá ejemplo (int, float, double).

La función se realiza en el momento en que desde el programa principal se hace referencia a su nombre, o dicho en otras palabras, en el momento en que se llama la función. Hay dos formas de llamar una función. Escribiendo su nombre como una instrucción (esto es para funciones sencillas que no regresan valor). Otra forma es escribiendo su nombre y la lista de parámetros (para funciones complejas con parámetros). El llamado de la función se puede hacer en cualquier momento, en cualquier posición dentro de nuestro programa. Se puede llamar a una función especificando su nombre, seguido de una lista de argumentos cerrados entre paréntesis y separados por comas. Si la llamada a la función no requiere ningún argumento, se debe escribir a continuación del nombre de la función un par de paréntesis vacíos. La llamada a la función puede aparecer sola, o puede ser uno de los operandos de una expresión más compleja.

Ejemplos de funciones que regresan valores al comando principal del programa serían:

Algoritmo que obtiene el cubo de un número dado desde el teclado:

declarar variables globales

flotantes res, num flotante cubo ( entero x ) inicio escribir ( ‘ Ingrese un número ‘ ) leer ( num ) res ← cubo ( num ) escribir ( num , ‘ al cubo es: ‘ , res ) return 0; fin function flotante cubo( entera x ) inicio return x*x*x fin_cubo Programa:

#include<stdio.h> float num; float res, cubo(int x);

main() { printf("ingrese un número "); scanf("%f",&num); res = cubo(num); printf("%f al cubo es: %f " ,num, res); return 0; }

float cubo(int x) {return x*x*x;}

Otro ejemplo de una función que regresa un valor al programa principal, es la siguiente de la potencia de un número dando desde el teclado, la base y la potencia a la cual se quiere elevar.



5

Algoritmo:


enteras b, e flotante potencia ( entero m, entero n ) inicio escribir ( ‘ INGRESE DOS NUMEROS.. ‘ ) leer ( b , e ) escribir ( potencia ( b , e ) ) pausa fin

function flotante potencia ( entera m, entera n ) inicio

declarar variables entera i flotante y y ← 1 desde i = 1 hasta i < = n incremento 1 hacer y ← y * m return y

fin_cubo

Programa:

#include<stdio.h> #include <math.h> int b, e; float potencia(int m, int n); main(void) { printf(" INGRESE DOS NÚMEROS.. "); scanf("%d %d",&b,&e); printf("%f",potencia(b, e)); getch(); } float potencia(int m, int n) { int i; float y; y=1; for(i=1;i<=n;i++)

y=y*m; return y; } Si se observa muy bien el programa anterior, notará que la función potencia recibe dos parámetros (m y n), pero solo devuelve al programa principal un valor de retorno (y), que es el que se muestra en el segundo printf del programa principal main().



5

El siguiente ejemplo no regresa un valor al programa principal, sino solamente imprime en pantalla los valores de área y longitud, al llamar a la función circulo (). Algoritmo:


entera r función circulo ( entero m ) inicio limpiar pantalla escribir ( ‘ INGRESE EL VALOR DEL RADIO.. ‘ ) leer ( r ) llamar a función circulo ( r ) pausa fin function circulo ( entera m ) inicio declarar variables flotante pi pi ← 3.1416 escribir ( ‘ AREA: ‘ , pi * m * m ) escirbir ( ‘ LONGITUD: ‘ , 2 * pi * m ) fin_cubo Programa: #include<stdio.h> int r; void circulo(int m); main(void) { clrscr(); printf(" INGRESE EL VALOR DEL RADIO.. "); scanf("%d",&r); circulo(r); // llamada a un procedimiento getch(); }

void circulo(int m) // procedimiento {

float pi; pi=3.1416; printf("AREA: %f \n ", pi*m*m); printf("LONGITUD: %f ", 2*pi*m); }

El siguiente programa que tiene la función intercambio( ), muestra los valores dentro de la función, cuando ésta es mandada a llamar por el programa principal.

La función contiene dos parámetros (x, y); que toman los valores que se ingresan en el programa principal como (a,b), para procesarlos dentro de la función e intercambiar sus valores, luego entonces ser mostrados en el printf de la función.



5

Algoritmo:

declarar función

intercambio ( entera x, entera y )


enteras temp, a , b inicio limpiar pantalla escribir ( ‘ Ingrese a: ‘ ) leer ( a ) escribir ( ‘ Ingrese b: ‘ ) leer ( b ) llamar a la función intercambio ( a , b ) pausa fin function intercambio ( entera x, entera y ) inicio temp ← x x ← y y ← temp escribir ( ‘ Nuevos valores de a: ‘ , x , ‘ y b: ‘ , y ) fin_intercambio

Programa:

#include<stdio.h> void intercambio(int x,int y); int temp,a,b; main(void) { clrscr(); printf("ingrese a: "); scanf("%d",&a); printf("ingrese b: "); scanf("%d",&b); intercambio(a,b); getch(); }

void intercambio(int x, int y) { temp = x; x = y; y = temp; printf(" Nuevos valores de a:=%d y b:=%d",x,y); }

UNIDAD II FUNDAMENTOS DE PROGRAMACIÓN ......UNIDAD II FUNDAMENTOS DE PROGRAMACIÓN ESTRUCTURADA...

Documents

Transcript of UNIDAD II FUNDAMENTOS DE PROGRAMACIÓN ......UNIDAD II FUNDAMENTOS DE PROGRAMACIÓN ESTRUCTURADA...