Unidad didactica Nro 4 (Clase Nro 5)

Unidad IV: Funciones

Librerías estándar

Todos los compiladores C y C++ disponen de ciertas librerías de funciones estándar que facilitan el acceso a la pantalla, al teclado, a los discos, la manipulación de cadenas, y muchas otras cosas, de uso corriente.

Ficheros Funcionalidad/funciones
Parte del a STL que contiene los algoritmos estándar de Entrada y Salida.
Encabezado estandar de entrada/salida.
Contiene los prototipos de las funciones matemáticas de la biblioteca.
Contiene prototipos de funciones y tipos para manipular la fecha y la hora.
Contiene los prototipos de las funciones para la conversión de números a texto y de texto a números, asignación de memoria, números aleatorios y otras funciones. Tiene la definición de la función RAND (random).
Contiene los prototipos de las funciones para el procesamiento de cadenas.
Para emplear la función getch ().

Funciones mas usadas de librerías
Función "sqrt(x)"
Devuelve la raiz cuadrada de x. Requiere la librería "math.h".
Sintaxis: sqrt(x);

Función "exp(x)"
Devuelve el exponencial de x. Requiere la librería "math.h".
Sintaxis: exp(x);

Función "pow(x,y)"
Devuelve la potencia de x elevada a y. Requiere la librería "math.h".
Sintaxis: pow(x,y);

Función "floor(x)"
Devuelve el Nro x redondeado al mas grande. Requiere la librería "math.h".
Sintaxis: floor(x);

Función "max()"
Devuelve el mayor de dos valores. Requiere la librería "stdio.h".
Sintaxis: max( t1, t2 );

Función "min()"
Devuelve el menor de dos valores. Requiere la librería "stdio.h".
Sintaxis: min( t1, t2 );

Función "abs()"
Devuelve el valor absoluto de un entero. Requiere la librería "stdio.h".
Sintaxis: int abs(int x);

Función "rand()"
Generador de números aleatorios. Requiere la librería "stdlib.h".
La función "rand" devuelve un número aleatorio entre 0 y RAND_MAX. La constante RAND_MAX está definida en stdlib.h.
Valor de retorno: "rand" devuelve un número entre 0 y RAND_MAX.
Sintaxis: int rand(void);
Ejemplo: i = 1 + rand () % 6 /* Crea un numero entre 1 y 6 */

Función "srand()"
Inicializa el generador de números aleatorios. Requiere la librería "stdlib.h".
La función "srand" sirve para cambiar el origen del generador de números aleatorios.
Valor de retorno: "srand" no devuelve ningún valor.

Sintaxis: void srand(unsigned semilla);
Ejemplo: srand (time (0)) /* Inicializa */

Tiro de dados, calcula la suma y despliega los resultados
# include
# include /* para la función time */
# include para las funciones srand y rand */
int main ( void )
{
int dado1; /* primer dado */
int dado2; /* segundo dado */
int sumaTemp; /* suma de los dados */
srand (time (0)); /* Inicializa el generador de números aleatorios */
dado1 = 1 + ( rand() % 6 ); /* toma el aleatorio para el dado1 */
dado2 = 1 + ( rand() % 6 ); /* toma el aleatorio para el dado2 */
sumaTemp = dado1 + dado2; /* suma el dado1 y el dado2 */
printf("El jugador tiro %d + %d = %d\n", dado1, dado2, sumaTemp); /* despliega los resultados */
return sumaTemp; /* devuelve la suma de los dados */
}


Verificación de las funciones matemáticas de la biblioteca
#include
#include
int main() /* la función main inicia la ejecución del programa */
{
printf( "sqrt(%.1f) = %.1f\n", 900.0, sqrt( 900.0 ) ); /* calcula y despliega la raiz cuadrada */
printf( "sqrt(%.1f) = %.1f\n", 9.0, sqrt( 9.0 ) );
printf( "exp(%.1f) = %f\n", 1.0, exp( 1.0 ) ); /* calcula y despliega la función exponencial e a la x */
printf( "exp(%.1f) = %f\n", 2.0, exp( 2.0 ) );
printf( "log10(%.1f) = %.1f\n", 1.0, log10( 1.0 ) ); /* calcula y despliega el logaritmo (base 10) */
printf( "log10(%.1f) = %.1f\n", 10.0, log10( 10.0 ) );
printf( "log10(%.1f) = %.1f\n", 100.0, log10( 100.0 ) );
printf( "fabs(%.1f) = %.1f\n", 13.5, fabs( 13.5 ) ); /* calcula y despliega el valor absoluto */
printf( "fabs(%.1f) = %.1f\n", 0.0, fabs( 0.0 ) );
printf( "fabs(%.1f) = %.1f\n", -13.5, fabs( -13.5 ) );
printf( "ceil(%.1f) = %.1f\n", 9.2, ceil( 9.2 ) ); /* calcula y despliega ceil( x ) */
printf( "ceil(%.1f) = %.1f\n", -9.8, ceil( -9.8 ) );
printf( "floor(%.1f) = %.1f\n", 9.2, floor( 9.2 ) ); /* calcula y despliega floor( x ) */
printf( "floor(%.1f) = %.1f\n", -9.8, floor( -9.8 ) );
printf( "pow(%.1f, %.1f) = %.1f\n", 2.0, 7.0, pow( 2.0, 7.0 ) ); /* calcula y despliega pow( x, y ) */
printf( "pow(%.1f, %.1f) = %.1f\n", 9.0, 0.5, pow( 9.0, 0.5 ) );
printf( "sin(%.1f) = %.1f\n", 0.0, sin( 0.0 ) ); /* calcula y despliega sin( x ) */
printf( "cos(%.1f) = %.1f\n", 0.0, cos( 0.0 ) ); /* calcula y despliega cos( x ) */
printf( "tan(%.1f) = %.1f\n", 0.0, tan( 0.0 ) ); /* calcula y despliega tan( x ) */
return 0; /* indica terminación exitosa */
}


Escala y cambio de enteros producidos por 1 + rand() % 6
#include
#include
int main()
{
int i; /* contador */
int fin;
for ( i = 1; i <= 20; i++ ) { /* repite 20 veces */
printf( "%10d", 1 + ( rand() % 100 ) ); /* obtiene un número aleatorio entre 1 y 6 y lo despliega */
if ( i % 5 == 0 ) { /* si el contador es divisible entre 5, comienza una nueva línea de salida */
printf( "\n" );
} /* fin de if */
} /* fin de for */
scanf ("%d", &fin);
return 0; /* indica terminación exitosa */
}

Unidad didactica Nro 4 (Clase Nro 4)

Unidad IV: Funciones

Sentencia "if” y "if...else"
Implementa la ejecución condicional de una sentencia. Requiere la librería "stdio.h".
Sintaxis: if ()
if () else
Ejemplo: if (x= =1) { }
if (x= =1) { } else { }

Se pueden declarar variables dentro de la condición. Por ejemplo: if(int val = func(arg))...
En este caso, la variable "val" sólo estará accesible dentro del ámbito de la sentencia "if" y, si existe, del "else".
Si la condición es "true" se ejecutará la sentencia1, si es "false" se ejecutará la sentencia2.
El "else" es opcional, y no pueden insertarse sentencias entre la sentencia1 y el "else".

Programa que al ingresar dos números enteros me dice si son iguales, mayor, menor, igual mayor o menor
#include
main() /* la función main inicia la ejecución del programa */
{
int num1; /* primer número que lee el usuario */
int num2; /* segundo número que lee el usuario */
printf( "Introduza dos enteros, y le dire\n" );
printf( "las relaciones que satisfacen: " );
scanf( "%d%d", &num1, &num2 ); /* lectura de los enteros */
if ( num1 == num2 ) {
printf( "%d es igual que %d\n", num1, num2 );
} /* fin de if */
if ( num1 != num2 ) {
printf( "%d no es igual que %d\n", num1, num2 );
} /* fin de if */
if ( num1 < num2 ) { printf( "%d es menor que %d\n", num1, num2 ); } /* fin de if */ if ( num1 > num2 ) {
printf( "%d es mayor que %d\n", num1, num2 );
} /* fin de if */
if ( num1 <= num2 ) { printf( "%d es menor o igual que %d\n", num1, num2 ); } /* end if */ if ( num1 >= num2 ) {
printf( "%d es mayor o igual que %d\n", num1, num2 );
} /* fin de if */
return 0; /* indica que el programa terminó con éxito */
} /* fin de la función main */
Operadores
== igual != desigual > mayor < menor >= mayor e igual <= menor e igual Sentencia "switch" Cuando se usa la sentencia "switch" el control se transfiere al punto etiquetado con el "case" cuya expresión constante coincida con el valor de la variable del "switch", no te preocupes, con un ejemplo estará más claro. A partir de ese punto todas las sentencias serán ejecutadas hasta el final del "switch", es decir hasta llegar al "}". Esto es así porque las etiquetas sólo marcan los puntos de entrada después de una ruptura de la secuencia de ejecución, pero no marcan las salidas. Requiere la librería "iostream.h". Esta característica nos permite ejecutar las mismas sentencias para varias etiquetas distintas, y se puede eludir usando la sentencia de ruptura "break" al final de las sentencias incluidas en cada "case". Si no se satisface ningún "case", el control parará a la siguiente sentencia después de la etiqueta "default". Esta etiqueta es opcional y si no aparece se abandonará el "switch". Para emplear números en el case, quitarle las comillas. Sintaxis: switch ()
{ case : [... ] [break;]
. . .
[default : ]
}
Ejemplo: switch ( calificacion ) {
case 'A': /* la calificación es A */
++cuentaA; /* incrementa cuentaA */
break; /* necesario para salir de switch */
default: /* atrapa todos los demás caracteres */
} /* fin de switch */

Programa que ingresa una letra y me dice si es vocal
#include
#include
int main ()
{
char letra; int EsVocal;
cin>>letra;
switch (letra)
{
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
EsVocal = true; //es lo que hace en caso de que la letra sea igual a alguna vocal
break; //detiene el programa
default:
EsVocal = false;
}
cout<
getch ();
return 0;
}

Ver ejercicio Nro 18 del trabajo práctico.
En este ejemplo letra es una variable de tipo "char" y EsVocal de tipo "bool". Si el valor de entrada en el "switch" corresponde a una vocal, EsVocal saldrá con un valor verdadero, en caso contrario, saldrá con un valor falso. El ejemplo ilustra el uso del "break", si letra es 'a', se cumple el primer "case", y la ejecución continúa en la siguiente sentencia, ignorando el resto de los "case" hasta el "break".

Unidad didactica Nro 4 (Clase Nro 3)

Unidad IV: Funciones

Suma de dos números
# include
int main()
{
int numero;
numero = 2 + 2;
return 0;
}

- Línea: “#include ” y “#include ”
Librerías necesarias para ambas funciones
Para que no se cierre: cin.get();
Para que no se cierre: getch ();

- Línea: "#”
Las líneas que comienzan con eso son procesadas por el preprocesadosador antes de que el programa se compile.

- Primera línea: "int main()"
Se trata de una línea muy especial, y la encontrarás en todos los programas C y C++. Es el principio de la definición de una función. Todas las funciones C toman unos valores de entrada, llamados parámetros o argumentos, y devuelven un valor de retorno. La primera palabra: "int", nos dice el tipo del valor de retorno de la función, en este caso un número entero. La función "main" siempre devuelve un entero. La segunda palabra es el nombre de la función, en general será el nombre que usaremos cuando queramos usar o llamar a la función.
En este caso "main" es una función especial, ya que nosotros no la usaremos nunca explícitamente, es decir, nunca encontrarás en ningún programa una línea que invoque a la función "main". Esta función será la que tome el control automáticamente cuando se ejecute nuestro programa. Otra pista por la que sabemos que se trata de una función son los paréntesis, todas las definiciones de funciones incluyen una lista de argumentos de entrada entre paréntesis, en nuestro ejemplo es una lista vacía, es decir, nuestra función no admite parámetros.

- Segunda línea: "{"
Aparentemente es una línea muy simple, las llaves encierran el cuerpo o definición de la función. Más adelante veremos que también tienen otros usos.

- Tercera línea: "int numero;"
Esta es nuestra primera sentencia, todas las sentencias terminan con un punto y coma. Esta concretamente es una declaración de variable. Una declaración nos dice, a nosotros y al compilador, que usaremos una variable "numero" de tipo entero. Esta declaración obliga al compilador a reservar un espacio de memoria para almacenar la variable "numero", pero no le da ningún valor inicial. En general contendrá "basura", es decir, lo que hubiera en esa zona de memoria cuando se le reservó espacio. En C y C++ es obligatorio declarar las variables que usará el programa.
C y C++ distinguen entre mayúsculas y minúsculas, así que "int numero;" es distinto de "int NUMERO;", y también de "INT numero;".

- Cuarta línea: ""
Una línea vacía, no sirve para nada, al menos desde el punto de vista del compilador, pero sirve para separar visualmente la parte de declaración de variables de la parte de código que va a continuación. Se trata de una división arbitraria. Desde el punto de vista del compilador, tanto las declaraciones de variables como el código son sentencias válidas. La separación nos ayudará a distinguir visualmente dónde termina la declaración de variables. Una labor análoga la desempeña el tabulado de las líneas: ayuda a hacer los programas más fáciles de leer.

- Quinta línea: "numero = 2 + 2;"
Se trata de otra sentencia, ya que acaba con punto y coma. Esta es una sentencia de asignación. Le asigna a la variable "numero" el valor resultante de la operación "2 + 2".

- Sexta línea: "return 0;"
De nuevo una sentencia, "return" es una palabra reservada, propia de C y C++. Indica al programa que debe abandonar la ejecución de la función y continuar a partir del punto en que se la llamó. El 0 es el valor de retorno de nuestra función. Cuando "main" retorna con 0 indica que todo ha ido bien. Un valor distinto suele indicar un error. Imagina que nuestro programa es llamado desde un fichero de comandos, un fichero "bat" o un "script". El valor de retorno de nuestro programa se puede usar para tomar decisiones dentro de ese fichero. Pero somos nosotros, los programadores, los que decidiremos el significado de los valores de retorno.

- Séptima línea: "}"
Esta es la llave que cierra el cuerpo o definición de la función.
Lo malo de este programa, a pesar de sumar correctamente "2+2", es que aparentemente no hace nada. No acepta datos externos y no proporciona ninguna salida de ningún tipo. En realidad es absolutamente inútil, salvo para fines didácticos, que es para lo que fue creado. Paciencia, iremos poco a poco. En los siguientes capítulos veremos tres conceptos básicos: variables, funciones y operadores. Después estaremos en disposición de empezar a trabajar con ejemplos más interactivos.

“/*” o “//”: para comentario.
“\n”: coloca al cursor al principio de la línea siguiente.
“\t”: mueve el cursor a la siguiente posición del tabulador.
“\a”: suena la campana del sistema.
“\””: inserta unas comillas en el sistema.

Función "printf()"
Sintaxis: int printf (const char* formato,...)
Ejemplo: printf ( "Escriba su nombre: " );
printf ( "\nHola %s. Tienes %d anyos.\n", nombre, edad );

Requiere la librería "stdio.h". Esta función acepta listas de parámetros con un número indefinido de elementos. Entendamos que el número está indefinido en la declaración de la función, pero no en su uso, el número de argumentos dependerá de la cadena de formato, y conociendo ésta, podrá precisarse el número de argumentos. Si no se respeta esta regla, el resultado es impredecible, y normalmente desastroso, sobre todo cuando faltan argumentos. En general, los sobrantes serán simplemente ignorados.
Cada argumento se aplicará a la cadena de formato y la cadena resultante se enviará a la pantalla.

Opciones
Opción Significado
- Justifica el resultado a la izquierda, rellena a la derecha con espacios, si no se da se asume justificación a la derecha, se rellena con ceros o espacios a la izquierda.
+ El número se mostrará siempre con signo (+) o (-), según corresponda.
Espacio Igual que el anterior, salvo que cuando el signo sea positivo se mostrará un espacio.
# Especifica que el número se convertirá usando un formato alternativo

Caracteres de conversión de tipo
Carácter de tipo Entrada esperada Formato de salida
d Entero con signo Entero decimal
i Entero con signo Entero decimal
o Entero con signo Entero octal
u Entero sin signo Entero decimal
x Entero sin signo Entero hexadecimal (con a, b, c, d, e, f)
X Entero sin signo Entero hexadecimal (con A, B, C, D, E, F)
f Coma flotante Valor con signo: [-]dddd.dddd
e Coma flotante Valor con signo: [-]d.dddd...e[+/-]ddd
g Coma flotante Valor con signo, dependiendo del valor de la precisión. Se rellenará con ceros y se añadirá el punto decimal si es necesario.
E Coma flotante Valor con signo: [-]d.dddd...E[+/-]ddd
G Coma flotante Como en g, pero se usa E para los exponentes.
c Carácter Un carácter.

Imprime Bienvenido a C!
#include
int main(void) /* la función main inicia la ejecución del programa */
{
printf( "Bienvenido a C!\n" );
return 0; /* indica que el programa terminó con exito */
} /* fin de la función main */

#include
int main(void)
{
int i = 123;
int j = -124;
float x = 123.456;
float y = -321.12;
char Saludo[5] = "hola";
printf("|%6d|\n", i); // | 123|
printf("|%-6d|\n", i); // |123 |
printf("|%06d|\n", i); // |000123|
printf("|%+6d|\n", i); // | +123|
printf("|%+6d|\n", j); // | -124|
printf("|%+06d|\n", i); // |+00123|
printf("|% 06d|\n", i); // | 00123|
printf("|%6o|\n", i); // | 173|
printf("|%#6o|\n", i); // | 0173|
printf("|%06o|\n", i); // |000173|
printf("|%-#6o|\n", i); // |0173 |
printf("|%6x|\n", i); // | 7b|
printf("|%#6X|\n", i); // | 0X7B|
printf("|%#06X|\n", i); // |0X007B|
printf("|%-#6x|\n", i); // |0x7b |
printf("|%10.2f|\n", x); // | 123.46|
printf("|%10.4f|\n", x); // | 123.4560|
printf("|%010.2f|\n", x); // |0000123.46|
printf("|%-+10.2e|\n", y); // |-3.21e+02 |
printf("|%*.*f|\n", 14, 4, x); // | 123.4560|
printf("%.2f es el 10%% de %.2f\n", .10*x, x); // 12.35 es el 10% de 123.46
printf("%s es un saludo y %c una letra\n", Saludo, Saludo[2]); // hola es un saludo y l una letra
printf("%.2s es parte de un saludo\n", Saludo); // ho es parte de un saludo
return 0;
}

cout, canal de salida estándar.
Imagina un canal por el que circula agua, si echamos al canal objetos que floten, estos se moverán hasta el final de canal, siguiendo el flujo del agua. Requiere la librería "iostream.h”.
Por ejemplo, en C++ el canal de salida es "cout", los objetos flotantes serán los argumentos que queremos extraer del ordenador o del programa, la salida del canal es la pantalla.

Sintaxis: cout << [<< ...];
Ejemplo: cout << "hola" << " " << endl; Los operadores "<<" representarían el agua, y la dirección en que se mueve. Cualquier cosa que soltemos en el agua: "hola", " " o endl, seguirá flotando hasta llegar a la pantalla, y además mantendrán su orden. cin, canal de entrada estándar Sobre el uso de "cin", que es el único canal de entrada predefinido, tenemos que aclarar cómo se usa, aunque a lo mejor ya lo has adivinado. Requiere la librería "iostream.h” Donde cada variable irá tomando el valor introducido mediante el teclado. Los espacios y los retornos de línea actúan como separadores. Sintaxis: cin >> [>> ...];
Ejemplo: cin >> Nombre >> DNI;

#include
int main()
{
char Nombre[30]; // Usaremos una cadena para almacenar el nombre (29 caracteres)
int Edad; // Un entero para la edad
char Telefono[8]; // Y otra cadena para el número de teléfono (7 dígitos)
cout << "Introduce tu nombre, edad y número de teléfono" << endl; // Mensaje para el usuario cin >> Nombre >> Edad >> Telefono; // Lectura de las variables
cout << "Nombre:" << Nombre << endl; // Visualización de los datos leídos cout << "Edad:" << Edad << endl; cout << "Teléfono:" << Telefono << endl; return 0; } scanf, canal de entrada estándar La función scanf() (scan-format, escanear con formato), en realidad representa a una familia de funciones que escanean una entrada de datos con formato y cargan el resultado en los argumentos que se pasan por referencia a dicha función o funciones. Requiere la librería "stdio.h". Sintaxis: scanf(tipo, &var); tipo: Tipo de dato a almacenar (&) se utiliza para indicar una dirección de memoria de la variable donde se almacenará el dato. Cuando se guardan de cadenas de caracteres, al tratarse de un array de tipo char, el & se omite. var: variable para almacenar el dato. Ejemplo: scanf("%d",&n); // Este ejemplo guarda un número en n. char m; // Este ejemplo guarda un caracter en m. printf("Introduce un caracter: "); scanf("%c",&m); char cad[20]; // Este ejemplo guarda una cadena de caracteres (solamente una palabra) en cad, Notese la ausencia de & printf("Introduce una palabra: "); scanf("%s",cad); printf("Introduce una palabra: "); scanf("%10s",cad); // lee a lo más 10 caracteres y le concatena el caracter cero. Introduce dos números, los suma y los muestra en pantalla #include
int main()
{
int entero1; /* primer número introducido por el usuario */
int entero2; /* segundo número introducido por el usuario */
int suma; /* variable en la cual se almacena la suma */
printf( "Introduzca el primer entero\n" ); /* indicador */
scanf( "%d", &entero1 ); /* lee un entero */
printf( "Introduzca el segundo entero\n" ); /* indicador */
scanf( "%d", &entero2 ); /* lee un entero */
suma = entero1 + entero2; /* asigna el total a suma */
printf( "La suma es %d\n", suma ); /* imprime la suma */
return 0; /* indica que el programa terminó con éxito */
}

Operadores aritméticos
Existen dos operadores aritméticos unitarios, '+' y '-', que asignan valores positivos o negativos a la expresión a la que se aplican.

Son usados para crear expresiones matemáticas.
Sintaxis: + -
* /

Sintaxis: %
El operador de módulo '%', devuelve el resto de la división entera del primer operando entre el segundo. Por esta razón no puede ser aplicado a operandos en coma flotante.

Video de Bienvenida