Facultad de Ciencias e Ingeniería
Escuela de Informática
FUNCIONES EN C++
Presentado por:
Sairelys Arletteh Alcantara Luciano | A00115382
Asignatura:
ISO-200 | PROGRAMACIÓN Y ESTRUCTURAS DE DATOS
Maestro:
Ing. Alexis Morillo
Fecha de entrega:
27 de Junio de 2024
2
Índice
Definición y Estructura ................................................................................................................... 4
Elementos de una declaración de función ....................................................................................... 5
Definiciones de función .................................................................................................................. 5
Parámetros de función y argumentos .............................................................................................. 6
Parámetros por valor y por referencia ............................................................................................. 7
Consejos para usar funciones de forma efectiva ............................................................................. 8
Tipos de Funciones ......................................................................................................................... 8
Funciones sin retorno: .......................................................................................................... 8
Funciones con retorno: ......................................................................................................... 8
Funciones void: .................................................................................................................... 8
Funciones con parámetros: .................................................................................................. 8
Funciones recursivas: ........................................................................................................... 8
Funciones sin retorno ...................................................................................................................... 8
Funciones con retorno ................................................................................................................... 10
Tipos de retorno ............................................................................................................................ 12
Consideraciones ............................................................................................................................ 13
Funciones void .............................................................................................................................. 13
Características de las funciones void ............................................................................................ 14
Consideraciones ............................................................................................................................ 14
Tipos de Parámetros ...................................................................................................................... 15
Consideraciones ............................................................................................................................ 18
Características de las funciones recursivas ................................................................................... 19
Estructura de una función recursiva .............................................................................................. 19
Ejemplo básico: Factorial ............................................................................................................. 19
Conclusión .................................................................................................................................... 20
Referencias Bibliográficas ............................................................................................................ 21
3
Introducción
En el mundo de la programación, las funciones son elementos esenciales que permiten
organizar y estructurar el código de manera eficiente. En el lenguaje C++, las funciones juegan un
papel fundamental, brindando modularidad, reutilización y legibilidad al programa. Este ensayo
se adentrará en el concepto de las funciones en C++, explorando sus características, tipos y
aplicaciones, para comprender su importancia en el desarrollo de software robusto y escalable.
Las funciones en C++ son una herramienta fundamental para escribir código modular,
eficiente y fácil de entender. Al comprender su funcionamiento y las mejores prácticas para su uso,
podrás aprovechar al máximo esta herramienta fundamental para escribir código C++ robusto y
efectivo.
En la programación en C++, las funciones son bloques de código reutilizables que realizan
tareas específicas. Estas son fundamentales para estructurar y organizar el código, permitiendo su
reutilización, mantenimiento y legibilidad. Las funciones pueden recibir datos de entrada
conocidos como parámetros y pueden devolver un valor como resultado. Existen varias categorías
de funciones en C++, cada una con sus propias características y usos.
4
Definición y Estructura
Una función en C++ se define como un bloque de código reutilizable que realiza una tarea
específica. Se caracteriza por tener un nombre único, un conjunto de parámetros opcionales y un
cuerpo que contiene las instrucciones a ejecutar. La estructura básica de una función en C++ se
compone de los siguientes elementos:
Figura 1.1
Una función es un bloque de código que realiza alguna operación. Una función puede
definir opcionalmente parámetros de entrada que permiten a los llamadores pasar argumentos a la
función. Una función también puede devolver un valor como salida. Las funciones son útiles para
encapsular las operaciones comunes en un solo bloque reutilizable, idealmente con un nombre que
describa claramente lo que hace la función. La siguiente función acepta dos enteros de un autor de
llamada y devuelve su suma; a y b son parámetros de tipoint.
Figura 1.2
La función puede ser invocada, o llamada, desde cualquier lugar del programa. Los valores
que se pasan a la función son los argumentos, cuyos tipos deben ser compatibles con los tipos de
los parámetros en la definición de la función.
Figura 1.3
5
No hay ningún límite práctico para la longitud de la función, pero el buen diseño tiene
como objetivo las funciones que realizan una sola tarea bien definida. Los algoritmos complejos
deben dividirse en funciones más sencillas y fáciles de comprender siempre que sea posible.
Las funciones definidas en el ámbito de clase se denominan funciones miembro. En C++,
a diferencia de otros lenguajes, una función también pueden definirse en el ámbito de espacio de
nombres (incluido el espacio de nombres global implícito). Estas funciones se denominan
funciones gratuitas o funciones que no son miembro; se usan ampliamente en la biblioteca
estándar.
Las funciones pueden ser sobrecargadas, lo que significa que diferentes versiones de una
función pueden compartir el mismo nombre si difieren por el número y/o tipo de parámetros
formales.
Elementos de una declaración de función
Los elementos necesarios de una declaración de función son los siguientes:
El tipo de retorno, que especifica el tipo del valor que devuelve la función, o void
si no se devuelve ningún valor. En C++11, auto es un tipo de retorno válido que indica
al compilador que infiera el tipo de la sentencia de retorno. En C++14, decltype(auto)
también está permitido. Para obtener más información, consulte más adelante
Deducción de tipos en tipos de valor devueltos.
El nombre de la función, que debe comenzar con una letra o un carácter de
subrayado y no puede contener espacios. En general, los caracteres de subrayado
iniciales en los nombres de función de biblioteca estándar indican funciones miembro
privadas o funciones que no son miembro que no están diseñadas para su uso por el
código.
La lista de parámetros, que es un conjunto delimitado por llaves y separado por
comas de cero o más parámetros que especifican el tipo y, opcionalmente, un nombre
local mediante el cual se puede acceder a los valores de dentro del cuerpo de la función.
Definiciones de función
Una definición de función consiste en la declaración y el cuerpo de la función, encerrado
entre llaves, que contiene declaraciones de variables, sentencias y expresiones. El siguiente
ejemplo muestra una definición de función completa:
6
Las variables declaradas dentro del cuerpo se denominan variables locales. Se salen del
ámbito cuando finaliza la función; por lo tanto, una función nunca debe devolver una referencia a
una variable local.
Figura 3.1
Parámetros de función y argumentos
Una función tiene una lista de parámetros separados por comas de cero o más tipos, cada
uno de los cuales tiene un nombre mediante el cual se puede acceder a ellos dentro del cuerpo de
la función. Una plantilla de función puede especificar más parámetros de tipo o valor. El llamador
pasa argumentos, que son valores concretos cuyos tipos son compatibles con la lista de parámetros.
De forma predeterminada, los argumentos se pasan a la función por valor, lo que significa
que la función recibe una copia del objeto que se pasa. En el caso de objetos grandes, la realización
de una copia puede ser costosa y no siempre es necesaria. Para hacer que los argumentos se pasen
por referencia (concretamente por referencia lvalue), agregue un calificador de referencia al
parámetro:
Figura 4.1
Una función declarada con la palabra clave única void en la lista de declaración de
parámetros no toma argumentos, siempre que la palabra clave void sea el primer y único miembro
de la lista de declaración de argumentos. Los argumentos del tipo void en otra parte de la lista
producen errores.
Figura 4.2
7
Parámetros por valor y por referencia
Los parámetros de las funciones se pueden pasar por valor o por referencia.
Parámetros por valor: Se crea una copia del valor del argumento al pasar la función.
Cualquier cambio realizado en la copia dentro de la función no afecta al valor original del
argumento.
Parámetros por referencia: Se pasa la dirección de memoria del argumento a la función.
Cualquier cambio realizado en el argumento dentro de la función afecta al valor original del
argumento.
Ejemplo:
Figura 5.1
8
Consejos para usar funciones de forma efectiva
Divide tu programa en funciones: Esto te ayudará a escribir código modular y fácil
de entender.
Utiliza nombres descriptivos para las funciones: Esto te ayudará a recordar qué
hace cada función.
Documenta tus funciones: Escribir comentarios claros y descriptivos te ayudará a
comprender mejor tu código en el futuro.
Utiliza las funciones de la biblioteca estándar: La biblioteca estándar de C++
proporciona una gran variedad de funciones que puedes usar en tu código.
Tipos de Funciones
C++ ofrece diversos tipos de funciones que se clasifican según su funcionalidad y
características:
Funciones sin retorno: Estas funciones no devuelven ningún valor, pero pueden
modificar variables externas.
Funciones con retorno: Estas funciones devuelven un valor de un tipo de dato
específico, que puede ser utilizado por la parte del programa que la llama.
Funciones void: Son funciones sin retorno y sin parámetros.
Funciones con parámetros: Reciben valores como argumentos, que se utilizan
dentro de la función para realizar su tarea.
Funciones recursivas: Se llaman a sí mismas, lo que permite realizar tareas
repetitivas de manera eficiente.
Funciones sin retorno
Vamos a ver un ejemplo práctico de una función, pero primero recordad que hay que
declararla antes del "main"; y luego podrá ser llamada cuando se necesite desde el "main".
Veamos como se construye la función:
En este caso hay un ejemplo una muy facilito, una función que simplemente suma dos
números recibidos por parámetro y muestra el resultado de la suma por pantalla:
Figura 7.1.1
9
La cabecera de la función es la siguiente, recordad:
<tipo_de_dato_a_devolver> <nombre_funcion> (<parametros>)
En este caso, la función no devolverá nada, por eso escribo "void". Luego el nombre de la
función, en este caso le puse Suma, y entre paréntesis las variables que recibe (las que necesitará
la función). Son dos números tipo "int", o sea, que esta función solo nos valdría para sumar dos
números enteros. Si quisiéramos sumar dos números decimales no nos valdría... en esto C es muy
estricto.
Bien, una vez llamada la función y dados los valores n1 y n2 (estas variables ya vendrán
con valores dados por el programador o por el usuario), lo que hacemos es crear una variable
"resultado", asignamos el resultado de la suma a esta variable y luego la mostramos por pantalla,
simplemente.
Eso en cuanto a la función, ahora bien, si no hacemos una llamada a dicha función, la
función no servirá de nada.
El código completo del programa es el siguiente:
Figura 7.1.2
10
Como ya sabéis el código del main es el que se ejecuta primero nada más ejecutar el
programa. Creamos las variables num1 y num2, y le damos los valores que queramos, en este caso
el 3 y el 7, y luego llamamos a la función:
<nombre_funcion_a_llamar> (<parametros_de_dicha_funcion)
A la hora de llamar a la función solo tenemos que poner el nombre de la función y los
parámetros que queramos pasarle. Fijaos que aquí en la llamada no hace falta poner el valor de
retorno, ni indicar el tipo de las variables de los parámetros.
Las variables "num1" y "num2" no son las mismas variables que n1 y n2 (variables de la
función Suma), estas últimas solo se pueden utilizar en el ámbito de la función, es decir, que solo
podemos trabajar con ellas dentro de la función Suma, no se pueden utilizar en el main ni en ningún
otro sitio. Lo que hace el programa es asignar a estas variables los valores de "num1" y "num2" al
hacer la llamada.
Por supuesto, a la función se le podrían pasar directamente los valores sin necesidad de ser
variables, por ejemplo:
Suma (4, 7);
Esto nos mostraría por pantalla un 11.
Funciones con retorno
Para definir una función con retorno, se especifica el tipo de retorno antes del nombre de
la función y la lista de parámetros (si los hay) entre paréntesis.
Ejemplo:
Figura 7.2.1
11
En este ejemplo, la función sumar devuelve un entero que es la suma de dos parámetros
enteros.
Características de las funciones con retorno
Tipo de retorno: El tipo de retorno puede ser cualquier tipo de dato válido en C++,
incluyendo tipos primitivos (como int, float, char), tipos definidos por el usuario (como
estructuras y clases), punteros, y referencias.
Palabra clave return: Para devolver un valor desde una función, se utiliza la palabra clave
return seguida del valor que se desea devolver. El valor debe coincidir con el tipo de retorno
especificado.
Figura 7.2.2
Funciones con múltiples return: Una función puede tener múltiples sentencias return,
aunque solo se ejecutará una de ellas, dependiendo de la lógica del programa.
Figura 7.2.3
Funciones inline: Las funciones que son pequeñas y se llaman frecuentemente pueden ser
declaradas como inline para sugerir al compilador que expanda la función en línea en lugar de
hacer una llamada de función.
Figura 7.2.4
12
Tipos de retorno
Tipos primitivos: Como int, float, double, char, bool, etc.
bool esPar(int numero) {
return (numero % 2 == 0);
}
Punteros: Las funciones pueden devolver punteros a variables.
int* obtenerMayor(int* a, int* b) {
if (*a > *b) {
return a;
} else {
return b;
}
}
Referencias: Las funciones pueden devolver referencias a variables.
int& obtenerMayor(int& a, int& b) {
if (a > b) {
return a;
} else {
return b;
}
}
Objetos: Las funciones pueden devolver objetos.
class Punto {
public:
int x, y;
Punto(int x = 0, int y = 0) : x(x), y(y) {}
};
Punto crearPunto(int x, int y) {
return Punto(x, y);
}
13
Consideraciones
Manejo de memoria: Al devolver punteros o referencias a variables dinámicamente
asignadas, es importante gestionar correctamente la memoria para evitar fugas de memoria.
Eficiencia: Para tipos de datos grandes, como objetos complejos, puede ser más eficiente
devolver referencias o punteros en lugar de valores, para evitar copias costosas.
Const-correctness: Si una función no debe modificar el objeto al que una referencia o
puntero apunta, se debe declarar como const para asegurar la inmutabilidad.
const Punto& obtenerConstPunto(const Punto& p) {
return p;
}
Las funciones con retorno son esenciales para estructurar programas en C++ de manera
modular y eficiente, permitiendo que los datos fluyan entre diferentes partes del programa y
facilitando la reutilización de código.
Funciones void
Las funciones void en C++ son funciones que no devuelven ningún valor. Son esenciales
cuando se desea realizar operaciones específicas sin necesidad de devolver un resultado. Estas
funciones se utilizan ampliamente para tareas como modificar variables, imprimir mensajes,
ejecutar procedimientos, y manejar eventos. A continuación, se detalla todo lo relacionado con las
funciones void.
Definición y Declaración
Para definir una función void, se especifica void como tipo de retorno seguido del nombre
de la función y la lista de parámetros (si los hay) entre paréntesis.
Ejemplo:
Figura 9.1.1
14
Características de las funciones void
No devuelven valor: Las funciones void no pueden utilizar la palabra clave return para
devolver un valor. Sin embargo, se puede usar return sin un valor para terminar prematuramente
la ejecución de la función.
Pueden tener parámetros: Las funciones void pueden tomar cualquier número de
parámetros de cualquier tipo.
Pueden ser sobrecargadas: Al igual que otras funciones, las funciones void pueden ser
sobrecargadas, es decir, puede haber múltiples funciones con el mismo nombre pero con diferentes
listas de parámetros.
Usos comunes
Procedimientos: Realizar una serie de acciones sin necesidad de devolver información,
como en el caso de imprimir algo en la pantalla o modificar una variable global.
Funciones de evento: En la programación basada en eventos, como los controladores de
eventos en interfaces gráficas, las funciones void son comunes ya que manejan eventos pero no
necesitan devolver valores.
Operaciones de entrada/salida: Manejo de archivos, lectura de entrada del usuario, y otras
operaciones de E/S frecuentemente utilizan funciones void.
Consideraciones
Eficiencia: Las funciones void pueden ser muy eficientes ya que no hay necesidad de
gestionar el valor de retorno.
Claridad del código: Utilizar funciones void puede hacer que el código sea más claro y
legible al separar claramente las operaciones que realizan tareas de las que devuelven resultados.
Encapsulación: Las funciones void pueden ayudar a encapsular la lógica de negocio o las
operaciones complejas en funciones bien definidas, mejorando la organización del código.
En resumen, las funciones void en C++ son una herramienta esencial cuando se necesita
ejecutar operaciones que no requieren devolver un valor, permitiendo una estructura de código
clara y organizada.
Las funciones con parámetros en C++ son aquellas que reciben uno o más argumentos al
ser llamadas. Estos argumentos se utilizan dentro de la función para realizar operaciones o cálculos
específicos. Los parámetros permiten que las funciones sean más flexibles y reutilizables, ya que
pueden trabajar con diferentes datos cada vez que se llaman.
Definición y Declaración
Para definir una función con parámetros, se especifican los tipos y nombres de los
parámetros en la lista de parámetros de la función, que se encuentra entre paréntesis después del
nombre de la función.
15
Ejemplo:
Figura 10.1.1
Tipos de Parámetros
Parámetros por valor: Los parámetros por valor se copian en la función. Las
modificaciones a estos parámetros dentro de la función no afectan a los argumentos originales.
void duplicar(int n) {
n = n * 2; // Solo se duplica la copia local
}
int main() {
int numero = 5;
duplicar(numero);
std::cout << "Numero: " << numero << std::endl; // numero sigue siendo 5
return 0;
}
Parámetros por referencia: Los parámetros por referencia permiten que la función
modifique los argumentos originales. Se indican con el operador &.
void duplicar(int& n) {
n = n * 2; // Se duplica el valor original
}
16
int main() {
int numero = 5;
duplicar(numero);
std::cout << "Numero: " << numero << std::endl; // numero es ahora 10
return 0;
}
Parámetros constantes por referencia: Si una función debe aceptar un parámetro por
referencia pero no debe modificarlo, se puede usar const.
void imprimir(const std::string& mensaje) {
std::cout << mensaje << std::endl; // No se puede modificar mensaje
}
int main() {
std::string saludo = "Hola, Mundo!";
imprimir(saludo);
return 0;
}
Parámetros por puntero: Los parámetros por puntero permiten que la función modifique
los valores apuntados. Se usan punteros (*) en lugar de referencias.
void duplicar(int* n) {
*n = *n * 2; // Se duplica el valor original al que apunta n
}
int main() {
int numero = 5;
duplicar(&numero);
std::cout << "Numero: " << numero << std::endl; // numero es ahora 10
return 0;
}
Parámetros Predeterminados
Las funciones pueden tener parámetros predeterminados, lo que permite omitir algunos
argumentos al llamar a la función. Los valores predeterminados se especifican en la declaración
de la función.
#include <iostream>
void saludar(std::string nombre = "Mundo") {
std::cout << "Hola, " << nombre << "!" << std::endl;
}
int main() {
saludar(); // Salida: Hola, Mundo!
saludar("Carlos"); // Salida: Hola, Carlos!
17
return 0;
}
C++ permite la sobrecarga de funciones, lo que significa que se pueden definir varias
funciones con el mismo nombre pero diferentes listas de parámetros.
#include <iostream>
void imprimir(int n) {
std::cout << "Entero: " << n << std::endl;
}
void imprimir(double d) {
std::cout << "Doble: " << d << std::endl;
}
void imprimir(const std::string& mensaje) {
std::cout << "Mensaje: " << mensaje << std::endl;
}
int main() {
imprimir(10);
imprimir(3.14);
imprimir("Hola!");
return 0;
}
Ejemplos adicionales
Función que suma elementos de un array
int sumarElementos(const int arr[], int tamaño) {
int suma = 0;
for (int i = 0; i < tamaño; ++i) {
suma += arr[i];
}
return suma;
}
int main() {
int numeros[] = {1, 2, 3, 4, 5};
int tamaño = sizeof(numeros) / sizeof(numeros[0]);
int suma = sumarElementos(numeros, tamaño);
std::cout << "La suma de los elementos es: " << suma << std::endl;
return 0;
}
18
Función que encuentra el valor máximo en un vector
#include <vector>
int encontrarMaximo(const std::vector<int>& vec) {
int maximo = vec[0];
for (int valor : vec) {
if (valor > maximo) {
maximo = valor;
}
}
return maximo;
}
int main() {
std::vector<int> valores = {3, 1, 4, 1, 5, 9, 2};
int maximo = encontrarMaximo(valores);
std::cout << "El valor máximo es: " << maximo << std::endl;
return 0;
}
Función que concatena dos cadenas
std::string concatenar(const std::string& s1, const std::string& s2) {
return s1 + s2;
}
int main() {
std::string cadena1 = "Hola, ";
std::string cadena2 = "Mundo!";
std::string resultado = concatenar(cadena1, cadena2);
std::cout << "Cadena concatenada: " << resultado << std::endl;
return 0;
}
Consideraciones
Paso por valor vs. paso por referencia: Elegir entre pasar parámetros por valor, referencia
o puntero depende de si se necesita modificar el valor original y del costo de copiar datos.
Uso de const: Utilizar const para parámetros de referencia que no deben ser modificados
puede mejorar la claridad y seguridad del código.
Valores predeterminados: Los valores predeterminados pueden simplificar las llamadas
a funciones y proporcionar flexibilidad adicional.
Las funciones con parámetros son fundamentales en C++ para crear código modular y
reutilizable, permitiendo que las funciones operen sobre diferentes datos sin necesidad de duplicar
el código.
19
Características de las funciones recursivas
Caso base: Es crucial definir claramente el caso base para evitar la recursión infinita. El
caso base debe ser sencillo y directo.
División del problema: En el caso recursivo, el problema se divide en subproblemas más
pequeños que eventualmente conducen al caso base.
Uso de la pila: Cada llamada recursiva se almacena en la pila de llamadas. Esto puede
llevar a un desbordamiento de pila si la recursión es demasiado profunda.
Las funciones recursivas son aquellas que se llaman a sí mismas directa o indirectamente.
La recursión es una técnica poderosa y a menudo se utiliza para resolver problemas que pueden
dividirse en subproblemas más pequeños del mismo tipo. Sin embargo, es importante usarlas con
cuidado para evitar problemas como la recursión infinita y el desbordamiento de pila (stack
overflow).
Estructura de una función recursiva
Una función recursiva en C++ debe tener al menos dos componentes principales:
Caso base: La condición que detiene la recursión. Sin un caso base, la función se llamaría
a sí misma indefinidamente.
Caso recursivo: La parte de la función donde se hace la llamada recursiva. Generalmente,
se divide el problema en partes más pequeñas y se resuelve cada parte recursivamente.
Ejemplo básico: Factorial
El factorial de un número n (denotado como n!) se define como el producto de todos los
enteros positivos desde 1 hasta n. El factorial de 0 se define como:
Figura 11.3.1
20
Conclusión
Las funciones son un componente esencial de la programación en C++, proporcionando
modularidad, reutilización de código y claridad. Las funciones void permiten realizar acciones sin
necesidad de devolver un valor, mientras que las funciones con retorno permiten el flujo de datos
a través de un programa. Las funciones con parámetros aportan flexibilidad y generalidad,
permitiendo que una sola función opere con diferentes datos. Finalmente, las funciones recursivas
ofrecen una manera elegante y potente de resolver problemas que pueden descomponerse en
subproblemas similares.
Comprender y utilizar adecuadamente las diferentes categorías de funciones es crucial para
escribir código eficiente, claro y mantenible en C++. Cada tipo de función tiene su lugar y
propósito, y el dominio de estas herramientas permite a los programadores abordar una amplia
variedad de problemas de manera efectiva y elegante.
Las funciones en C++ son herramientas indispensables para la creación de software de alta
calidad. Su capacidad para modularizar, reutilizar y encapsular el código las convierte en
elementos fundamentales para el desarrollo de programas eficientes, legibles y mantenibles.
Dominar el concepto de las funciones y sus diferentes tipos es esencial para cualquier programador
que desee crear aplicaciones robustas y escalables en C++.
21
Referencias Bibliográficas
Chichon, D. P. (2015, 25 febrero). Funciones sin retorno - Lenguaje de
programación C. https://www.aulafacil.com/cursos/programacion/lenguaje-de-
programacion-c/funciones-sin-retorno-l16901
GeeksforGeeks. (2023, 23 septiembre). C data types. GeeksforGeeks.
https://www.geeksforgeeks.org/cpp-data-types/
Microsoft Copilot in Bing. (s. f.).
https://www.bing.com/search?q=funciones+sin+retorno+en+c%2B%2B&qs=n&form
=QBRE&=Buscar+%7B1%7D+en+%7B0%7D&=Buscar+trabajo+para+%7B0%7D
&=%25eAdministra+tu+historial+de+b%C3%BAsqueda%25E&sp=-
1&lq=0&pq=funciones+sin+retorno+en+c%2B%2B&sc=0-
28&sk=&cvid=4E4463FCA18F4A5BAE351045A4ADCF35&ghsh=0&ghacc=0&gh
pl=&ntref=1&showconv=1
Nivardo. (2024, 11 abril). Funciones en C++. Oregoom.com.
https://oregoom.com/cpp/funciones/
Recursión en C++. (2023, 17 diciembre). Ethical Hack - Blog.
https://ehack.info/recursion-en-c/
SoloCodigo. (s. f.). https://solocodigo.com/
TylerMSFT. (2023, 3 abril). Funciones (C++). Microsoft Learn.
https://learn.microsoft.com/es-es/cpp/cpp/functions-cpp?view=msvc-170
