UNEXCA
UNIVERSIDAD NACIONAL EXPERIMENTAL
DE LA GRAN CARACAS
DOCENTE: JOHANA PARRA
ALUMNO: SAMIL CARABALLO
CARACAS 24/11/26
Introducción
C++ es un lenguaje de programación de propósito general que extiende
el lenguaje C con características de programación orientada a objetos.
Las funciones son elementos fundamentales en C++, permitiendo
organizar el código en bloques reutilizables y modulares.
1. Concepto de Función
Una función en C++ es un bloque de código que realiza una tarea
específica y puede ser invocado desde diferentes partes del programa.
Las funciones facilitan:
· Reutilización de código
· Modularidad
· Mantenibilidad
· Legibilidad
2. Estructura de una Función
```cpp
tipo_retorno nombre_funcion(parámetros) {
// Cuerpo de la función
return valor; // (opcional)
```
Ejemplo Básico:
```cpp
#include <iostream>
using namespace std;
// Declaración de la función
int suma(int a, int b);
// Definición de la función
int suma(int a, int b) {
return a + b;
int main() {
int resultado = suma(5, 3);
cout << "La suma es: " << resultado << endl;
return 0;
```
3. Tipos de Funciones
3.1 Funciones con Retorno de Valor
```cpp
double calcularAreaCirculo(double radio) {
return 3.14159 * radio * radio;
```
3.2 Funciones sin Retorno (void)
```cpp
void mostrarMensaje(string mensaje) {
cout << "Mensaje: " << mensaje << endl;
```
3.3 Funciones con Parámetros por Valor
```cpp
int duplicar(int numero) {
return numero * 2;
```
3.4 Funciones con Parámetros por Referencia
```cpp
void intercambiar(int &a, int &b) {
int temp = a;
a = b;
b = temp;
```
3.5 Funciones con Parámetros por Puntero
```cpp
void incrementar(int *ptr) {
(*ptr)++;
```
4. Sobrecarga de Funciones
C++ permite definir múltiples funciones con el mismo nombre pero
diferentes parámetros:
```cpp
#include <iostream>
using namespace std;
// Sobrecarga de funciones
int multiplicar(int a, int b) {
return a * b;
}
double multiplicar(double a, double b) {
return a * b;
int multiplicar(int a, int b, int c) {
return a * b * c;
int main() {
cout << multiplicar(2, 3) << endl; // 6
cout << multiplicar(2.5, 3.5) << endl; // 8.75
cout << multiplicar(2, 3, 4) << endl; // 24
return 0;
```
5. Parámetros por Defecto
```cpp
#include <iostream>
using namespace std;
void mostrarInfo(string nombre, int edad = 18, string ciudad =
"Desconocida") {
cout << "Nombre: " << nombre << endl;
cout << "Edad: " << edad << endl;
cout << "Ciudad: " << ciudad << endl;
}
int main() {
mostrarInfo("Ana"); // Usa valores por defecto
mostrarInfo("Juan", 25); // Ciudad por defecto
mostrarInfo("Maria", 30, "Madrid"); // Todos los parámetros
return 0;
```
6. Funciones Recursivas
```cpp
#include <iostream>
using namespace std;
// Función recursiva para calcular factorial
long factorial(int n) {
if (n <= 1) {
return 1;
return n * factorial(n - 1);
// Función recursiva para Fibonacci
int fibonacci(int n) {
if (n <= 1) {
return n;
return fibonacci(n - 1) + fibonacci(n - 2);
int main() {
cout << "Factorial de 5: " << factorial(5) << endl;
cout << "Fibonacci posición 6: " << fibonacci(6) << endl;
return 0;
```
7. Funciones Inline
```cpp
#include <iostream>
using namespace std;
// Función inline para optimización
inline int cuadrado(int x) {
return x * x;
int main() {
cout << "Cuadrado de 5: " << cuadrado(5) << endl;
return 0;
}
```
8. Plantillas de Funciones (Templates)
```cpp
#include <iostream>
using namespace std;
// Plantilla de función
template <typename T>
T maximo(T a, T b) {
return (a > b) ? a : b;
// Plantilla con múltiples tipos
template <typename T1, typename T2>
void mostrarPar(T1 primero, T2 segundo) {
cout << "Par: " << primero << ", " << segundo << endl;
int main() {
cout << "Máximo entre 3 y 7: " << maximo(3, 7) << endl;
cout << "Máximo entre 3.14 y 2.71: " << maximo(3.14, 2.71) <<
endl;
mostrarPar(25, "años");
mostrarPar(3.14, "pi");
return 0;
```
9. Funciones Lambda (C++11 y posteriores)
```cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
vector<int> numeros = {5, 2, 8, 1, 9};
// Función lambda para ordenar descendente
sort([Link](), [Link](), [](int a, int b) {
return a > b;
});
// Función lambda para mostrar elementos
for_each([Link](), [Link](), [](int n) {
cout << n << " ";
});
cout << endl;
// Lambda con captura de variables
int factor = 2;
auto multiplicar = [factor](int x) -> int {
return x * factor;
};
cout << "5 * 2 = " << multiplicar(5) << endl;
return 0;
```
10. Ejemplo Completo: Calculadora
```cpp
#include <iostream>
#include <cmath>
using namespace std;
// Prototipos de funciones
double sumar(double a, double b);
double restar(double a, double b);
double multiplicar(double a, double b);
double dividir(double a, double b);
double potencia(double base, double exponente);
void mostrarMenu();
// Implementación de funciones
double sumar(double a, double b) {
return a + b;
double restar(double a, double b) {
return a - b;
double multiplicar(double a, double b) {
return a * b;
double dividir(double a, double b) {
if (b != 0) {
return a / b;
} else {
cout << "Error: División por cero" << endl;
return 0;
double potencia(double base, double exponente) {
return pow(base, exponente);
void mostrarMenu() {
cout << "\n=== CALCULADORA ===" << endl;
cout << "1. Sumar" << endl;
cout << "2. Restar" << endl;
cout << "3. Multiplicar" << endl;
cout << "4. Dividir" << endl;
cout << "5. Potencia" << endl;
cout << "6. Salir" << endl;
cout << "Seleccione una opción: ";
int main() {
int opcion;
double num1, num2;
do {
mostrarMenu();
cin >> opcion;
if (opcion >= 1 && opcion <= 5) {
cout << "Ingrese primer número: ";
cin >> num1;
cout << "Ingrese segundo número: ";
cin >> num2;
switch (opcion) {
case 1:
cout << "Resultado: " << sumar(num1, num2) << endl;
break;
case 2:
cout << "Resultado: " << restar(num1, num2) << endl;
break;
case 3:
cout << "Resultado: " << multiplicar(num1, num2) << endl;
break;
case 4:
cout << "Resultado: " << dividir(num1, num2) << endl;
break;
case 5:
cout << "Resultado: " << potencia(num1, num2) << endl;
break;
case 6:
cout << "Saliendo..." << endl;
break;
default:
cout << "Opción inválida" << endl;
} while (opcion != 6);
return 0;
```
11. Buenas Prácticas con Funciones
11.1 Nombres Descriptivos
```cpp
// ❌ Mal
void f(int x, int y) { ... }
// ✅ Bien
void calcularAreaRectangulo(int base, int altura) { ... }
```
11.2 Funciones Cortas y Específicas
```cpp
// ❌ Mal - función que hace demasiado
void procesarUsuario() {
// Validar datos
// Calcular impuestos
// Generar reporte
// Enviar email
// ✅ Bien - funciones específicas
bool validarDatosUsuario(Usuario user) { ... }
double calcularImpuestos(Usuario user) { ... }
void generarReporte(Usuario user) { ... }
void enviarEmailConfirmacion(Usuario user) { ... }
```
11.3 Documentación Adecuada
```cpp
/**
* Calcula el área de un círculo
* @param radio El radio del círculo
* @return El área calculada
* @pre radio debe ser mayor que 0
*/
double calcularAreaCirculo(double radio) {
if (radio <= 0) {
throw invalid_argument("El radio debe ser positivo");
return 3.14159 * radio * radio;
```
Conclusión
Las funciones son pilares fundamentales en la programación en C++. Su
correcto uso permite crear código más organizado, mantenible y
eficiente. Desde funciones simples hasta plantillas y lambdas, C++
ofrece un amplio espectro de herramientas para la implementación de
funcionalidades modulares. La elección del tipo de función y parámetros
adecuados depende del contexto específico y los requerimientos de
rendimiento del programa.
Bibliografía Recomendada
1. Stroustrup, B. - "The C++ Programming Language"
2. Lippman, S. B. - "C++ Primer
3. Meyers, S. - "Effective C++"