Manejo de Funciones en C++

Profesor Francisco Alejandro Medina

 Que es Programación Modular ?
• La programación modular consiste en dividir un algoritmo (programa) en
unidades de menor tamaño, donde cada fragmento realiza una tarea
explícita y única.

• Cada uno de esos fragmentos recibe el nombre de subalgoritmo o

módulo. Por tanto, los subalgoritmos (sean funciones o procedimientos)
nos permiten hacer pequeñas porciones de código reutilizable, que
pueden ser llamados desde el resto del programa sin necesidad de repetir
esas partes de código cada vez que se necesiten.

• Todas las librerías de C están repletas de funciones, como por ejemplo:

pow, system, abs, etc. Por lo tanto, ya estás acostumbrado a utilizarlas, ya
que en anteriores guiones las hemos utilizado con frecuencia. Ahora sólo
nos queda ver cómo crear nuestras propias funciones.
 Sintaxis General de una Función en C+
+
TipoDato NombreFuncion (TipoDato Parametro ,
…) El ‘TipoDato’ se refiere al tipo de
dato (int, float, void, char) y en las
{ funciones que no retornan siempre
es void.
___________
El ‘nombreFuncion’ es el nombre
___________ de la función: cualquiera que
empiece con una letra, que sea
___________ significativo y que no sea una
palabra reservada.
}
 Tipos de Funciones en C++
En C++ se pueden usar 4 formas para manejar
funciones
• Sin Parametros y sin Retorno (No reciben ni
retornan)
• Sin Parametros y con Retorno (No reciben y
retornan)
• Con Parametros y sin Retorno (Reciben y no
retornan)
• Con parametros y con Retorno (Reciben y
retornan)
 Sin Parámetros y Sin Retorno (No
reciben ni retornan)
Las más sencillas. Para usarlas sólo tenemos que saber cómo crearlas y cómo
llamarlas.

Para llamarlas sólo hay que escribir el nombre de la función seguido de sus paréntesis
y un punto y coma (;).

Sintaxis para la creación: Sintaxis para el Llamado:

void NombreFuncion()
{ NombreFuncion();
-----------
-----------
-----------
}
Sin Parámetros y Sin Retorno (No
reciben ni retornan)
 Con Parámetros y Sin Retorno
(Reciben y No Retornan)
Para llamar la función hay que poner la variables que vamos a enviar dentro del
paréntesis en el mismo orden en que las declaramos en la función:
NombreFuncion (parametro1, parametro2);

Sintaxis para la creación: Sintaxis para el Llamado:

void NombreFuncion(TipoDato Parametro , … )
{ NombreFuncion (Parametro , …);
-----------
-----------
-----------
}
Con Parámetros y Sin Retorno
(Reciben y No Retornan)
 Sin Parámetros y Con Retorno
(Retornan y No Reciben)
Recibir es enviar datos del main a la función. Retornar es enviar datos de la función al
main.

Para retornar datos hay que hacer dos cosas: no usar void como tipo y usar return.

Para indicar qué variable estamos retornando usaremos la palabra return seguido de

la variable. Usualmente esto va al final de la función.

Sintaxis para la creación: Sintaxis para el Llamado:

TipoDato NombreFuncion()
{
----------- TipoDato NombreVle;
----------- NombreVble = NombreFuncion();
-----------
return (expresion)
}
Sin Parámetros y Sin Retorno
(Retornan y No Reciben)
 Con Parámetros y Con
Retorno(Reciben y Retornan)
Las funciones de la librería math.h son en su mayoría de este tipo. sqrt(); pow(); sin();

Sintaxis para la creación: Sintaxis para el Llamado:

TipoDato NombreFuncion(TipoDato Parametro , … )
{
----------- TipoDato NombreVble;
----------- NombreVble = NombreFuncion(parametro , … );
-----------
return (expresion)
}
 Con Parámetros y Con
Retorno(Reciben y Retornan)