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.