Funciones
Son bloques de códigos ejecutable, a los que podemos pasar parámetros y operar con ellos. Nos sirven para modular nuestros programa y estructurarlos en bloques que realicen una tarea concreta.
Las funciones nos sirven para las siguientes tareas, por ejemplo:
- Mapeos - producir uno o varios valor de salida basado al valor el cual se le introduce al inicio del proceso. Las funciones normalmente al acabar su ejecución devuelve un valor que conseguimos con el parámetro
return. - Procedimientos - funciones pueden ser llamada en secuencias de pasos.
- I/O - Algunas funciones solo existen para comunicarte con parte del sistema el cual utilizas, así como lenguaje de programación, sistema de hardware, sistema de record, etc.
Para declarar una función primero definimos el tipo de valor el cual la función devuelve al finalizar, por ejemplo si la función no devuelve ningún valor en este caso usaremos el tipo void el cual será el valor que devuelve q es nulo, luego el nombre de la función el cual usaremos para representarla en diferentes punto del codigo, aqui aplica las mismas reglas de definición de nombre que las variables, los paréntesis para enumerar dentro de ellos los parámetros que necesitamos o queremos utilizar en la función y terminamos con llaves el cual representa el cuerpo o contenido de la función, este contenido es el código que será ejecutado cada vez que llamemos o usemos la función.
#include <iostream>
using namespace std;
void hello(string name) {
cout << "Hello " << name << endl;
}
int main()
{
hello("Israel");
return 0;
}
//-> Hello Israel
Return
La instrucción return determina que valores la función devolverá al final de la ejecución de la misma función.
Parámetros o Argumentos
Las funciones utilizan valores de entrada para luego ser procesado dentro de la misma, a estos valores o variables se décimos argumentos o parámetros. Los parámetros o argumentos se comportan como unas variables regulares del mismo lenguaje de programación.
#include <iostream>
using namespace std;
void hello(string firstName, string lastName) {
cout << "Hello " << firstName << " " << lastName << endl;
}
int main()
{
hello("John", "Casper");
return 0;
}
//-> Hello John Casper
Parámetros por defecto
#include <iostream>
using namespace std;
void hello(
string firstName = "First name please",
string lastName = "Last name please") {
cout << "Hello " << firstName << " " << lastName << endl;
}
int main()
{
hello("John");
return 0;
}
//-> Hello John Last name please
Parametros por referencia
#include <iostream>
using namespace std;
void square(int a, int b) {
a = a * a;
b = b * b;
cout << "In square: a = " << a << "\tb = " << b << endl;
}
int main()
{
int x = 4;
int y = 5;
int &xRef = x;
int &yRef = y;
square(xRef, yRef);
return 0;
}
//-> In square: a = 16 b = 25
Prototipos de funciones
En situaciones el cual definimos funciones después de la función main podemos tener problemas al momento de compilación, esto sucede ya que el compilador desconoce sobre la funciones. Cuando definimos una función prototipo sin su contenido ayudamos al compilador a tener información sobre qué función estamos haciendo referencia.
#include <iostream>
#include <cstdio>
using namespace std;
void f();
int main() {
puts("This is main");
f();
return 0;
}
void f() {
puts("This is f");
}
//-> This is main
//-> This is f
Valores estáticos en funciones
Cuando una variable se declara de manera estática, el espacio para ella se asigna durante la vida útil del programa, incluso si la función se llama múltiple veces, el espacio para la variable estática se asigna solo una vez y el valor.
#include <iostream>
#include <cstdio>
using namespace std;
void f() {
static int i = 5;
cout << "i is: " << i << endl;
i = 42;
cout << "i is: " << i << endl;
}
int main() {
puts("This is main");
f();
f();
return 0;
}
//-> i is: 5
//-> i is: 42
//-> i is: 42
//-> i is: 42
Si no usamos la palabra reservada estática, cada vez que llamemos a la función, el valor de la variable iniciara al valor inicial.
#include <iostream>
#include <cstdio>
using namespace std;
void f() {
int i = 5;
cout << "i is: " << i << endl;
i = 42;
cout << "i is: " << i << endl;
}
int main() {
puts("This is main");
f();
f();
return 0;
}
//-> i is: 5
//-> i is: 42
//-> i is: 5
//-> i is: 42
Funciones punteros
Un puntero a función es una variable que almacena la dirección de una función. Esta función puede ser llamada más tarde, a través del puntero. Este tipo de construcción es útil pues encapsula comportamiento, que puede ser llamado a través de un puntero. Podemos declara una función de la siguiente forma int f() , por logica pensamos que podemos declarar un puntero función de la misma forma int *f() , pero esto genera un error en el compilador y esto sucede por precedencia de operadores el cual juega rol importante en C++. En este case los operadores ( ) tienen prioridad sobre el operador * . Para resolver este problema cambiando la precedencia de operaciones de la siguiente manera (*pointerName)(parameters) .
#include <iostream>
#include <cstdio>
using namespace std;
void f() {
cout << "This is f" << endl;
}
int main() {
void (*fptr)() = f;
fptr();
return 0;
}
//-> This is f
Es importante que los tipo de valor de retorno entre la función y el puntero sean iguales.
#include <iostream>
#include <cstdio>
using namespace std;
void add(int a, int b) {
cout << a + b << endl;
}
void mult(int a, int b) {
cout << a * b << endl;
}
int main() {
// Declare a function pointer
void (*fptr)(int, int);
// fptr -> add
fptr = &add;
fptr(12, 3);
// fptr -> mult
fptr = &mult;
fptr(5, 4);
return 0;
}
//-> 15
//-> 20
También podemos crear un arreglo de funciones punteros.
#include <iostream>
#include <cstdio>
using namespace std;
void add(int a, int b) {
cout << a + b << endl;
}
void mult(int a, int b) {
cout << a * b << endl;
}
int main() {
void (*fptr[2])(int, int);
fptr[0] = &add;
fptr[1] = &mult;
fptr[0](12, 3);
fptr[1](5, 4);
return 0;
}
//-> 15
//-> 20