Manual de C Vers. 2005

Programación en C
www.jlbv.com
PROGRAMACIÓN EN C
Ser capaz de desarrollar programas estructurados utilizando la sintaxis y librerías del lenguaje C.
110 horas
Introducción a C.
C es un lenguaje de programación de propósito general. Sus características más importantes son:
• Programación estructurada.
• Economía en las expresiones.
• Abundancia en operadores y tipos de datos.
• Codificación en alto y bajo nivel simultáneamente.
• Reemplaza la programación del ensamblador.
El lenguaje C nació en los laboratorios BELL en 1972, fue creado por Dennis Ritchie y se usó al
principio para crear el sistema operativo UNIX. C surgió de modificaciones realizadas en el lenguaje B.
Una ventaja de C es que es muy transportable, funciona en numerosas máquinas y sistemas
operativos diferentes y además es capaz de realizar programas de muy diferentes propósitos.
Estructura de un Programa C
Un programa en C está formado por una o más funciones. Muchas de las funciones que se utilizan
en los programas de C ya vienen predefinidas, sin embargo si queremos hacer algo que no viene en ninguna
función.
Todo programa de C debe contener una función principal que se ejecutará siempre como cuerpo
principal del programa, y la cual viene definida por un nombre [variable de salida] main ([variables de entrada])
y toda la información reunida entre dos llaves "{ }".
Para ver mejor como es una estructura en C, podemos basarnos en un ejercicio ya terminado para
comentar sus otras estructuras.
Pág. 1
Programación en C
www.jlbv.com
Escribir el siguiente programa:
/* Antes de nada, los comentarios se escribirán entre los símbolos que
rodean esta frase. */
/* Lo primero que hay que definir son las funciones ya predefinidas de C. */
#include <stdio.h>
/* Las definiciones de constantes vienen después de las funciones. */
#define INF -30
#define SUP 100
/* Declaración de funciones a programar. Variable de salida, nombre y
variable de entrada.*/
float Convertir (int c);
/* A partir de aquí vamos a definir el programa principal. */
void main()
{
/* Declaración de variables locales */
int GradCen = INF;
float GradFar = 0;
int Salto = 5;
/* Todas las sentencias se cierran con el ";", sin embargo el while no se cierra
hasta que hayamos terminado el bloque del "{ }".
while (GradCen <=INF)
{
/* Si llamamos a una función tendremos que llamarla como se definió.
GradFar cogerá un valor tipo flotante de la función a la que llama.
Pág. 2
Programación en C
www.jlbv.com
Convertir es la función a la que llamamos dándole el valor GradCen. */
GradFar = Convertir (GradCen);
/* printf nos permite mostrar por pantalla */
printf("%10d C son %10.2f F\n", GradCen, GradFar);
/* asignación con incremento */
GradCen += Salto;
};
}
/* Las funciones y procedimientos se programan después del main, pero
deben definirse antes del main porque si no, el ordenador no es capaz de llamar
a la función. */
float convertir (int Gcent)
{
/* Declaración de variables locales */
float Far;
far = (float)9 / (float)5 * Gcent + 32;
return (Far);
};
Pág. 3
Programación en C
www.jlbv.com
Los tipos y las variables.
Las letras del alfabeto internacional en mayúscula y minúscula, los dígitos y el carácter de subrayado
son los encargados de componer las constantes, los identificadores y las palabras clave. En C son muy
diferentes las variables VARIABLE1 de Variable1, ya que el ordenador no las considera como iguales,
pudiendo servir cada una para realizar cosas diferentes.
Los espacios, tabuladores y saltos de línea no significan nada para el ordenador salvo un cambio de
elemento. Para que más de un espacio se considere, habrá que meterlos entre comillas.
C también utiliza una serie de caracteres que podemos llamar especiales y que son utilizados de
formas muy diferentes: , . ; : ? ‘ “ ( ) [ ] { } < > ! | / \ + - * / ^ % & ~ =
Ya sólo nos falta por usar las secuencias de escape que nos permiten representar por pantalla
movimientos o caracteres de forma física por medio de un símbolo que en C comienza por una barra \.
\n Ir al principio de la línea siguiente.
\t Tabulador horizontal.
\v Tabulador vertical.
\b Retroceso.
\r Retorno de carro si avance de línea.
\f Alimentación de página para la impresora.
\a Alerta sonora.
\’
La forma de mostrar una comilla simple.
\” La forma de mostrar una comilla doble.
\\ La forma de mostrar una barra invertida (una sola barra indicaría una secuencia de escape).
\ddd Representación Octal de un carácter ASCII.
\xdd Representación Hexadecimal de un carácter ASCII.
Los tipos de datos.
Hay en C datos de tipo entero, datos de tipo real y datos que no tienen nada (void).
Los datos de tipo entero son aquellos que no muestran decimales en ninguna de sus opciones y son
char, int, short, long y enum. Los datos de tipo entero tienen la opción de ir de 0 hasta el máximo de la
capacidad, o de ir desde – (máximo/2) + 1 hasta máximo/2
Los datos de tipos reales son aquellos que permiten el uso de comas, y que pueden ser de tres
clases, flota, double y long double.
Pág. 4
Programación en C
www.jlbv.com
• Char (tipo carácter – 1 byte): Se encarga de almacenar un valor que va de 0 a 255 y que suele
estar identificado con un carácter (ya que ocupan lo mismo y por eso se usa este tipo para
guardarlos).
char a=’a’; o char a=122;
• Short (entero corto – 2 bytes): Su rango de números va de 0 a 65535.
unsigned short a=54323;
• Int (entero variable): Tiene el tamaño de las instrucciones del procesador 16, 32 o 64bits (2,4 y 8
bytes).
int a=54323;
• Long (entero largo): También tiene un tamaño no definido que puede ser mayor o igual al del
número entero.
Int a=2147483647;
• Enum (enumerado): Es una lista de valores que se representan con identificadores.
enum MESES { Enero, Febrero, Marzo, Abril, Mayo, Junio, Julio, Agosto,
Septiembre, Octubre, Noviembre, Diciembre} MMVI;
printf(“Introduce un número de mes, 0 al 11: ”);
scanf(“%d”, &MMVI);
printf(“\n%d\n”, MMVI);
• Float (coma flotante): Son números que tienen 4 bytes de tamaño.
float a=3.1415926;
• Double (precisión doble): Tienen 8 bytes de precisión.
double a=2.2e-8;
• Long double (formato largo): Tiene 10bytes.
long double y=1.189731e+4932;
Pág. 5
Programación en C
www.jlbv.com
• Void: especifica un conjunto vacío de valores. Nunca podremos declarar una variable de este
tipo. Void se utiliza para indicar que un procedimiento no recibe valores, o que no devuelve valores.
int funcion(void);
void funcion(int, int);
Cadenas o conjuntos de elementos.
Las cadenas de caracteres son un conjunto de elementos del mismo tipo. Su definición es bastante
sencilla, ya que consiste en la unión de un tipo de variables y una cantidad de ellos unido por el nombre de la
cadena.
int lista[100];
char nombre[15];
Las inicializaciones de las cadenas pueden ser mediante el programa, o directamente.
int edades[5] = {19, 22, 25, 20, 32};
La cantidad de elemento no tiene por qué indicarse, si no se indica el ordenador define la cadena por
la cantidad del número de elementos que hay en la cadena.
Si la cadena se quiere realizar con más de una dimensión, su definición sería la siguiente:
int horario [12][31][24][60][60];
Características principales de las cadenas son que el ordenador en ningún momento sabe el número
de elementos que existen, por lo que el programa no debe mirar en posiciones no existentes.
Si hablamos de cadenas de caracteres, usaremos el valor \0 para identificar el final de cadena.
Tipos combinados.
Los tipos combinados se consiguen tras la definición de unos datos por el usuario a los que se da un
nombre.
Un ejemplo sería el crear un tipo de datos llamado DNI, que sería un tipo entero largo sin signo:
typedef unsigned long DNI;
Ahora podemos decir por ejemplo sin que C nos de ningún error que queremos una variable llamada
cod_cliente que sea del tipo DNI:
DNI cod_cliente;
Pág. 6
Programación en C
www.jlbv.com
También podemos realizar un nuevo tipo de datos que sea una cadena:
typedef enum
{Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo} T-DIAS;
Las variables.
Son palabras formadas desde una sola letra o guión bajo, que pueden ir seguidas de otra letra, un
número o un guión bajo.
Las letras pueden ser mayúsculas o minúsculas, y hay que diferenciar las mayúsculas de las
minúsculas.
Se pueden definir antes del main si queremos que se puedan usar las variables durante todo el
programa, o las pondremos dentro de un procedimiento si queremos que esas variables sólo se puedan usar
desde dentro del procedimiento.
Declaración de constantes.
Las constantes se definen antes del main utilizando la instrucción #define:
#define PI 3.1415926
Palabras clave.
C tiene una serie de palabras que no se pueden tomar como variables, ya que éstas tienen una
función ya predefinida en el propio programa:
auto
break
case
char
const
continue
default
do
double
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
Si en algún momento se abre una biblioteca de funciones, los nombres de estas tampoco se
deberían utilizar, y se deberían interpretar como palabras clave.
Pág. 7
Programación en C
www.jlbv.com
Comentarios.
El comentario en C corresponde a la unión de una barra y un asterisco /*, que delimitan el
comentario y que debe estar cerrado por un asterisco y una barra */.
/* Esto podría ser un comentario de C */
Operadores.
Los operadores son símbolos que permiten manipular los datos al programador. C tiene operadores
aritméticos, lógicos, de relación, booleanos, unitarios, de manejo de bits, de asignación, condicionales, las
direcciones y las indirecciones.
Operadores aritméticos.
Son los que utilizamos para realizar operaciones matemáticas. Nos sirven para sumar (+), restar (-),
multiplicar (*), dividir (/) y calcular el resto de una división (%).
Operadores de relación.
Nos va a devolver uno de los dos posibles valores, Verdadero o Falso, respondiendo a una relación.
Las relaciones pueden ser de menor (<), mayor (>), igual (==), menor o igual (<=), mayor o igual (>=) y
diferente (!=).
Operadores lógicos.
Los operadores lógicos nos permiten calcular el AND (&&), el OR (||) y el NOT (!) de cualquier
relación o grupo de relaciones.
Operadores unitarios.
Estos operadores se aplican a un sólo operando. Los operadores permiten calcular el contrario (!),
cambiar el signo (-) o pasar un valor a complemento a 1 (~). También nos encontramos con otros dos
operadores, el operador de dirección y el de indirección:
• Operador de dirección.
Nos permite guardar los resultados en la dirección de memoria a la que apunta una variable.
&a = 5;
El ejemplo anterior, guarda 5 en la dirección de memoria que tiene A.
• Operador de in-dirección.
Pág. 8
Programación en C
www.jlbv.com
Funciona de forma complementaria y opuesta al operador de dirección, ya que hace justamente lo
contrario que ella, pero nos permite usando las dos realizar la operación de guardar y sacar.
variable = *a;
En este ejemplo, se guarda en VARIABLE aquello que se encuentra en A.
Operadores de manejo de bits.
Estos operadores pueden ser lógicos a nivel de bits como es el caso de AND (&), OR (|) y el XOR (^).
También podemos encontrarnos con operadores de desplazamiento de bits a la izquierda (<<) o a la
derecha (>>).
Operadores de asignación.
Asignan a una variable un valor resultante de una operación.
++
A++
Incrementa A en una unidad
/=
A/=5
Divide A entre 5 y lo guarda
--
A--
Decrece el valor de A en una unidad
%=
A%=5
Guarda el resto de A entre 5
=
A=5
Asignación directa
&=
A&=011
Opera AND a nivel bit.
+=
A+=5
Suma a A 5 y lo guarda en A
|=
A|=011
Opera OR a nivel bit
-=
A-=5
Resta a A 5 y lo guarda en A
^=
A^=011
Opera XOR a nivel bit
*=
A*=5
Multiplica A por 5 y guarda en A
<<= , =>>
A<<=
Desplaza los bits de A
Operadores condicionales.
Dependiendo de una condición elegimos si cambiar por uno u otro operando.
condición ? valor1 : valor2;
El siguiente ejemplo vemos que mayor se va a quedar con la variable que es mayor de ambas. Si A
es mayor que B, nos quedamos con A como MAYOR, en caso de que no se cumpla la condición, B se asigna
a MAYOR.
mayor= (a>b)? a : b;
Pág. 9
Programación en C
www.jlbv.com
Prioridades de cálculo y conversión de tipos.
Por orden de prioridad en el cálculo debemos decir que siempre que tengamos paréntesis,
deberemos calcular estos antes que el resto, de izquierda a derecha y primero el más interno.
La segunda prioridad la tienen los operadores unitarios y los incrementos y decrementos (++ y --).
La tercera prioridad se encarga de la multiplicación, división y resto.
Más adelante nos encontramos con la suma y la resta.
Los operadores de desplazamiento.
Los operadores de relación.
Los operadores lógicos.
El operador condicional.
Y los operadores de asignación.
En el caso de tener que asignar valores de diferentes tipos, hay que destacar que el tipo del
resultado será en todo momento el de mayor tamaño de los necesarios en la operación.
Funciones.
Hay funciones que ya vienen predefinidas dentro del lenguaje de programación C, por lo que no
tenemos que programar al ordenador para realizar las cosas más sencillas y repetitivas, las cuales ya suelen
estar programadas en librerías de funciones que vienen agrupadas por tema de función.
Pág. 10
Programación en C
www.jlbv.com
Funciones básicas.
Hay una serie de funciones que se denominan básicas, ya que hay muchas posibilidades de usarlas
en cualquier momento.
Las funciones más básicas a la hora de realizar un programa son printf, scanf, getchar, getch, getche
y system.
• printf: es la función que permite sacar información del ordenador con formato. Las opciones para
sacar la información son las siguientes.
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 octal.
x
(int) enteros sin signo, en base hexadecimal minúsculas.
X
(int) enteros sin signo, en base hexadecimal mayúsculas.
f
(float) número con coma flotante con signo. [-]dddd.dddd
e
(double) número con coma flotante con signo y exponente. [-]d.dddde[+,-]ddd
E
(double) número con coma flotante con signo y exponente. [-]d.dddde[+,-]ddd
g
(double) elige entre "e" y "f" y se queda con el más compacto.
G
(double) elige entre "e" y "F" y se queda con el más compacto.
c
(carácter) muestra un carácter.
s
(cadena de caracteres) muestra una cadena de caracteres hasta (/0).
También existen modificadores de la información, que permiten especificar más el formato:
-
justifica el resultado a la izquierda dentro del ancho especificado (por defecto es a la derecha).
+
antepone el signo positivo a los números (por defecto sólo a los negativos).
0
rellena la salida con 0 no significativos.
spc
antepone un espacio en blanco si el número es positivo.
#
con "x", antepone un valor de salida "0x".
con "e", "f" o "g" fuerza a la aparición de la coma decimal.
se ignora con "c", "d", "i", "u", o "s".
La función printf permite mostrar además de texto, variables por pantalla:
printf("Tienes %2u años y pesa %3.3f kilos \n", edad, peso);
• scanf: es la función que permite capturar datos. Las opciones de captura de datos son las
mismas que para la salida estándar, pero con unas pequeñas cositas a añadir:
Pág. 11
Programación en C
www.jlbv.com
*
Un asterisco suprime la asignación del siguiente dato de entrada.
h
Se utiliza para indicar el prefijo SHORT.
l
Se utiliza para indicar el prefijo LONG.
u
Se utiliza para indicar el prefijo UNSIGNED. SIGNED viene dado por defecto.
• getchar: devuelve un carácter leído de entrada por la entrada estándar (stdin).
caracter = getchar();
• putchar: muestra el carácter almacenado.
putchar (caracter);
• getch y getche: son funciones hermanas, las dos hacen exactamente lo mismo, leer un carácter
del teclado, pero con la única diferencia entre ellas es que getch no muestra el valor capturado, y
getche si que lo muestra.
• system: permite ejecutar instrucciones del sistema operativo.
system ("cls");
Pág. 12
Programación en C
www.jlbv.com
Sentencias de control.
Las sentencias de control son aquellas que me permiten a los programas a tomar decisiones. Las
sentencias de control también son las encargadas de que se repita una y otra vez el mismo conjunto de
sentencias.
Las sentencias de control más importantes son: if, if anidadas, else if, switch, break, while, do, for y
continue.
• if: permite al programa tomar una decisión para ejecutar una acción u otra basándose en un
resultado positivo o negativo.
if (condicion) {sentencias en caso afirmativo;} else {sentencias en caso negativo;};
• if anidadas: permite al ordenador tomar decisiones dependientes de otras decisiones.
if (condicion1)
{if (condicion2 )
{sentencia1;}
else {sentencia2;};
}
else {sentencia3;};
• else if: muy parecida a los if anidados, pero en este caso con las opciones negativas.
if (condicion1)
sentencia1;
else if (condicion2) sentencia3;
else sentencia4;
• switch: permite ejecutar varias acciones en función del valor de una expresión. Si no
encontramos ningún "break", se ejecutarán todas las sentencias que se encuentren en expresiones
afirmativas. Para que sólo actúe en una sola sentencia, habrá que poner el "break". Si está puesto
el "break", sólo se realizará la opción "default" si no se cumple ninguna otra.
switch (expresion)
{
case expresion1: sentencia1;
case expresion2: sentencia2;
default: sentencia n;
};
Pág. 13
Programación en C
www.jlbv.com
• break: finaliza la ejecución de "switch", como acabamos de ver, o de los bucles "while", "do" o
"for".
• while: ejecuta unas sentencias de 0 a más veces siempre que se cumpla la condición.
while (condicion)
sentencias;
• do: de ejecución similar a while, ejecuta las sentencias de 1 a más veces, si se cumple la
condición.
do
sentencias;
while (condicion);
• for: permite ejecutar una sentencia simple o compuesta, repetidamente un número de veces
conocido.
for (valor1=elemento1, valor2=elemento2; condición; saltocondicion)
{
sentencias;
};
• continue: obliga a continuar al menos una vez más en un bucle while, do y for.
Pág. 14
Programación en C
www.jlbv.com
Funciones de entrada y salida por dispositivos estándar.
Hay una librería que se encarga de recoger a las funciones normales de entrada y salida del
ordenador, esta librería estándar es la llamada STDIO.H.
Hay diferentes formas de comunicar el ordenador con la persona que lo maneja:
• stdin: dispositivo de entrada estándar por teclado.
• stdout: dispositivo de salida estándar por pantalla.
• stderr: dispositivo de error estándar.
• stdaux: dispositivo auxiliar de comunicación, puerto serie.
• stdprn: dispositivo de impresión estándar, puerto paralelo.
Las funciones más normales que usa esta librería son: fputc, fgetc, putw, getw, fputs, fgets, fopen,
freopen, fclose, ferror, clearerr, feof, perror, fprintf, fscanf, fwrite, fread, setbuf, setvbuf, fflush, tmpfile, fseek,
ftell, y rewind:
• fputc: escribe un carácter en la posición indicada.
fputc( "A", salida);
• fgetc: lee un carácter de la posición indicada.
caracter = fgetc(entrada);
• putw: escribe una cadena en la posición indicada.
• getw: lee una cadena de una posición indicada.
• fputs: copia la cadena dada donde se quiera.
fputs( cadena, fichero);
• fgets: toma una cadena de valores y lo guarda donde se quiera.
cadena[]= fgets(cadena2, Elementos, fichero);
• fopen: abre el fichero para trabajar con él. Hay 6 modos de abrir los ficheros. "r": para lectura.
"w": para escritura, creándolo o machacándolo. "a": para escribir al final del mismo. "r+" para lectura
y escritura en un archivo que ya existe. "w+" para lectura y escritura, creando el archivo o
borrándolo si existe. "a+": para lectura y escritura, añade o crea el archivo si no existe.
fichero = fopen ("datos.dat", "w");
• freopen: redirige un archivo a una entrada o salida. Suele usar "w" con stdout, y "r" con stdin.
fichero = freopen ("datos.dat", "w", stdout);
• fclose: cierra los archivos abiertos.
fclose(fichero);
• ferror: verifica si ha habido un error en la operación con ficheros.
Pág. 15
Programación en C
www.jlbv.com
• clearerr: desactiva el indicador de error y el indicador de fin de fichero, poniéndolos a 0.
• feof: devuelve un valor distinto de 0 cuando un fichero se encuentra al final.
• perror: devuelve el mensaje que devuelve el sistema en referencia a un error.
• fprintf: escribe una cadena con formato en un fichero.
• fscanf: toma una cadena con formato en un fichero.
• fwrite: permite escribir c elementos de longitud n bytes almacenados en una cadena en un
fichero.
• fread: permite leer c elementos de una longitud de n bytes de un fichero y los guarda en una
cadena.
• setbuf: permite al usuario controlar la memoria intermedia asignada al fichero.
• setvbuf: permite al usuario controlar el tamaño de la memoria intermedia asignada al fichero.
• fflush: borra la memoria intermedia.
• tmpfile: crea un fichero temporal a modo de intercambio de información.
• fseek: mueve el apuntador de un fichero para su lectura. Se puede hacer SEEK_SET para
apuntar al principio del fichero, SEEK_CUR para la posición actual del puntero y SEEK_END que
apunta al final del fichero.
fseek(fichero, 0L, SEEK_SET);
• ftell: devuelve la posición del apuntador (es de tipo long).
pos = ftell(fichero);
• rewind: mueve el apuntador al comienzo del fichero, es similar a fseek con SEEK_SET.
Pág. 16
Programación en C
www.jlbv.com
Funciones matemáticas.
La función más conocida de matemáticas es MATH.H.
Para poder utilizar esta función habrá que definirla como el resto de las funciones:
#include <math.h>
Las variables que admite son de tipo double, al igual que el dato resultante de la operación.
Las funciones que se encuentran en la librería MATH, son las siguientes: fabs, floor, ceil, pow, sqrt,
sin, cos, tan, acos, asin, atan, atan2, sinh, cosh, tanh, log10, log, exp,
• fabs: da como resultado el valor absoluto de x.
• floor: devuelve el entero menor o igual más cercano a un número.
• ceil: devuelve el entero mayor o igual más cercano a un número.
• pow: haya la potencia de x elevado a y. Devuelve un error en el caso de las indeterminaciones,
que son la exponenciación de 0 elevado a 0, de un negativo elevado a un número con decimales, o
de o elevado a un número negativo.
• sqrt: la raiz cuadrada de un número, pero dará un error en el caso de hacerlo con un número
negativo.
• sin: devuelve el resultado del seno en radianes.
• cos: devuelve el resultado del coseno en radianes.
• tan: devuelve el resultado de la tangente en radianes.
• acos: devuelve el arco cuyo coseno se introduce por teclado.
• asin: devuelve el arco cuyo seno se introduce por teclado.
• atan: devuelve el arco cuya tangente se introduce por teclado.
• atan2: devuelve el arco cuya tangente es valor2 / valor1.
• sinh: devuelve el seno hiperbólico en radianes.
• cosh: devuelve el coseno hiperbólico en radianes.
• tanh: devuelve la tangente hiperbólica en radianes.
• log10: devuelve el logaritmo en base 10 del valor dado.
• log: devuelve el logaritmo del valor dado.
• exp: devuelve el la exponenciación de e al valor dado.
Pág. 17
Programación en C
www.jlbv.com
PROGRAMACIÓN EN C ...................................................................................................................... 1
Introducción a C. .............................................................................................................................. 1
Estructura de un Programa C........................................................................................................... 1
Los tipos y las variables. .................................................................................................................. 4
Los tipos de datos........................................................................................................................ 4
Cadenas o conjuntos de elementos............................................................................................. 6
Tipos combinados. ....................................................................................................................... 6
Las variables................................................................................................................................ 7
Declaración de constantes........................................................................................................... 7
Palabras clave. ............................................................................................................................ 7
Comentarios. .................................................................................................................................... 8
Operadores. ..................................................................................................................................... 8
Operadores aritméticos................................................................................................................ 8
Operadores de relación................................................................................................................ 8
Operadores lógicos...................................................................................................................... 8
Operadores unitarios.................................................................................................................... 8
Operadores de manejo de bits..................................................................................................... 9
Operadores de asignación. .......................................................................................................... 9
Operadores condicionales. .......................................................................................................... 9
Prioridades de cálculo y conversión de tipos. ............................................................................ 10
Funciones....................................................................................................................................... 10
Funciones básicas. .................................................................................................................... 11
Sentencias de control................................................................................................................. 13
Funciones de entrada y salida por dispositivos estándar........................................................... 15
Funciones matemáticas. ............................................................................................................ 17
Pág. 18