PDF de programación - 4. La abstracción procedimental

Fundamentos de la programación

4444

I
I

Grados en Ingeniería Informática, Ingeniería
Grados en Ingeniería Informática, Ingeniería
dlSf
dlSf
d
d
i
i
í d C
í d C
del Software e Ingeniería de Computadores
del Software e Ingeniería de Computadores
Ana Gil Luezas
Ana Gil Luezas
(adaptadas del original de Luis Hernández Yáñez)
(adaptadas del original de Luis Hernández Yáñez)
FacultaddeInformática
FacultaddeInformática
Facultad de Informática
Facultad de Informática
Universidad Complutense
Universidad Complutense

Subprogramas
Subprogramas
Parámetros
Parámetros
Parámetros
Parámetros
Argumentos
Argumentos
Parámetros por referencia constante
Parámetros por referencia constante
Resultado y vuelta de la función
Resultado y vuelta de la función
Notificación de errores
Notificación de errores
Subprogramas y declaraciones
Subprogramas y declaraciones
Prototipos
Prototipos
Sobrecarga de funciones
Sobrecarga de funciones
Funciones de operador
Funciones de operador
Funciones de operador
Funciones de operador
Argumentos
Argumentos implícitos
implícitos
La función
La función mainmain() ()

p g
p g

y
y

22
77
77
1111
2222
2626
3333
3939
4545
4949
5252
5252
5656
6464

Fundamentos de la programación: La abstracción procedimental
Fundamentos de la programación: La abstracción procedimental

Página
Página 11

Fundamentos de la programación: La abstracción procedimental
Fundamentos de la programación: La abstracción procedimental

Página
Página 22

Subprogramas
Subprogramas

j
j

p
p

Subrutinas, procedimientos, funciones, acciones, ...
Subrutinas, procedimientos, funciones, acciones, ...

p gp g
Pequeños programas dentro de otro programa.
Pequeños programas dentro de otro programa.

Unidades de ejecución independientes.
Unidades de ejecución independientes.
Encapsulan código y datos.
Encapsulan código y datos.
Pueden comunicarse con otros subprogramas (parámetros).
Pueden comunicarse con otros subprogramas
p gp g
(p
(p
(parámetros).
)
)
Realizan tarea s individuales del programa.
Realizan tarea s individuales del programa.
y
Funcionalidad concreta, identificable y coherente (diseño).
Funcionalidad concreta, identificable y coherente (diseño).
)
)
(
(
y
Se ejecutan de principio a fin cuando se llaman (
Se ejecutan de principio a fin cuando se llaman (invocan
invocan).).
Terminar devolviendo el control al punto de llamada.
Terminar devolviendo el control al punto de llamada.
Aumentan el nivel de abstracción del programa.
Aumentan el nivel de abstracción del programa.
y
t
i
l
ió
ió
Facilitan la prueba, la depuración y el mantenimiento.
Facilitan la prueba, la depuración y el mantenimiento.
i
i
i
t
t
t
l
y
F ilit
F ilit

b l d
b l d
,
,

p
p

l
l

p
p

pp

Fundamentos de programación: La abstracción procedimental
Fundamentos de programación: La abstracción procedimental

Página
Página 33

Datos
Datos de entrada, datos de salida y datos de entrada/salida
de entrada, datos de salida y datos de entrada/salida
Datos de entrada: aceptados
Datos de entrada: aceptados
Datos de salida: devueltos
Datos de salida: devueltos
Datos de entrada/salida:
Datos de entrada/salida:
aceptadosymodificados
aceptadosymodificados
aceptados y modificados
aceptados y modificados

Subprograma
Subprograma
Subprograma
Subprograma

Subprograma
Subprograma

Subprograma
Subprograma

49494949

7777

b:b:77b:b:77

b:b:4949b:b:4949

Fundamentos de programación: La abstracción procedimental
Fundamentos de programación: La abstracción procedimental

Página
Página 44

domingo}}tDiaSemana
tDiaSemana;;

typedef
typedef enumenum {{lunes
const
const intint NumDias
const
const intint NumDias

lunes, , martes
NumDias == 77;;
NumDias = = 77;

martes,,......, , domingo
// Tema 3
// Tema 3
; // Tema 3
// Tema 3

Subprograma
Subprograma que dado un día de la semana lo
que dado un día de la semana lo muestra
muestra
que lee y devuelve un día de la semana
Subprograma
Subprograma que lee y devuelve un día de la
semana

void
void mostrar(
mostrar(tDiaSemana
(){ … mostrar(
main(){ …
intint main

tDiaSemana ddls
mostrar(lunes

ddls););

lunes); …}
); …}

lunes
lunes
lunes
lunes

Subprograma
Subprograma

tDiaSemana
tDiaSemana leerDdls
tDiaSemana
tDiaSemana leerDdls
intint main

leerDdls();();
leerDdls();();
main(){(){… … tDiaSemana
mostrar(
mostrar(diadia); );
}}…}…}

tDiaSemana diadia == leerDsls

leerDsls();();

Subprograma
Subprograma

jueves
jueves
jueves
jueves

Fundamentos de programación: La abstracción procedimental
Fundamentos de programación: La abstracción procedimental

Página
Página 55

 Subprograma

Subprograma que que dado un día de la semana devuelve el siguiente día
dado un día de la semana devuelve el siguiente día
tDiaSemana
tDiaSemana siguiente(
intint main
()()

((
tDiaSemana diadia = siguiente(
lunes); ); …}…}

siguiente(tDiaDemana

main(){(){… … tDiaSemana

= siguiente(lunes
))

tDiaDemana ddlsddls););

Subprograma
que dada una variable la modifica con el siguiente día
qq
Subprograma que dada una variable
p gp g
la modifica con el siguiente día

Subprograma
Subprograma

martes
martes
martes
martes

lunes
lunes
lunes
lunes

gg

voidvoid siguiente(
intint main

siguiente(tDiaDemana
main(){(){… … tDiaSemana

tDiaDemana && ddlsddls););
tDiaSemana diadia = = lunes

lunes; siguiente(

; siguiente(diadia); …}
); …}

diadia:: lunes
diadia:: lunes
lunes
lunes
diadia: : lunes
diadia: : lunes
lunes
lunes

Subprograma
Subprograma
Subprograma
Subprograma

diadia:: martes
diadia:: martes
martes
martes
diadia: : martes
diadia: : martes
martes
martes

Fundamentos de programación: La abstracción procedimental
Fundamentos de programación: La abstracción procedimental

Página
Página 66

Declaración de parámetros
Declaración de parámetros

pp

Se distinguen dos clases de parámetros:
Se distinguen dos clases de parámetros:
——Por valor (se copia el valor): Sólo de
p
(
p
(
Por valor (se copia el valor): Sólo de entrada
entrada
)
)
Sólo salida o o entrada/salida
——Por Por variable:
entrada/salida
variable: Sólo salida
Entre los paréntesis de la cabecera del subprograma.
Entre los paréntesis de la cabecera del
subprograma.

Li
Li
Lista de parámetros formales
Lista de parámetros formales

á
á

d
d

f
f

l
l

tipo
tipo nombre

nombre((parámetros
parámetros))

&&
&&

pparámetros
pparámetros
arámetros
arámetros

ttipoipo

iidentificador
dentificador

,,

Por referencia
ffff
Por referencia
Por referencia
Por referencia

Fundamentos de programación: La abstracción procedimental
Fundamentos de programación: La abstracción procedimental

Página
Página 77

Parámetros por valor
Parámetros por valor

intint cuadrado(

cuadrado(intint numnum););

double
double potencia(
double
double potencia(

potencia(double
potencia(double

base
double base
intint expexp););
base, intint expexp););
double base,

void
void mostrar(

mostrar(tDiaSemana

tDiaSemana diadia); );

void
void mostrar(

mostrar(double

double diadia););

Argumentos
Argumentos
Argumentos
Argumentos

mostrar(potencia(cuadrado(3*2+1), 3
mostrar(potencia(cuadrado(3*2+1), 3));));

mostrar(potencia(cuadrado(7),
mostrar(potencia(cuadrado(7), 33));));

mostrar(potencia(49
3));
3));
mostrar(potencia(49, 3));
mostrar(potencia(49
mostrar(potencia(49, 3));

mostrar(117649);
mostrar(117649);

Fundamentos de programación: La abstracción procedimental
Fundamentos de programación: La abstracción procedimental

Página
Página 88

Parámetros por referencia o variable
Parámetros por referencia o variable

void
void incr

incr((intint & & numnum););

&&&&

void
void leer(
void
void leer(
void
void intercambia(

leer(tDiaSemana
leer(tDiaSemana
intercambia(double

tDiaSemana && diadia););
tDiaSemana & & diadia););

double & & xx, , double

double & & y);y);

Argumentos
Argumentos
intint n =

n = 4545; ; double

double v =

;;

v = 2.32.3, y =

, y = 3333; ; tDiaSemana
, y, y

tDiaSemana ddls
ddls; ;
;;

;;

incr
incr(n);

(n); // ahora n ==

// ahora n == 4646

leer(
leer(ddls

ddls); ); // // supongamos martes
supongamos martes

siguiente(
ddls); );
(
siguiente(ddls
(
););

g
g

// // ahora
////

ahora ddls

ddls == == miercoles
miercoles

intercambia(v, y);
intercambia(v, y); // ahora

// ahora v v == == 33 e y == 2.3
33 e y == 2.3

Fundamentos de programación: La abstracción procedimental
Fundamentos de programación: La abstracción procedimental

Página
Página 99

Puedehabertantoparámetrosporvalorcomoporreferencia
Puedehabertantoparámetrosporvalorcomoporreferencia
Puede haber tanto parámetros por valor como por referencia
Puede haber tanto parámetros por valor como por referencia
A
ió !
ió !
¡Atención!
A
¡Atención!LLos os arrays
arraysy los flujos NO se pueden pasar por valor
y los flujos NO se pueden pasar por valor
se pasan por defecto (sin poner &&) ) por referencia
arraysse pasan por defecto (sin poner
 Los Los arrays
por referencia
salida o E/S : no poner nada
Parámetros
Parámetros de de salida o E/S : no poner nada
d l
d
Parámetros de entrada: declarar const
P á
P á
Parámetros de entrada: declarar
d
t d
t d
d l
t
t
 Losflujos
)hayquepasarlosporreferencia(poner &&))
Losflujos((stream)hayquepasarlosporreferencia(poner
 Los flujos
Los flujos ((stream) hay que pasarlos por referencia (poner
) hay que pasarlos por referencia (poner &&))
Aunque el flujo sea de lectura (input), el cursor debe moverse.
Aunque el flujo sea de lectura (input), el cursor debe moverse.

ostream & flujo,
flujo,, tipo
flujo, , tipo

const
tt
const tArray
tArray lista

void
void escribir(
void
void leer(
void
void leer(

escribir(ostream
leer(istream
leer(istream

void
void agregar(

agregar(char

double
double media(

media(const

& flujo, tipo

tipo dato);
dato);

istream && flujo
istream & & flujo

tipo && dato);
tipo & & dato);
dato);
dato);

char cstr

cstr[],

[], char

char ch);
ch);

lista););

Fundamentos de programación: La abstracción procedimental
Fundamentos de programación: La abstracción procedimental

Página
Página 1010

Llamada a un subprogra