C++ / funciones

Bienvenidos sean a este post, hoy veremos el primer tema importante de una serie de muchos.

Hoy si trataremos el primer tema interesante si vienen de los posts anteriores. Las funciones son las que permiten las acciones para nuestros programas, y reutilizarlas siempre que lo necesitemos. Veamos como es su sintaxis mas basica:

tipo_de_dato nombre_func(<argumentos>) {

	... instrucciones ..
	
}

Siempre ira primero el tipo de dato, recuerden que en este post mencionamos que el tipo de dato que asignamos es el mismo que devolveremos al final de la funcion. Los tipos de datos que podemos asignarle son los primitivos que mencionamos en este post. Pero estas son dos verdades a medias, porque mas adelante veremos como crear mas tipos de datos y tendremos una excepcion al momento de devolver el tipo de dato. Luego tenemos el nombre identificador que utilizaremos en el codigo para llamar a la funcion cuando sea necesario. Los argumentos son opcionales pero estos nos permitiran pasar informacion al bloque de la funcion. Por ultimo, tenemos el bloque de codigo donde haremos todas las acciones necesarias. Pasemos a analizar unu ejemplo, para ello crearemos un archivo on el nombre de ejemplo02.cpp y le agregaremos el siguiente codigo:

#include <iostream>

int sumar(int a, int b)
{
        int total = a + b;
        return total;
}

int main()
{
        int valor_1, valor_2, total;
        std::cout << "Ingresa un numero: ";
        std::cin >> valor_1;
        std::cout << "Ingresa otro numero: ";
        std::cin >> valor_2;
        total = sumar(valor_1, valor_2);

        std::cout << "La suma da: " << total << std::endl;

        return 0;
}

Por fuera del main definimos a nuestra funcion. Esta es de tipo int y recibe dos valores del mismo tipo para sumarlos entre si y asignarlos a una variable que sera la devolucion final de la misma. En el main declaramos tres variables, lo siguientes sera dos llamados a cin para que ingresemos un valor a las dos primeras variables declaradas y luego tomaremos a la ultima variable declarada y le asignaremos el valor devuelto de la funcion anterior a la cual le pasamos los dos valores ingresados anteriormente. Para finalmente mostrar en pantalla un mensaje y el valor almacenado en total. Compilemos y veamos como trabaja:

$ ./ejemplo02
Ingresa un numero: 20
Ingresa otro numero: 25
La suma da: 45
$

Esto es un ejemplo muy basico de como crear una funcion, pasarle informacion y que nos devuelva un dato despues de procesarla.

Al comienzo de este post mencionamos que la funcion siempre devuelve un valor del mismo tipo de la funncion y que esto no es asi completamente. Vamos a hablar sobre este tema, para ello tomen el codigo anterior y realicemos las siguientes modificaciones:

#include <iostream>

int sumar(int a, int b)
{
        int total = a + b;
        return total;
}

void saludar()
{
        std::cout << "Hola, Mundo!" << std::endl;
}

int main()
{
        saludar();

        return 0;
}

En este codigo agregamos una nueva funcion llamada saludar y sera de tipo void. Este es un tipo especial que lo podemos considerar como comodin porque se utiliza cuando el tipo de informacion que debemos manejar es desconocido, tambien para cuando no debemos devolver ningun tipo de dato, y si bien se puede utilizar su uso no es recomendado de forma muy general. En este caso, solamente lo utilizamos para mostrar un mensaje en pantalla. En el main eliminamos todo el codigo anterior y solo hacemos un llamado a esta funcion. Compilemos y veamos como es su salida:

$ ./ejemplo02
Hola, Mundo!
$

Hizo lo que mencionamos, vamos a complicarlo un poco mas y para ello modificaremos a la funcion saludar de la siguiente manera:

void saludar()
{
        char nombre[80];
        std::cout << "Ingresa tu nombre: ";
        std::cin >> nombre;
        std::cout << "Hola, " << nombre << std::endl;
}

Primero declaramos una nueva variable,, luego pedimos que ingresen un nombre mediante cin y lo almacemamos en la variable anterior. Para finalmente mostrar el mensaje de hola con el nombre ingresado. Compilemos y veamos como es la salida:

$ ./ejemplo02
Ingresa tu nombre: tinchicus
Hola, tinchicus
$

De nuevo, cumplio con lo solicitado. Nos pide un nombre, lo ingresamos y lo mostramos en pantalla. Solamente modificando la funcion sin necesidad de tocar el resto del codigo.

Pasemos a hablar sobre una modalidad de las funciones como son los prototipos. Estos los podemos considerar como declaraciones de una funcion. Si bien, en estos codigos basicos no tendra mucho sentido pero lo sera cuando hablemos sobre las librerias aunque por el momento nos centraremos en este tema. Para entender el concepto vamos a modificar el codigo de nuestro archivo de la siguiente manera:

#include <iostream>

char nombre[80];
int total;
int sumar(int, int);
void preguntar();

int main()
{
        preguntar();

        std::cout << "Hola, " << nombre << std::endl;
        std::cout << "Tu suma dio " << total << std::endl;

        return 0;
}

int sumar(int a, int b)
{
        return a + b;
}

void preguntar()
{
        int valor_1, valor_2;
        std::cout << "Ingresa tu nombre: ";
        std::cin >> nombre;
        std::cout << "Ingresa un numero: ";
        std::cin >> valor_1;
        std::cout << "Ingresa otro numero: ";
        std::cin >> valor_2;

        total = sumar(valor_1, valor_2);
}

Hablemos de la primera parte, en ella haremos cuatro simple declaraciones. La primera sera una variable de tipo char para almacenar un dato de tipo texto, la segunda sera de tipo int para almancenar un numero y ambos casos seran globales porque estan por fuera de cualquier bloque. Las siguientes dos declaraciones son de las funciones o mas comunmente denominadas como prototipos. Observen que solo pasamos lo basico: el tipo de la funcion, el nombre identificador y si tiene argumentos solamente los tipos de estos y la cantidad. No es necesario pasarles un nombre porque al ser simple declaraciones cuando las definamos se los estableceremos. Antes de comentar las definiciones, hablemos sobre el main. En este llamaremos a preguntar y luego mostraremos el valor de nombre y luego el de la otra variable. Con esto comentado ahora si podemos pasar a hablar sobre las definiciones.

Como dijimos antes, este es un caso particular solo de practica pero en la vida real tanto el prototipo como la definicion estaran en un archivo aparte. Pero si lo trabajamos de esta forma, la definicion siempre ira despues del main. Funciona porque al estar declarado antes del main, le dice al compilador que en alguna parte del codigo estas declaraciones fueron definidas y con eso lo contenta, se que suena raro pero es asi. Primero definiremos a sumar donde recibiremos dos valores y devolvemos la suma de los valores recibidos, sin necesidad de pasarlo a otra variable como vimos anteriormente, y luego tenemos la definicion de preguntar. En esta primero declaramos dos variables, pero lo primero que haremos sera preguntar por el nombre y lo almacenamos en nombre, recuerden que esta es global y se puede acceder desde cualquier parte del codigo, y luego por dos numeros para asignarlos a las variables declaradas anteriormente. Estas las pasaremos a la funcion sumar y el valor devuelto lo asignamos a la otra variable global, total, y con esto le asignamos los valores a ambas. Compilemos y veamos como es su salida:

$ ./ejemplo02
Ingresa tu nombre: tinchicus
Ingresa un numero: 20
Ingresa otro numero: 10
Hola, tinchicus
Tu suma dio 30
$

Vean, como nos pidio primero los tres datos y luego los mostro correctamente. Como pueden ver no solamente se pueden utilizar variables globales en toda parte del codigo, como mencionamos siempre, sino que podemos llamar una funcion desde otra funcion. Pasemos a ver un tema bastante simple pero muy util, como es el establecimiento de valores predeterminados en argumentos. Tomemos el codigo anterior y hagamos la siguiente modificacion:

#include <iostream>

char nombre[80];
int total;
int sumar(int, int = 20);
void preguntar();

int main()
{
        preguntar();

        std::cout << "Hola, " << nombre << std::endl;
        std::cout << "Tu suma dio " << total << std::endl;

        return 0;
}

int sumar(int a, int b)
{
        return a + b;
}

void preguntar()
{
        int valor_1;
        std::cout << "Ingresa tu nombre: ";
        std::cin >> nombre;
        std::cout << "Ingresa un numero: ";
        std::cin >> valor_1;

        total = sumar(valor_1);
}

Las modificaciones fueron pocas y algunas un poco forzadas para ver como trabaja. La primera fue en el prototipo de sumar. Donde ahora agregamos un operador de asignacion y un valor al segundo argumento. Si vemos la definicion de la funcion esta no cambio en nada. La segunda modificacion fue en sumar, donde ahora quitamos la segunda variable local y no pedimos que le ingresen un valor y al momento de ejecutar a sumar le pasamos un solo valor. Compilemos y veamos como trabaja:

$ ./ejemplo02
Ingresa tu nombre: tinchicus
Ingresa un numero: 25
Hola, tinchicus
Tu suma dio 45
$

Primero, no nos devolvio ningun error de compilacion. Esto es asi porque si bien no pasamos ningun valor para el segundo argumento, toma como referencia al que pasamos en el prototipo. Y luego trabajo como lo viene haciendo hasta ahora. Esta modalidad de trabajo esta pensada para que ante cualquier eventualidad la funcion reciba todos los argumentos que necesite y nos evite errores de compilacion. Si bien en este codigo tan simple no nos devuelva ningun error si puede sucedernos en codigos mas complejos.

Al comienzo mencionamos que las funciones son de un determinado tipo y devuelven ese tipo, salvo el tipo void, pero esto no es tan asi porque una opcion interesante que poseemos es la de sobrecargar a las funciones (overload). Esto nos permite tener una funcion con el mismo nombre pero con distintos tipos de datos. Vamos a suponer que tenemos una funcion llamada Duplicar y necesitamos que maneje distintos tipos de datos, las funciones pueden ser de la siguiente manera:

int Duplicar(int);
long Duplicar(long);
float Duplicar(float);
double Duplicar(double); 

Esto es gracias a la firma de cada funcion donde no es establecida por el nombre de la misma sino por el tipo de datos y los argumentos que poseen. Siempre que sean distintos entre si no tendremos ningun inconveniente.

En resumen, hoy hemos visto funciones, que son, para que sirven, como se utilizan, los distintos tipos que utilizan, sus distintas posibilidades, asi como tambien a los prototipos, que por el momento no resultan muy utiles pero es solo una referencia de para que pueden servirnos. Espero les haya resultado de utilidad sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.