Programación 1: funciones en C

Programación 1
Funciones en C
Angel Vázquez-Patiño
angel.vazquezp@ucuenca.edu.ec
Departamento de Ciencias de la Computación
Universidad de Cuenca
14 de septiembre de 2017

14/09/17 Angel Vázquez-Patiño 2/51
Objetivos
1) Conocer el concepto de función
2) Conocer el concepto de parámetro/argumento
3) Implementar funciones en C
4) Tener una primera aproximación al concepto
de puntero
5) Entender las llamadas de funciones por valor y
por referencia
6) Entender las reglas de ámbito de las variables

Funciones y parámetros

Divide et impera
Resolver un problema difícil dividiéndole en
partes más simples

Divide et impera
Tantas veces hasta que la resolución sea obvia

Función
Definición
●
Subalgoritmo, parte de un algoritmo principal
que permite resolver una tarea específica
●
Puede ser invocada desde otras partes del
algoritmo cuantas veces se necesite
●
Puede recibir valores (parámetros o
argumentos)
●
Puede devolver valores

Función
5 25

Función
Función resultado <- Potencia (base, exponente)
resultado <- base ^ exponente;
FinFunción
Algoritmo funcionPotencia
Definir base, exponente Como Entero;
Escribir "Ingrese Base: ";
Leer base;
Escribir "Ingrese Exponente: ";
Leer exponente;
Escribir "Resultado: ", Potencia(base, exponente);
FinAlgoritmo

1 #include<stdio.h>
2 // prototipo/declaración de función
3 float cuadrado(float x);
4 int main( ){
5 float m, n ;
6 scanf ("%f", &m) ;
7 n = cuadrado (m) ; // llamada
8 }
9 // definición
10 float cuadrado(float x){
11 float p = x * x;
12 return p;
13 }

Función
Cómo nombrar una función
●
Letras del alfabeto inglés, dígitos y el carácter _
●
El primer carácter no puede ser número
●
No usar palabras reservadas
●
Usar nombres descriptivos (nemotécnicos)
●
No usar el mismo nombre de las funciones para
variables ni viceversa
●
No usar espacios

Ejemplo guiado 1
Problema: calcular el cubo de un número
int cubo(int num)
{
return num*num*num;
}
Nombre ParámetroTipoTipo
Para devolver un valor

Ejemplo guiado 1
#include<stdio.h> // Uso de la función
int cubo(int num);
int main(){
int m, n;
printf("Número: "); scanf("%d", &m);
n = cubo(m);
printf ("El cubo de %d es %d.", m,
n);
}
int cubo(int num){ return num*num*num; }

Ejemplo guiado 1
#include<stdio.h> // Otra forma de llamar
int cubo(int num);
int main(){
int m;
printf("Número: "); scanf("%d", &m);
printf("%d^%d", m, cubo(m));
}
int cubo(int num){ return num*num*num; }

Ejemplo guiado 2
Problema: calcular el área de un triángulo
●
Para más parámetros, se separa con coma
int areaTriangulo(int base,int altura)
{
return base*altura;
}

Ejemplo guiado 2
#include<stdio.h>
int areaTriangulo(int base, int altura);
int main(){
int b, a;
printf("Base: "); scanf("%d", &b);
printf("Altura: "); scanf("%d", &a);
printf("Área: %d", areaTriangulo(b, a));
}
int areaTriangulo(int base, int altura)
{ return base*altura; }

Ejemplo guiado 3
Problema: calcular 5!
●
Es posible usar funciones sin parámetros
#include<stdio.h>
int factorial5();
int main(){
printf("5!: %d", factorial5());
}
int factorial5(){return 5*4*3*2;}

Ejemplo guiado 4
Problema: mostrar la tabla de multiplicar (1-10) de
un número
●
Una función no necesariamente devuelve un
valor
● En C se usa void para indicar que la función
no devuelve ningún valor. Y no se usa nunca
return (porque nunca se devuelve nada)

Ejemplo guiado 4
#include<stdio.h>
void tablaMultiplicar(int num);
int main(){ tablaMultiplicar(8); }
void tablaMultiplicar(int num){
for(int i=1; i<11; i++)
printf("%d x %d = %dn", num, i,
num*i);
}

Ejemplo guiado 5
Problema: mostrar la tabla de multiplicar del 7
●
Se puede definir funciones sin parámetros
#include<stdio.h>
void tabla7();
int main(){ tabla7(); }
void tabla7(){
for(int i=1; i<11; i++)
printf("7 x %d = %dn", i,
7*i);}

Ejercicio propuesto 1
●
Implementar una función que reciba un número
entero y devuelva True si dicho valor es impar
y False si es par
●
Utilizar un nombre adecuado para la función,
i.e., un nombre nemotécnico

#include<stdio.h>
_Bool esImpar(int n);
int main(){
int num;
printf("Número: "); scanf("%d", &num);
printf(esImpar(num)==0?"nImpar: F":"nImpar: T");
}
_Bool esImpar(int n){
if(n%2 != 0)
return 1;
return 0;}

●
Implementar una función que reciba un número
entero e imprima en pantalla los valores
anterior y posterior a ese número
●
Utilizar un nombre adecuado para la función,
i.e., un nombre nemotécnico

#include<stdio.h>
void antPos(int n);
int main(){
int num;
printf("Número: "); scanf("%d", &num);
antPos(num);}
void antPos(int n){
printf("Anterior: %d.n", n-1);
printf("Posterior: %d.", n+1);}

Llamada de funciones por valor y
por referencia

Llamada por valor y por referencia
Llamada por referencia
●
La dirección de la variable es pasada a la
función como parámetro
●
El valor del parámetro puede ser modificado
●
El mismo espacio de memoria es usado en la
función y desde donde se llama

Puntero
●
Variable que contiene la dirección de memoria
de un dato o de otra variable que contiene al
dato en un arreglo
●
Apunta al espacio físico donde está el dato o la
variable
●
Vea https://youtu.be/YqoV6UMQEcE

Puntero
●
Muchas de las funciones estándares de C,
trabajan con punteros, e.g. scanf y strcpy
char a;
scanf ("%c",&a);

Declaración de punteros
●
Igual que cualquier otra variable, pero
anteponiendo un * antes del nombre de la
variable
tipo *NombrePuntero;

1 #include <stdio.h>
2 int main(){
3 int a=0; int *punt;
4 punt=&a;//Asigna dir memori de a
5 printf("Valor de a: %d. nValor de
*punt: %d. n", a, *punt);
6 printf("Dirección de memoria de
*punt: %p", punt);
7 printf("nDirección de memoria de a
(&a): %p", &a);
8 }

#include<stdio.h>
void swap(int *a, int *b);
int main(){
int m = 22, n = 44;
printf("Antes m = %d y n = %dn", m, n);
swap(&m, &n);
printf("Después m = %d y n = %dn", m, n);}
void swap(int *a, int *b){
int tmp = *a;
*a = *b;
*b = tmp;
printf("Función a = %d y b = %dn", *a, *b);}

#include<stdio.h>
void swap(int a, int b);
int main(){
int m = 22, n = 44;
printf("Antes m = %d y n = %dn", m, n);
swap(m, n);
printf("Después m = %d y n = %dn", m, n);}
void swap(int a, int b){
int tmp = a;
a = b;
b = tmp;
printf("Función a = %d y b = %dn", a, b);}

Funciones que devuelven un arreglo

2 int * obtenerPares(int n){
3 // Arreglo entero stático local
4 static int arregloPares[100];
5 for(int i=0; i<n; i++)
6 arregloPares[i] = (i+1)*2;
7 // devuelve base address de arregloPares
8 return arregloPares;}
9 int main(){
10 int *arreglo; arreglo = obtenerPares(10);
11 for(int cont=0; cont<10; cont++)
12 printf("%dn", arreglo[cont]);}

Ejercicio propuesto 3 (1)
//****************************************
num <- divisor
a_d <- num
Repetir
num <- a_d
a_d <- 0
Mientras num > 0 Hacer
a_d <- a_d + num MOD 10
num <- trunc(num / 10)
FinMientras
Hasta Que a_d < 10
//********************************************
num <- cociente
ac <- num
Repetir
num <- ac
ac <- 0
ac <- ac + num MOD 10
FinMientras
Hasta Que ac < 10
Algoritmo pruebaDelNueve
// Versión de Angel Vázquez
Leer dividendo
Leer divisor
cociente <- trunc(dividendo / divisor)
residuo <- dividendo MOD divisor
//****************************************
num <- dividendo
aD <- num
Repetir
num <- aD
aD <- 0
aD <- aD + num MOD 10
FinMientras
Hasta Que aD < 10

Ejercicio propuesto 3 (2)
num <- residuo
ar <- num
Repetir
num <- ar
ar <- 0
ar <- ar + num MOD 10
FinMientras
Hasta Que ar < 10
//***********************
num <- a_d * ac + ar
a_dc_r <- num
Repetir
num <- a_dc_r
a_dc_r <- 0
a_dc_r <- a_dc_r + num MOD 10
FinMientras
Hasta Que a_dc_r < 10
//****************************************
Escribir "Dividendo: ", dividendo, ". Suma: ", aD
Escribir "Divisor : ", divisor, ". Suma: ", a_d
Escribir "Cociente : ", cociente, ". Suma: ", ac
Escribir "Residuo : ", residuo, ". Suma: ", ar
Escribir " "
Escribir " D = d * c + r -> ", aD, " = ",
a_dc_r
Escribir " "
Si aD = a_dc_r Entonces
Escribir " División correcta."
Sino
Escribir " División incorrecta."
Fin Si
FinAlgoritmo

Ámbito de las variables

Ámbito
●
Región del programa donde una variable definida
puede tener su existencia y más allá de esa
variable no puede ser accedida
Tres lugares donde se pueden declarar en C
1) Dentro de una función o bloque, variables locales
2) Fuera de todas las funciones, variables globales
3) En la definición de los parámetros de la función,
parámetros formales

Variables locales
●
Declaradas dentro de una función o bloque
●
Pueden ser usadas sólo por sentencias que
están dentro de esa función o bloque de código
●
No son conocidas por funciones fuera de donde
fueron declaradas

2 int main() {
3 /* declaración de variables locales */
4 int a, b;
5 int c;
6 /* inicialización */
7 a = 10; b = 20; c = a + b;
8 printf("a: %d, b: %d y c: %d",a,b,c);
9 return 0;
10 }

Variables globales
●
Definidas fuera de una función, usualmente al
inicio del programa
●
Toman sus valores durante todo el tiempo de
vida del programa
●
Pueden ser accedidas dentro de cualquier
función definida en el programa

2 /* declaración de variable global */
3 int g;
4 int main() {
5 /* declaración de variables locales */
6 int a, b;
7 /* inicialización */
8 a = 10; b = 20; g = a + b;
9 printf("a: %d, b: %d y g: %d", a, b, g);
10 return 0;
11 }

Variables globales
●
Un programa puede tener el mismo nombre
para una variable local y una variable global
●
El valor de la variable local dentro de una
función tendrá la preferencia

2 /* declaración de variable global */
3 int g = 20;
4 int main()
5 {
6 /* declaración de variable local */
7 int g = 10;
8 printf("g: %d.n", g);
9 return 0;
10 }

Parámetros formales
●
Son tratados como variables locales dentro de
una función y toman la precedencia por encima
de cualquier variable global

2 int a = 20;
3 int main(){
4 int a = 10; int b = 20; int c = 0;
5 printf("a en main(): %d.n", a);
6 c = sumar(a, b);
7 printf("c en main(): %d.n", c);
8 return 0;}
9 int sumar(int a, int b){
10 printf("a en sumar(): %d.n", a);
11 printf("b en sumar(): %d.n", b);
12 return a + b;}

Inicialización de variables locales y globales
●
Cuando se define una variable local, no es
inicializada por el sistema. El programador la
debe inicializar
●
Cuando se define una variable global, es
inicializada automáticamente por el sistema

Tipo de dato Valor inicial por
defecto
int 0
char ‘0’
float 0
double 0
pointer NULL

Inicialización de variables locales y globales
Es una buena práctica de programación
inicializar las variables apropiadamente, de otro
modo el programa puede producir resultados
inesperados porque las variables no inicializadas
tomarán valores basura ya disponibles en sus
posiciones de memoria

Conceptos y términos importantes
●
Palabras reservadas de C que no pueden ser
usadas como nombres de funciones
●
Punteros: obtención del valor del espacio de
memoria y la dirección del espacio de memoria
●
Llamado de función por valor y por referencia
●
Funciones que devuelven un arreglo
●
Reglas del ámbito de una variable

Referencias
●
C programming tutorial,
http://fresh2refresh.com/c-programming/
●
Departamento de Ciencias de la Computación, 2016.
Guía de aprendizaje del MOOC de Fundamentos de
Programación: parte II. Universidad de Cuenca,
Cuenca, Ecuador.
●
Plataforma MOOC Cedia, https://goo.gl/VDWwKV
●
Programación en C/Punteros, https://goo.gl/Wqx2Pa
●
Return array from function in C, https://goo.gl/YnlUbi

Preguntas

Programación 1: funciones en C

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (7)

Similar a Programación 1: funciones en C

Similar a Programación 1: funciones en C (20)

Más de Angel Vázquez Patiño

Más de Angel Vázquez Patiño (20)

Último

Último (20)

Programación 1: funciones en C