Lenguajes de

Programación

Laboratorio N° 7

Métodos que no retornan

valor

Integrante:

Sección: 2

Profesor:

Fecha de Realización:

Fecha de Entrega:

Mecatrónica Industrial
 Lab. N°7 Métodos que no
retornan valor
Fundamento teórico:

Los métodos con valor de retorno son módulos de programa que pueden recibir datos de
entrada por medio de variables locales (parámetros) y posteriormente retorna un resultado al
punto donde es llamado. Este tipo de métodos se utiliza para operar cualquier tipo de
proceso que produzca un resultado.

Los métodos con valor de retorno se clasifican en dos tipos:

 Métodos con valor de retorno sin parámetros.

 Métodos con valor de retorno con parámetros.

.
Métodos con valor de retorno sin parámetros :

Este tipo de métodos no reciben datos de entrada; pero de igual forma retornan un resultado
al punto donde son llamados.

Su definición es de la siguiente manera:

tipo nombreMetodo(){
Declaracion de variables locales
Cuerpo del método
return valor;
}
Donde:
 Valor: Es el valor que es retornado por el método.

 Tipo: Es el tipo del valor de retorno.

Invocación (llamado):

variable = nombreMetodo();

Donde:

 Variable: Es la variable que recibe el valor retornado por el método.

Métodos con valor de retorno con parámetros:

Este tipo de métodos reciben datos de entrada por medio de parámetros y retornan un
resultado al punto de su llamado.

Pág.
2
 Lab. N°7 Métodos que no
retornan valor
ESCRITURA DE UNA FUNCIÓN

Una función es una sección de código de C que tiene un nombre, independiente, que
ejecuta una tarea específica y que opcionalmente regresa un valor al programa que
la llama.
 Una función tiene nombre
 Una función ejecuta una tarea específica
 Una función puede regresar un valor al programa que la llama

Prototipo de función:

tipo_retorno nombre_función (tipo_argunmento nombre1, tipo_argumento nombre2,…)

Un prototipo de función proporciona al compilador la descripción de una función. El
prototipo incluye un tipo de retorno, que indica el tipo de variable que regresará la
función. También incluye el nombre de la función, que deberá describir lo que hace la
función. El prototipo también contiene el tipo de las variables de los argumentos que
serán pasadas a la función. Opcionalmente puede contener los nombres de las
variables que serán pasadas. Un prototipo siempre termina en punto y coma.
Ejemplo:

int sumar_dos_valores (int a, int b);

float dividir_dos_valore (int a, int b);

Definición de función:
Contiene el código que será ejecutado. La primera línea de la definición de función,
llamado el encabezado de función, debe ser idéntico al prototipo de función, a
excepción del punto y coma. Un encabezado de función no debe terminar con un punto
y coma.
Ejemplo:

Int sumar_dos_valores (int a, int b)

{
return (a+b);
}

Tipo de retorno de una función:

El tipo de retorno de la función específica el tipo de dato que regresa la función al

programa que la llama. Algunas funciones no usan argumentos, y en esos casos la
lista de parámetros debe decir void.

int funcion1(…) /* regresa un tipo int. */

Pág.
3
 Lab. N°7 Métodos que no
float funcion2(…) /* regresa unretornan
tipo float.
valor */
void funcion3(…) /* no regresa nada.*/

Pág.
4
 Lab. N°7 Métodos que no
retornan valor
Ejemplos:

int sumatoria (int x, int y, int z,…)

/* Regresa un tipo entero */

void ejecutar (int x, float y, char z, …)

/* No regresa nada pero acepta argumentos*/

void operar (void)

/* No regresa nada y no acepta argumentos */

Pág.
5
 Lab. N°7 Métodos que no
retornan valor
Procedimiento

1. Copiar el programa de abajo, comentar y compilar. Luego analizar los que sucede.

/* Programa para la demostracion de funciones sin retorno de valor */

#include <stdio.h>
//*******************************************
// Declaracion de funciones
void sumar(void);
void restar(void);
void multiplicar(void);
void dividir(void);
//*******************************************
//Programacion principal
main()
{
sumar();
restar();
multiplicar();
dividir();

system("PAUSE");
return 0;
}
//*******************************************
//Funciones
void sumar(void)
{
float x,num1,num2;
puts("Ingresa dos valores para ser sumados:");
scanf("%f %f",&num1,&num2);
x = num1+num2;
printf("El valor de la suma es:%f\n\n",x);
}
void restar(void)
{
float x,num1,num2;
puts("Ingresa dos valores para ser restados:");
scanf("%f %f",&num1,&num2);
x = num1-num2;
printf("El valor de la resta es:%f\n\n",x);
}
void dividir(void)
{
float x,num1,num2;
puts("Ingresa dos valores para ser divididos:");
scanf("%f %f",&num1,&num2);
x = num1/num2;
printf("El valor de la division es:%f\n\n",x);
}

void multiplicar(void)
{
float x,num1,num2;
puts("Ingresa dos valores para ser multiplicados:");
scanf("%f %f",&num1,&num2);
x = num1*num2;
printf("El valor de la multiplicacion es:%f\n\n",x);
}

Pág.
6
Lab. N°7 Métodos que no
retornan valor

Pág.
7
 Lab. N°7 Métodos que no
retornan valor

CONCLUSIÓN:

 Es una función con float que divide de dos a

mas valores. El void (El cual no acepta
argumentos). El programa te declara 4
funciones las cuáles son: Suma, Resta,
Multiplicación, División.

 Luego poneos dos valores, pueden ser

cualquier letra ejemplo: a, b

 Después aplicar en la primera opción como se

muestra en la imagen.

Pág.
8
 Lab. N°7 Métodos que no
retornan valor
2. Ejercicio propuesto para investigar y desarrollar

 Teclear un programa que pida que ingrese la cantidad de notas de 20 alumnos,

luego con la opción número 1 deberán ser ordenarlos de menor a mayor. El
programa debe estar hecho con funciones y arreglos. Este programa deberá
pedir la cantidad de notas de forma repetitiva.
 Lab. N°7 Métodos que no
retornan valor

CONCLUSIÓN:

 El primer ejercicio nos sirvió para entender

mejor los programas de funciones (void)

 Esta programación está hecho con funciones y

arreglos

 Algunos programas de funciones no usan

argumento

Pág. 9
 Lab. N°7 Métodos que no
Observaciones Generales
retornan valor
1. La presentación del informe se realiza por el campus virtual., en la clase
siguiente a su realización.
2. Se tomará en cuenta las reglas de ortografía en la redacción del informe.
3. La evaluación se realizará del siguiente modo

Pág.
10
 Lab. N°7 Métodos que no
retornan valor

Lenguajes de
Programación

Laboratorio N° 8

Métodos que retornan

valor

Bullón

Profesor:

II

Mecatrónica Industrial

Pág.
11
 Lab. N°8 Métodos que
retornan valor
Fundamento teorico:
Los métodos con valor de retorno son módulos de programa que pueden recibir datos de
entrada por medio de variables locales (parámetros) y posteriormente retorna un resultado al
punto donde es llamado. Este tipo de métodos se utiliza para operar cualquier tipo de
proceso que produzca un resultado.

Los métodos con valor de retorno se clasifican en dos tipos:

 Métodos con valor de retorno sin parámetros.

 Métodos con valor de retorno con parámetros.
1. Métodos con valor de retorno sin parámetros
Este tipo de métodos no reciben datos de entrada; pero de igual forma retornan un
resultado al punto donde son llamados.

Su definición es de la siguiente manera:

tipo nombreMetodo(){
Declaracion de variables locales
Cuerpo del método
return valor;
}

Donde:

 valor: Es el valor que es retornado por el método.

 tipo: Es el tipo del valor de retorno.
Invocación (llamado):
variable = nombreMetodo();
Donde:

 variable: Es la variable que recibe el valor retornado por el método.

2. Métodos con valor de retorno con parámetros

Este tipo de métodos reciben datos de entrada por medio de parámetros y retornan un
resultado al pundo de su llamado.

Pág.
2
 Lab. N°8 Métodos que
retornan valor
ESCRITURA DE UNA FUNCIÓN

Una función es una sección de código de C que tiene un nombre, independiente, que
ejecuta una tarea específica y que opcionalmente regresa un valor al programa que la
llama.
 Una función tiene nombre
 Una función ejecuta una tarea específica
 Una función puede regresar un valor al programa que la llama

Prototipo de función:

tipo_retorno nombre_función (tipo_argunmento nombre1, tipo_argumento nombre2,…)

Un prototipo de función proporciona al compilador la descripción de una función. El

prototipo incluye un tipo de retorno, que indica el tipo de variable que regresará la
función. También incluye el nombre de la función, que deberá describir lo que hace la
función. El prototipo también contiene el tipo de las variables de los argumentos que
serán pasadas a la función. Opcionalmente puede contener los nombres de las
variables que serán pasadas. Un prototipo siempre termina en punto y coma.
Ejemplo:

int sumar_dos_valores (int a, int b);

float dividir_dos_valore (int a, int b);

Definición de función:
Contiene el código que será ejecutado. La primera línea de la definición de función,
llamado el encabezado de función, debe ser idéntico al prototipo de función, a
excepción del punto y coma. Un encabezado de función no debe terminar con un punto
y coma.
Ejemplo:

Int sumar_dos_valores (int a, int b)

{
return (a+b);
}

Tipo de retorno de una función:

El tipo de retorno de la función específica el tipo de dato que regresa la función al

programa que la llama. Algunas funciones no usan argumentos, y en esos casos la
lista de parámetros debe decir void.

int funcion1(…) /* regresa un tipo int. */

Pág.
3
 Lab. N°8 Métodos que
float funcion2(…) /* regresa un tipo float.
retornan valor */
void funcion3(…) /* no regresa nada.*/

Pág.
4
 Lab. N°8 Métodos que
int sumatoria (int x, int y, int z,…)retornan valor
/* Regresa un tipo entero */

void ejecutar (int x, float y, char z, …)

/* No regresa nada pero acepta argumentos*/

void operar (void)

/* No regresa nada y no acepta argumentos */

Ejemplo 01: Copiar el código y compilarlo. Luego analice e indique lo que sucede.

/************************************************************************/
/************************************************************************/
/* Ejemplo de aplicación con retorno de valor */
#include <stdio.h>

float OperacionMultiplicar(float num1, float num2);

float OperacionCuadrado(float num1);
float x,y,z;
main()
{
puts("Ingrese dos valores a multiplicar:");
scanf("%f %f",&x,&y);
z=OperacionMultiplicar(x,y);
printf("El resultado de la multiplicar %f con %f es: %f\n\n",x,y,z);
puts("Ingrese un valor para elevar al cuadrado:");
scanf("%f",&x);
z=OperacionCuadrado(x);
printf("El resultado de elevar al cuadrado %f es: %f\n\n",x,z);

system("PAUSE");
return 0;
}

float OperacionMultiplicar(float num1, float num2)

{
return(num1*num2);
}
float OperacionCuadrado(float num1)
{
return(num1*num1);
}

Pág.
5
 Lab. N°8 Métodos que
retornan valor

 El código que fue ingresado

tiene la función float que
recibe datos de
entrada por medio de los
parámetros, cumple con 2
función multiplicar dos
valores y elevar un valor
numérico al cuadrado y la
función float es más
utilizado para que produzca
un resultado.

Pág.
6
 Lab. N°8 Métodos que
retornan valor
Procedimiento

1. Hacer un programa que conste de funciones los cuales hacen lo siguiente:

- La opción 1 pone en modo de ingreso de notas.

- La opción 2 muestra en pantalla todas las notas que se ha ingresado.
- La opción 3 ordena de menor a mayor las notas que se han ingresado
y las muestra en pantalla.
- La opción 4 hace el cálculo del promedio de las notas ingresadas y lo muestra
en pantalla.
- La opción 5 muestra en pantalla el total de aprobados.
- La opción 6 muestra en pantalla el total de desaprobados.
- La opción 7 borra todas las notas ingresadas.
- La opción 8 muestra en pantalla la nota mínima y máxima.
- La opción 9 permite salir del sistema.
-

La consola debe de ser igual a la imagen de abajo.

Pág.
7
 Lab. N°8 Métodos que
retornan valor

#include <stdio.h>
#include <stdlib.h>
int cont=0, numero=0, may=0, men=0;//Declaracion de
variables
int valor;
int aprobados;
int aux;
int vector[5];
int num1,num2,num3,num4,num5,promedio;
int i,j,h;
int mayor=0;
int menor=100;
int arreglo[5];
int main (int argc, char *argv[]){
mdo:
printf("\nSeleccione una opcion:\n");
printf("\n|-------------------------------------| ------- |");
printf("\n| | |");
printf("\n| Funcion | Opcion |");
printf("\n| | |");
printf("\n|-------------------------------------| ------- |");
printf("\n| Ingresar notas | 1 |");
printf("\n|-------------------------------------|------- |");
printf("\n| Mostrar notas ingresadas | 2 |");
printf("\n|-------------------------------------| ------- |");
printf("\n| Ordenar de menor a mayor | 3 |");
printf("\n|-------------------------------------| ------- |");
printf("\n| Mostrar promedio | 4 |"); printf("\n|--
-----------------------------------| ----------------------- |");
printf("\n| Mostrar total de aprobados | 5 |");
printf("\n|-------------------------------------| ------- |");
printf("\n| Mostrar total de desaprobados | 6 |");
printf("\n|-------------------------------------| ------- |");
printf("\n| Borrar datos ingresadas | 7 |");
printf("\n|-------------------------------------| ------- |");
printf("\n| Mostrar nota min. y max. | 8 |");
printf("\n|-------------------------------------| ------- |");
printf("\n| Salir del sistema | 9 |");
printf("\n|-------------------------------------| ------- |\n\n");

Pág.
8
 Lab. N°8 Métodos que
retornan valor
scanf("%d",&valor);
system("pause");
system("cls");
switch(valor){
case 1:
printf("\nIngrese numero de notas:\n");
printf("introduce nota 1: ");
scanf("%d",&num1);
printf("introduce nota 2: ");
scanf("%d",&num2);
printf("introduce nota 3: ");
scanf("%d",&num3);
printf("introduce nota 4: ");
scanf("%d",&num4);
printf("introduce nota 5: ");
scanf("%d",&num5);
system("pause");
goto mdo;//Esta funcionn es para que despues de haber
realizado una operacion este regrese y no almacene nada
case 2:
printf("\nNotas ingresadas:\n");
printf("\n%d %d %d %d
%d\n",num1,num2,num3,num4,num5);
system("pause");
goto mdo;
case 3:
printf("Notas de menor a mayor son:\n");
if(num1<num2 && num1<num3)
{
if(num2<num3)
{
printf("\n%d",num1);
printf("\n%d",num2);
printf("\n%d",num3);
}
else {
printf("\n%d",num1);
printf("\n%d",num3);
printf("\n%d",num2);
}
}
if(num2<num1 && num2<num3)
{
if(num1<num3)
{
printf("\n%d",num2);
printf("\n%d",num1);
printf("\n%d",num3);
}
else{
printf("\n%d",num1);
printf("\n%d",num3);
printf("\n%d",num2);
}
}
Pág.
8
 Lab. N°8 Métodos que
if(num3<num1 && num3<num2)retornan valor
{
if(num1<num2)
{
printf("\n%d",num3)
;
printf("\n%d",num1)
;
printf("\n%d",num2)
;
}
else{
printf("\n%d",num1);
printf("\n%d",num3);
printf("\n%d",num2);
}
}
printf("\n");
system("pause"
); goto mdo;
case 4:
promedio=(num1+num2+num3+num4+num5)/5;
printf("\nPromedio total de las notas es
%d\n",promedio); system("pause");
goto
mdo;
case 5:
printf("Las notas aprobadas son:\n");
if(num1>=13)
{
printf("%d",num1);
printf("\n");
}
if(num2>=13)
{
printf("%d",num2);
printf("\n");
}
if(num3>=13)
{
printf("%d",num3);
printf("\n");
}
if(num4>=13)
{
printf("%d",num4);
printf("\n");
}
if(num5>=13)
{
printf("%d",num5);
printf("\n");
}
system("pause"
); goto mdo;
case 6:
printf("\nLas notas desaprobados
son:\n"); if(num1<13)
{ Pág. 9
printf("%d",num1);
printf("\n");
 Lab. N°8 Métodos que
} retornan valor
 Lab. N°8 Métodos que
retornan valor
if(num2<13)
{
printf("%d",num2);
printf("\n");
}
if(num3<13)
{
printf("%d",num3);
printf("\n");
}
if(num4<13)
{
printf("%d",num4);
printf("\n");
}

if(num4<13)
{
printf("%d",num4);
printf("\n");
}
if(num5<13)
{
printf("%d",num5);
printf("\n");
}
system("pause");
goto mdo;
}
case 7:
printf("\nDatos borrados, ingrese nuevamente los datos:\n");
system("pause");
goto mdo;
case 8:
if (num1>mayor)
{
mayor=num1;
}
else if(num1<menor)
{
menor=num1;
}
if (num2>mayor)
{
mayor=num2;
}
else if (num2<menor)
{
menor=num2;
}
if (num3>mayor)
{
mayor=num3;
}

Pág.
10
 Lab. N°8 Métodos que
retornan valor

else if(num3<menor)
{
menor=num3;
}
if (num4>mayor)
{
mayor=num4;
}

system("pause");
goto mdo;
case 9:
printf("\nSaliendo del sistema:\n");
system("pause");
return 0;
return 0;
}
v
else if(num4<menor)
{
menor=num4;
}
if (num5>mayor)
{
mayor=num5;
}
else if (num5<menor)
{
menor=num5;
}
printf("La nota max. es:%d\n",mayor);//Se imprime el
nuero mayor con su respectivo salto de linea
printf("La nota min. es:%d\n",menor);

Pág.
11
 Lab. N°8 Métodos que
retornan valor

 En esta programación el código que

fue ingresado es la funcion printf, que
cumple con poder escribir datos en el
dispositivo de salida estándar en la
pantalla.
 Esta función también retorna el
numero de caracteres impresos, o
un valor negativo si ocurre un error.

Pág.
12
Lab. N°8 Métodos que
retornan valor

Pág.
19
 Lab. N°8 Métodos que
retornan valor
Observación:

 Al colocar tilde en el código, este al momento de

compilar se cambia de letra las palabras con tilde.

 Al ingresar una vocal en mayúscula el programa no lo

reconoce y no lo cuenta con variable.

 El código es muy extenso

Conclusión:

 Las estructuras se utilizan cuando se deben de tomar

una decisión en el desarrollo de la solución a un
problema

 Se llegó a identificar los tipos de retorno de funciones

y sus usos

Pág.
20
 Lab. N°8 Métodos que
retornan valor
Observaciones Generales

1. La presentación del informe se realiza por el campus virtual., en la clase siguiente a su realización.
2. Se tomará en cuenta las reglas de ortografía en la redacción del informe.
3. La evaluación se realizará del siguiente modo

Pág.
21