Practica 5. Procedimientos y funciones.

Objetivo: Comprender el uso de procedimientos, funciones y porque se diseñan.

Marco conceptual.

Función: Es conjunto de instrucciones o clausulas bajo mismo nombre, cuya característica

principal es que devuelven un valor.

Las funciones permiten la modularidad del código, simplificándolo, en fragmentos que

pueden aplicarse, y algunos talvez dependa de otros.

La sintaxis:
// para la definición
tipo nombreFuncion(argumentos);

//para el cuerpo
tipo nombreFuncion(argumentos){
// estructuras o clasulas
// la devolucion del tipo correspondiente
return valorTipo;
}

// la incovacion
//atraves de una variable del tipo
varTipo = nombreFuncion(argumentos);
// atraves de salida en pantallla
printf(" directrizTipo",nombreFuncionargumentos);
// en una invocacion de argumento
...nombreFuncion1(nombreFuncion2());

Procedimientos: es conjunto de instrucciones ó cláusulas que están bajo un mismo pero

que no devuelven nada, solo puedes usar para mostrar o con elementos globales.

La sintaxis:
// para la definición
void nombreProcedimiento(argumentos);
 //para el cuerpo
void nombreProcedimiento(argumentos){
// estructuras o clausulas
}

// la incovacion
nombreProcedimiento(argumentos);

Actividades.

1. De acuerdo a la imagen con la función realiza un programa que utilice procedimientos y

funciones para resolverlo.

#include<stdio.h>
// definicion de funciones
int f1(int);
int f2(int);
int f3(int);
int f(int);
// definicion procedimiento
void funcion();

int main(){
//la llamada a procedimiento
funcion();
// la salida del main
return 1;
}

// cuerpos de funciones
// 2
int f1(int px){
// 3x+ 36
// 3*2 +36
// 6 +36
// 42
return 3*px + 36;
}
// 20
int f2(int px){
// x^2 -10
// 20*20 -10
// 390
return px*px -10;
}
int f3(int px){
// x+6
return px+6;
}
// 2,20
int f(int px){
// variable de salida
int r;
// si aplica la funcion 1
// 2<11, 20<11
// 1 0
(px<=11)?
// 2
// 42
(r=f1(px)):
//20>11 && 20<=33
// 1 && 1
// 1
((px>11 && px<=33)?
// 20
// 390
(r=f2(px)):
((px>33&& px<=64)?
(r=f3(px)):
(r=0)));
// devuelve la respuesta
return r;// 42,390
}
// Cuerpo procedimiento
void funcion(){
// Declaramos una variable
int x;//[82828]
// Asignamos un valor
x=20;//[2] 2,20
 // f(20)=390
// f(2)= 42
printf("f(%d)=%d \n",x,f(x));
}

2. Dado la función matemática, determina valores de acuerdo al rango observa la imagen.

Los valore varían de acuerdo al residuo

variable % 4 si es 0 entonces g(x)=x^2 => int g1(int)

si es 1 entonces g(x)=x/6 => float g2(int)
si es 2 entonces g(x)=raiz(x) => float g3(int)
si es 3 entonces g(x)=x^3+5 => int g4(int)

// La biblioteca principal
#include<stdio.h>
// Para las funciones matemáticas
#include<math.h>

// Declaraciones de funciones
int g1(int);
float g2(int);
float g3(int);
int g4(int);

// declaración de procedimiento
void g(int);

// La función principal
int main(){
// Llamada al procedimiento
g(27);
// La salida del main
return 1;
}
// Cuerpos de funciones
// matemáticamente computacionalmente en C
// x^2 pow(x,2)
// 3x^3+2x 3*pow(x,3)+2*x
//
int g1(int pv){
// return pow(pv,2);
return pv*pv;
}

float g2(int pv){

return pv/6.0;
}
// Matemáticamente computacionalmente en C
// raiz(x) sqrt(x)
// raiz(x)= x^1/2 pow(x,0.5)

float g3(int pv){

return sqrt(pv);
}
// 27
int g4(int pv){
// pv*pv*pv+5;
// 27^3 +5
// 19688
return pow(pv,3)+5;
}

// Cuerpo de procedimiento
// 27
void g(int px){
// Tomo la decisión de función voy a llamar
// 6
// 4|27
// -24
// 3
//27%4==2
//3 ==2
// 0
(px%4==2)?
printf("g3(%d)=%f",px,g3(px)):
 //27%4==0
//3 ==0
// 0
((px%4==0)?
printf("g1(%d)=%d",px,g1(px)):
//27%4==3
//3 ==3
// 1
((px%4==3)?
// 27 g4(27)
// 19688
// g4(27)=19688
printf("g4(%d)=%d",px,g4(px)):
printf("g2(%d)=%f",px,g2(px))));
}