Libro de Prácticas 2001-06

Fundamentos de Informática
1º Curso. Ingeniería Química
Libro de Prácticas
Manuel López Martínez
Manuel Ruiz Arahal
Ing. Sistemas y Automática
© 2001-2006
Índice
FUNDAMENTOS DE INFORMÁTICA
Práctica 1: La máquina Cesius............................................. 1
LENGUAJE C
Compilador C.....................................................................61
Práctica 1: Área de un polígono regular...............................67
Práctica 2: Bifurcaciones y Bucles.......................................69
Práctica 3: Funciones..........................................................73
Práctica 4: Vectores y Cadenas de Caracteres.....................75
Práctica 5: Multiplicación de Matrices.................................77
Práctica 6: Funciones de Entrada/Salida de Ficheros.........81
Fundamentos de Informática.
Práctica
Funcionamiento de la computadora digital
En esta práctica se pretende aclarar mediante ejemplos prácticos el funcionamiento de la
computadora estudiando las transferencias elementales entre registros al ejecutar ciertas
instrucciones.
2.1 Desarrollo de la práctica
2.1.1 Carga, suma y almacenamiento
Se van a analizar las siguientes instrucciones:
Cargar en el acumulador un número localizado en la memoria en la dirección 5.
Sumar al acumulador un número localizado en la memoria en la dirección 6.
Almacenar en la dirección 7 de la memoria el resultado contenido en el acumulador.
Se supondrá que estas instrucciones están en la memoria en las direcciones 23, 24 y 25
respectivamente.
El alumno ha de escribir las transferencias elementales entre registros y las señales de
gobierno correspondientes a la ejecución de las tres instrucciones citadas.
Posteriormente pondrá en marcha un programa en el ordenador para comprobar los
resultados. Este programa muestra una animación realizada mediante imágenes
sucesivas; como una proyección de diapositivas.
El alumno comprobará que los resultados observados en la proyección en su ordenador
son los mismos que había obtenido en su análisis previo.
2.1.2 Otras instrucciones
El alumno podrá observar que el programa contiene más diapositivas que las
comentadas. Estas diapositivas adicionales muestran ejemplos basados en otras
instrucciones. Es un ejercicio muy conveniente intentar el análisis de estas otras
instrucciones.
Tenga presente al observar esta parte que el tamaño del dibujo de la memoria en la
pantalla no permite incluir en él los 2048 registros, por lo que sólo se dibuja en cada
momento la parte interesante.
2.2 Programa a usar
El programa que el alumno debe usar se pone en marcha activando el icono
ppview32.exe que se halla en la carpeta fundinf1ii/p2 del disco marcado como
"software en CDC" (suele ser la unidad H:'Cdcsrv3'). Para ello puede simplemente
activar MiPC pulsando sobre el icono del escritorio y seleccionar las carpetas en el
1
Fundamentos de Informática.
orden correcto. Este programa solicita el nombre de la presentación que se quiere
mostrar, en este caso se ha de seleccionar el archivo p2_2000.ppt.
Aparece entonces la presentación formada por diapositivas. Para pasar de una pantalla a
otra se puede usar la tecla del espacio o las de Avance de Página y Retroceso de Página.
En la figura de la página siguiente se muestra el aspecto de las primeras diapositivas. Se
observa que los números se representan dentro de los registros no en binario (que sería
lo correcto) sino en decimal, para facilitar la lectura.
Es conveniente aclarar que, para simplificar las diapositivas, sólo se han dibujado en
cada momento los aspectos más interesantes para la operación en curso. En concreto, no
se presenta todo el contenido de la memoria sino sólo la parte implicada en cada
momento.
Se observará que durante una transferencia entre registros se dibuja con color verde los
accesos al enlace que permiten el paso de información mientras que el resto de accesos
están dibujados en color rojo. Las señales de gobierno de la memoria y UAL sólo se
dibujan cuando son activadas.
CAR 5 situación inicial
9
3
0
S
7
A
P
23
7
CAR 5
SUM 6
ALM 7
I
T
E
2
Fundamentos de Informática.
2.3 Evaluación
Indique el contenido de cada registro de la computadora elemental (incluyendo los
registros ocupados de la memoria) después de ejecutar las instrucciones:
Cargar en el acumulador un número localizado en la memoria en la dirección 5.
Sumar al acumulador un número localizado en la memoria en la dirección 6.
Almacenar en la dirección 7 de la memoria el resultado contenido en el acumulador.
Se supondrá que estas instrucciones están en la memoria en las direcciones 23, 24 y 25
respectivamente.
3
CESIUS
Transferencias entre registros y
señales de gobierno para algunas
instrucciones
4
CAR 5 situación inicial
9
3
0
S
7
A
P
23
7
CAR 5
SUM 6
ALM 7
I
T
E
© MRA, 2000
5
CAR 5 búsqueda instrucción (1)
9
3
0
S
7
A
P
23
23
7
CAR 5
SUM 6
ALM 7
I
T
E
© MRA, 2000
6
CAR 5 búsqueda instrucción (2)
9
3
0
S
7
A
P
23
23
7
LECM
CAR 5
SUM 6
ALM 7
I
CAR 5
T
E
© MRA, 2000
7
CAR 5 búsqueda instrucción (3)
9
3
0
S
7
A
P
23
23
7
CAR 5
CAR 5
SUM 6
ALM 7
I
CAR 5
T
E
© MRA, 2000
8
CAR 5 búsqueda operando (1)
9
3
0
S
7
A
P
5
23
7
CAR 5
CAR 5
SUM 6
ALM 7
I
CAR 5
T
E
© MRA, 2000
9
CAR 5 búsqueda operando (2)
9
3
0
S
7
A
P
5
23
7
CAR 5
LECM
CAR 5
SUM 6
ALM 7
9
I
T
E
© MRA, 2000
10
CAR 5 búsqueda operando (3)
9
3
0
S
7
A
P
5
23
7
9
CAR 5
CAR 5
SUM 6
ALM 7
9
I
T
E
© MRA, 2000
11
CAR 5 ejecución operación
9
3
0
S
9
A
P
CARGA
9
9
5
23
CAR 5
CAR 5
SUM 6
ALM 7
9
I
T
E
© MRA, 2000
12
CAR 5 preparación instrucción siguiente
9
3
0
S
9
A
INCP
P
5
24
9
9
CAR 5
CAR 5
SUM 6
ALM 7
9
I
T
E
© MRA, 2000
13
SUM 6 búsqueda instrucción (1)
9
3
0
S
9
A
P
24
24
9
9
CAR 5
SUM 6
ALM 7
I
T
E
© MRA, 2000
14
SUM 6 búsqueda instrucción (2)
9
3
0
S
9
A
P
24
24
9
9
LECM
CAR 5
SUM 6
ALM 7
I
SUM 6
T
E
© MRA, 2000
15
SUM 6 búsqueda instrucción (3)
9
3
0
S
9
A
P
24
24
9
9
SUM 6
CAR 5
SUM 6
ALM 7
I
SUM 6
T
E
© MRA, 2000
16
SUM 6 búsqueda operando (1)
9
3
0
S
9
A
P
6
24
9
9
SUM 6
CAR 5
SUM 6
ALM 7
I
SUM 6
T
E
© MRA, 2000
17
SUM 6 búsqueda operando (2)
9
3
0
S
9
A
P
6
24
9
9
SUM 6
LECM
CAR 5
SUM 6
ALM 7
I
3
T
E
© MRA, 2000
18
SUM 6 búsqueda operando (3)
9
3
0
S
9
A
P
6
24
9
3
SUM 6
CAR 5
SUM 6
ALM 7
I
3
T
E
© MRA, 2000
19
SUM 6 ejecución instrucción
9
3
0
S
12
A
P
SUMA
9+3
12
3
6
24
SUM 6
CAR 5
SUM 6
ALM 7
I
3
T
E
© MRA, 2000
20
SUM 6 preparación instrucción siguiente
9
3
0
S
12
A
INCP
P
6
25
12
3
SUM 6
CAR 5
SUM 6
ALM 7
I
3
T
E
© MRA, 2000
21
ALM 7 búsqueda instrucción (1)
9
3
0
S
12
A
P
25
25
12
3
SUM 6
CAR 5
SUM 6
ALM 7
I
3
T
E
© MRA, 2000
22
ALM 7 búsqueda instrucción (2)
9
3
0
S
12
A
P
25
25
12
3
SUM 6
LECM
CAR 5
SUM 6
ALM 7
I
ALM 7
T
E
© MRA, 2000
23
ALM 7 búsqueda instrucción (3)
9
3
0
S
12
A
P
25
25
12
3
ALM 7
CAR 5
SUM 6
ALM 7
I
ALM 7
T
E
© MRA, 2000
24
ALM 7 ejecución instrucción (1)
9
3
0
S
12
A
P
7
24
12
3
ALM 7
CAR 5
SUM 6
ALM 7
I
ALM 7
T
E
© MRA, 2000
25
ALM 7 ejecución instrucción (2)
9
3
0
S
12
A
P
7
24
12
3
ALM 7
CAR 5
SUM 6
ALM 7
I
12
T
E
© MRA, 2000
26
ALM 7 ejecución instrucción (3)
9
3
12
S
12
A
P
7
24
12
3
ALM 7
ESCM
CAR 5
SUM 6
ALM 7
I
12
T
E
© MRA, 2000
27
ALM 7 preparación instrucción siguiente
9
3
12
S
12
A
INCP
P
7
25
12
3
ALM 7
CAR 5
SUM 6
ALM 7
I
12
T
E
© MRA, 2000
28
ESC 7 búsqueda instrucción (1)
9
3
12
S
12
A
P
26
26
12
3
SUM 6
SUM 6
ALM 7
ESC 7
I
12
T
E
© MRA, 2000
29
ESC 7 búsqueda instrucción (2)
9
3
12
S
12
A
P
25
25
12
3
SUM 6
LECM
SUM 6
ALM 7
ESC 7
I
ESC 7
T
E
© MRA, 2000
30
ESC 7 búsqueda instrucción (3)
9
3
12
S
12
A
P
25
25
12
3
ESC 7
SUM 6
ALM 7
ESC 7
I
ESC 7
T
E
© MRA, 2000
31
ESC 7 búsqueda operando (1)
9
3
12
S
7
A
P
7
25
7
ESC 7
SUM 6
ALM 7
ESC 7
I
ESC 7
T
E
© MRA, 2000
32
ESC 7 búsqueda operando (2)
9
3
12
S
7
A
P
7
25
7
ESC 7
LECM
SUM 6
ALM 7
ESC 7
I
12
T
E
© MRA, 2000
33
ESC 7 ejecución instrucción (1)
9
3
12
S
12
A
P
7
25
12
3
ESC 7
SUM 6
ALM 7
ESC 7
I
12
12
T
E
© MRA, 2000
34
ESC 7 ejecución instrucción (2)
9
3
12
S
12
A
P
7
25
12
3
ESC 7
SUM 6
ALM 7
ESC 7
I
12
12
T
E
12
© MRA, 2000
35
ESC 7 preparación instrucción siguiente
9
3
12
S
12
A
INCP
P
7
26
12
3
ESC 7
SUM 6
ALM 7
ESC 7
I
12
12
T
E
12
© MRA, 2000
36
MUL 6 búsqueda instrucción (1)
9
3
12
S
12
A
P
26
26
12
3
ESC 7
ALM 7
ESC 7
MUL 6
I
12
12
T
E
12
© MRA, 2000
37
MUL 6 búsqueda instrucción (2)
9
3
12
S
12
A
P
26
26
12
3
ESC 7
LECM
ALM 7
ESC 7
MUL 6
MUL 6
I
12
T
E
12
© MRA, 2000
38
MUL 6 búsqueda instrucción (3)
9
3
12
S
12
A
P
26
26
12
3
MUL 6
ALM 7
ESC 7
MUL 6
MUL 6
I
12
T
E
12
© MRA, 2000
39
MUL 6 búsqueda operando (1)
9
3
12
S
12
A
P
6
26
12
3
MUL 6
ALM 7
ESC 7
MUL 6
MUL 6
I
12
T
E
12
© MRA, 2000
40
MUL 6 búsqueda operando (2)
9
3
12
S
12
A
P
6
26
12
3
MUL 6
LECM
ALM 7
ESC 7
MUL 6
3
I
12
T
E
12
© MRA, 2000
41
MUL 6 búsqueda operando (3)
9
3
12
S
12
A
P
6
26
12
3
MUL 6
ALM 7
ESC 7
MUL 6
3
I
12
T
E
12
© MRA, 2000
42
MUL 6 ejecución instrucción
9
3
12
S
A
36
P
MULT
12·3
36
3
6
26
MUL 6
ALM 7
ESC 7
MUL 6
3
I
12
T
E
12
© MRA, 2000
43
MUL 6 preparación instrucción siguiente
9
3
12
S
36
A
INCP
P
6
27
36
3
MUL 6
ALM 7
ESC 7
MUL 6
3
I
12
T
E
12
© MRA, 2000
44
ALM 8 búsqueda instrucción (1)
9
3
12
S
36
A
P
27
27
36
3
MUL 6
ESC 7
MUL 6
ALM 8
3
I
12
T
E
12
© MRA, 2000
45
ALM 8 búsqueda instrucción (2)
9
3
12
S
36
A
P
27
27
36
3
MUL 6
LECM
ESC 7
MUL 6
ALM 8
ALM 8
I
12
T
E
12
© MRA, 2000
46
ALM 8 búsqueda instrucción (3)
9
3
12
S
36
A
P
27
27
36
3
ALM 8
ESC 7
MUL 6
ALM 8
ALM 8
I
12
T
E
12
© MRA, 2000
47
ALM 8 ejecución instrucción (1)
9
3
12
0
S
36
A
P
8
27
36
3
ALM 8
ESC 7
MUL 6
ALM 8
ALM 8
I
12
T
E
12
© MRA, 2000
48
ALM 8 ejecución instrucción (2)
9
3
12
0
S
36
A
P
8
27
36
3
ALM 8
ESC 7
MUL 6
ALM 8
36
I
12
T
E
12
© MRA, 2000
49
ALM 8 ejecución instrucción (3)
9
3
12
36
S
36
A
P
8
27
36
3
ALM 8
ESCM
ESC 7
MUL 6
ALM 8
36
I
12
T
E
12
© MRA, 2000
50
ALM 8 preparación instrucción siguiente
9
3
12
36
S
36
A
INCP
P
8
28
36
3
ALM 8
ESC 7
MUL 6
ALM 8
36
I
12
T
E
12
© MRA, 2000
51
ECA 8 búsqueda instrucción (1)
9
3
12
36
S
36
A
P
28
28
36
3
ALM 8
MUL 6
ALM 8
ECA 8
36
I
12
T
E
12
© MRA, 2000
52
ECA 8 búsqueda instrucción (2)
9
3
12
36
S
36
A
P
28
28
36
3
ALM 8
LECM
MUL 6
ALM 8
ECA 8
ECA 8
I
12
T
E
12
© MRA, 2000
53
ECA 8 búsqueda instrucción (3)
9
3
12
36
S
36
A
P
28
28
36
3
ECA 8
MUL 6
ALM 8
ECA 8
ECA 8
I
12
T
E
12
© MRA, 2000
54
ECA 8 búsqueda operando (1)
9
3
12
36
S
36
A
P
8
28
36
3
ECA 8
MUL 6
ALM 8
ECA 8
ECA 8
I
12
T
E
12
© MRA, 2000
55
ECA 8 búsqueda operando (2)
9
3
12
36
S
36
A
P
8
28
36
3
ECA 8
LECM
MUL 6
ALM 8
ECA 8
36
I
12
T
E
12
© MRA, 2000
56
ECA 8 ejecución instrucción (1)
9
3
12
36
S
36
A
P
8
28
36
3
ECA 8
MUL 6
ALM 8
ECA 8
36
I
36
T
E
12
© MRA, 2000
57
ECA 8 ejecución instrucción (2)
9
3
12
36
S
36
A
P
8
28
36
3
ECA 8
MUL 6
ALM 8
ECA 8
36
I
36
T
E
12
$
CARACT
© MRA, 2000
58
ECA 8 preparación instrucción siguiente
9
3
12
36
S
36
A
INCP
P
8
29
36
3
ECA 8
MUL 6
ALM 8
ECA 8
36
I
36
T
E
12
$
© MRA, 2000
59
S
A
P
I
T
E
© MRA, 2000
60
!
" #$ % & '
( )
) '
*+
,
-
*+
" " ) ,
) *+
) '
,
'
.
,
,
) "
" *+
) " , '
, & / ,0 , * '
+
" 1 '
) 1 " * '
+ 2 " " ( '
)
& *+
* & *+
*+
'
*" .
+ * * + 61 3
4
3) * 3 - 3
5
6
7
!
9
;
%
!
% &
($
8 :
($
,
'
,
1 1
*
62 5
( '
<
&
( + + . ! 2 . + + " '
*
+ + '
'
,
" '
*" =
+
/0
>
>
< >
< ?@>
,/A B
)
,/ACA" D0>
A0>
,/?@> > EE0
,/A C )A" 0>
,/AC,A" D0>
E? >
,/A B-? C, A" F0>
+ & 2 & + *+
1 !
/
0 * 5 + " *+
,
" &
636
4
5) *+
# 1 " /
*
60 '
" &
" 1 - !
& '
+ + ,
" $ %
& $
&
"
* 7 '
' 2 " + 1 "
# ( * )
3 G 647
4
6) 4
7) H
!
65
5 ,
- !
6 * " " 7 *
9
66
PRÁCTICA : Área de un polígono regular
Realizar un programa que calcule el área de un polígono regular de n lados.
Calcule el área aproximada del circulo con n suficientemente grande.
Nota:
•
El área de un polígono regular : perímetro * apotema /2
•
apotema= mínima distancia entre el centro del polígono y un lado.
67
PRÁCTICA 3: Bifurcaciones y Bucles en Lenguaje C
Práctica
Bifurcaciones y Bucles en Lenguaje C
1 .- INTRODUCCIÓN
Se pide realizar un programa que calcule la factorización de un número introducido
desde teclado, y que presente por pantalla el máximo factor primo obtenido. Se
entiende por factorización de un número, el conjunto de numeros primos por el que es
divisible, incluyendo aquellos que se repiten y el 1.
Ej: 20 = 1 · 2 · 2 · 5
maxfactor = 5
2 .- DESARROLLO DE LA PRÁCTICA
El programa estará estructurado de la siguiente forma:
a) Función main:
-
En ella se declararán la variable que contendrá el numero introducido desde
teclado, y la variable que contendrá el máximo factor primo (maxfactor).
Declare las variables auxiliares que necesite y siga la plantilla de la página
siguiente.
Se recomienda que la factorización se realice usando un bucle que calcule el número
primo menor por el que es divisible empezando a probar con el 2. A continuación se
dividirá el número original por el divisor calculado y con el número resultante se
volverá a repetir el proceso. Así hasta que el número sea 1, que será justamente el
divisor más pequeño.
Ej: 20 -> es divisible por 2 -> 20/2 = 10
10 -> es divisible por 2 -> 10/2 = 5
5 -> es divisible por 5 -> 5/5 = 1
69
PRÁCTICA 3: Bifurcaciones y Bucles en Lenguaje C
3. - PLANTILLA
#include <
>
void main(void)
{
int numero;
int maxfactor;
int divisor;
do
{
printf("Introduzca número mayor que 1:\t");
scanf(
);
}
while(numero<2);
divisor = 2;
while (
{
...........
)
......
}
maxfactor = ......
printf( “
“, maxfactor );
}
70
PRÁCTICA 3: Bifurcaciones y Bucles en Lenguaje C
Diagrama de Flujo
71
PRÁCTICA 2: INTRODUCCIÓN AL USO DE FUNCIONES
Práctica
Introducción al Uso de Funciones en Lenguaje C
1 .- INTRODUCCIÓN
Se pide realizar un programa que calcule la factorización de un número introducido
desde teclado, y que presente por pantalla el máximo factor primo obtenido. Se
entiende por factorización de un número, el conjunto de numeros primos por el que es
divisible, incluyendo aquellos que se repiten y el 1.
Ej: 20 = 1 · 2 · 2 · 5
maxfactor = 5
2 .- DESARROLLO DE LA PRÁCTICA
El programa estará estructurado de la siguiente forma:
a) Función main:
- En ella se declararán la variable que contendrá el numero introducido desde
teclado, y la variable que contendrá el máximo factor primo (maxfactor).
-Desde la función main se llamará a otra función, denominada factoriza, que
deberá calcular dicha factorización y modificar el contenido de maxfactor.
b) Función factoriza:
-La función factoriza recibirá como parámetros un número entero que se
almacenará en la variable num y la dirección de la variable maxfactor que será
almacenada en un puntero denominado pfactor.
-La función factoriza no devuelve nada.
A continuación se muestra el prototipo de la función.
void factoriza(int num, int * pfactor);
Se recomienda que la factorización se realice usando una función que calcule el número
primo menor por el que es divisible empezando a probar con el 2. A continuación se
dividirá el número original por el divisor calculado y con el número resultante se
volverá a repetir el proceso. Así hasta que el número sea 1, que será justamente el
divisor más pequeño.
Ej: 20 -> es divisible por 2 -> 20/2 = 10
10 -> es divisible por 2 -> 10/2 = 5
5 -> es divisible por 5 -> 5/5 = 1
73
Las notas saldrán el día 21 de Junio de 2002 a las 21:00.
Hoja 3/6
PRÁCTICA 2: INTRODUCCIÓN AL USO DE FUNCIONES
3. - PLANTILLA
#include <
>
void factoriza(
void factoriza(int num, int *pfactor)
{
);
void main(void)
{
int numero;
int maxfactor;
do
{
printf("Introduzca número mayor que 1:\t");
scanf(
);
}
while(numero<2);
factoriza(
printf( “
);
“, maxfactor );
}
}
74
Las notas saldrán el día 21 de Junio de 2002 a las 21:00.
Hoja 5/6
PRÁCTICA
VECTORES Y CADENAS DE CARACTERES
Se quiere hacer un programa que ordene por orden alfabético los elementos de una
cadena de caracteres dada (origen) y los almacene en otra cadena (destino).
Ejemplo:
cfaebd
abcdef
Para ello será necesario:
1.- Determinar el número de caracteres de la cadena. Vamos a suponer que no
conocemos el número de caracteres de la cadena origen. Habrá que hacer un bucle para
buscar el cero en la cadena e ir contando los elementos que forman la cadena.
2.- Comparar los caracteres. El criterio de comparación viene dado de forma
automática por el código ASCII. Luego el carácter 'a' (97) es menor que 'b' (98).
3.- Ordenar los caracteres. Para ordenar los caracteres habrá que buscar el más
pequeño de todos y ponerlo en primer lugar. Descartando este primer carácter para la
siguiente búsqueda, daremos con el segundo más pequeño, y así sucesivamente.
Existen varias formas de resolver el problema. Se permite escribir sobre la cadena
origen para descartar los elementos ya ordenados.
Se pide:
a) Hacer el diagrama de flujo de cada una de las partes.
b) Codificar el algoritmo resultante en lenguaje C.
Nota: Por sencillez las cadenas de caracteres se declararán de la siguiente forma:
char origen[]="cfaebd";
char destino[10];
75
PRÁCTICA 4: Multiplicación de Matrices con notación vectorial
Práctica
Multiplicación de Matrices con notación vectorial
1 .- INTRODUCCIÓN
Se pide realizar un programa que calcule la multiplicación de 2 matrices.
Los datos de ambas matrices serán introducidos desde teclado, y el resultado de la
multiplicación deberá ser mostrado en pantalla.
El objetivo de esta práctica consiste en hacer que el alumno use la asignación
dinámica de memoria y aprenda a realizar el paso de parámetros a funciones.
2 .- DESARROLLO DE LA PRÁCTICA
El programa estará estructurado de la siguiente forma:
a) Función main:
- Se declararán los elementos necesarios para almacenar de forma dinámica y
mediante notación vectorial, las matrices a multiplicar y la matriz resultado.
- Se llamará a la función leematriz para introducir los datos de la primera
matriz: nº de filas, nº de columnas y elementos.
- Se llamará a la función leematriz para introducir los datos de la segunda
matriz: nº de filas, nº de columnas y elementos.
- Se llamará a la función multiplicamatriz.
- Se llamara a la función escribematriz.
b) Función leematriz: la función leematriz recibirá las direcciones de dos variables
enteras que guardarán el número de filas y de columnas de las matriz dato. El número
de filas y de columnas, así como los distintos elementos de la matriz serán introducidos
desde esta función.
Su prototipo será: int * leematriz( int *nf, int *nc);
En esta función se hará la reserva dinámica de memoria asignada a la matriz dato y se
devolverá la dirección de memoria de comienzo a la función principal, para que pueda
ser usada por el resto de funciones.
c) Función multiplicamatriz: la función multiplicamatriz recibirá las direcciónes de las
dos matrices datos. También recibirá los números de filas y de columnas.
Su prototipo será:
int * multiplicamatriz(int * pmat1,int * pmat2, int nf1,int nc1,int nc2);
En esta función, se reservará espacio de forma dinámica para la matriz resultado.
Posteriormente se calculará la multiplicación de las dos matrices, y el resultado se
77
PRÁCTICA 4: Multiplicación de Matrices con notación vectorial
almacenará en el espacio reservado para la matriz resultado. La función devolverá la
dirección de comienzo de la matriz resultado a la función principal.
d) Función escribematriz: la función escribe matriz recibirá la dirección de comienzo
asignada a la matriz resultado, así como el número de filas y de columnas.
Su prototipo será: void escribematriz(int * pmatriz, int nf, int nc);
#include <stdio.h>
#include <stdlib.h>
int * leematriz( int *nf, int *nc);
int * multiplicamatriz(int * pmat1,int * pmat2, int nf1,int nc1,int nc2);
void escribematriz(int * pmatR, int nf, int nc);
void main(void)
{
int *pmat1,*pmat2,*pmatR;
int nf1,nc1,nc2;
pmat1=leematriz( &nf1, &nc1);
pmat2=leematriz( &nc1, &nc2);
pmatR=multiplicamatriz(pmat1,pmat2,nf1,nc1,nc2);
escribematriz(pmatR, nf1, nc2);
}
int * leematriz( int *nf, int *nc)
{
int *pmat;
int i,j;
printf("Introduzca nº de filas de la matriz:\n");
scanf("%d",nf);
printf("Introduzca nº de columnas de la matriz:\n");
scanf("%d",nc);
pmat=(int *)malloc((*nf)*(*nc)*sizeof(int));
if(pmat==NULL)exit(1);
for(i=0;i<(*nf);i++)
{
for(j=0;j<(*nc);j++)
{
printf("Introduzca el elemento [%d][%d]: ",i,j);
scanf("%d",pmat+i*(*nc)+j);
}
}
return pmat;
}
78
PRÁCTICA 4: Multiplicación de Matrices con notación vectorial
void escribematriz(int * pmatR, int nf, int nc)
{
int i,j;
for(i=0;i<nf;i++)
{
printf("\n");
for(j=0;j<nc;j++)
{
printf("%d ",pmatR[i*nc+j]);
}
}
printf("\n");
}
int * multiplicamatriz(int * pmat1,int * pmat2, int nf1,int nc1,int nc2)
{
int *pmat;
int i,j,k;
pmat=(int *)malloc(nf1*nc2*sizeof(int));
if(pmat==NULL)exit(1);
for(i=0;i<nf1;i++)
{
for(j=0;j<nc2;j++)
{
*(pmat+i*nc2+j)=0;
for(k=0;k<nc1;k++)
{
*(pmat+i*nc2+j)=*(pmat+i*nc2+j)+pmat1[i*nc1+k]*pmat2[k*nc2+j];
}
}
}
return pmat;
}
79
Fundamentos de Informática. Primer Curso de Ingenieros Químicos
Práctica
Funciones de entrada/salida de ficheros
1
Introducción
El objeto de la presente práctica es permitir al alumno ensayar y familiarizarse con las
funciones de entrada y salida, para ficheros de texto y binario, que se han desarrollado en las
clases teóricas de lenguaje C de la asignatura.
Para ello se hará uso del programa TURBO C, que permitirá editar, compilar y montar
programas desarrollados en el lenguaje de programación C.
Consejo: se deben traer los apuntes de la asignatura para la realización de la práctica.
2 Desarrollo de la Práctica
Se pretende hacer un programa que calcule la nota media de un alumno a partir de 2 notas
que se encuentran en un fichero binario.
El programa tendrá la siguiente estructura:
-
-
-
En la función principal (main) deberá aparecer un menú con 3 opciones.
Opción 1: Introducir dato. Deberá llamarse a una función que denominaremos
introducir, la cual permitirá al usario introducir el nombre del alumno y 2 notas.
Esta información se guardará en un archivo binario cuyo nombre será notas.dat.
El fichero se debe abrir para añadir datos nuevos.
Opción 2: Presentar. Deberá llamarse a una función que denominaremos
presentar. El programa deberá mostrar por pantalla la lista completa de alumnos,
indicando la nota media y la palabra APROBADO o SUSPENSO. Esta
información se calculará a partir de las notas contenidas en el fichero binario
anterior.
Opción 3: Salir. Esta opción ha de finalizar la ejecución del programa.
Para la edición del programa se da una plantilla que habrá que completar.
Además de las funciones antes mencionadas, se ha introducido una función para realizar la
lectura de diversos elementos de un fichero binario. Dicha función se llama leebinario y
devolverá un 1 si la lectura se ha realizado con éxito.
811
Fundamentos de Informática. Primer Curso de Ingenieros Químicos
/**************************************/
/*
LECTURA Y ESCRITURA
*/
/*
EN FICHERO
*/
/**************************************/
#include <stdio.h>
#include <stdlib.h>
void introducir(void);
void presentar(void);
int leebinario(char *nombre,float *nota1,float *nota2,FILE *pf);
void main(void)
{
...... opcion;
do
{
printf("\nElija opcion:");
printf("\n\t1. Introducir dato\n\t2. Presentar\n\t3. Salir\n");
scanf(.........);
switch (opcion)
{
case ...: introducir(); break;
case ...: presentar(); break;
case ...: break;
default: printf("\nopcion incorrecta");
}
}
while(opcion !=....);
}
/**************************************/
/*
Introduccion de datos
*/
/**************************************/
void introducir(void)
{
FILE *pf;
char nombre[10];
float nota1,nota2;
pf = fopen("notas.dat", "....");
if(pf == NULL)
{
printf("\nNo se puede abrir archivo\n");
exit(1);
}
printf("\nIntroduce Nombre:\t");
scanf(............,.........);
/* nombre */
printf("\nIntroduce Nota1:\t");
scanf(............,.........);
/* nota1 */
printf("\nIntroduce Nota2:\t");
scanf(............,.........);
/* nota2 */
fwrite(.........................................); /* nombre */
fwrite(.........................................); /* nota1 */
fwrite(.........................................); /* nota2 */
fclose(pf);
}
82
2
Fundamentos de Informática. Primer Curso de Ingenieros Químicos
/**************************************/
/*
Presenta datos
*/
/**************************************/
void presentar(void)
{
float nota1,nota2,media;
char nombre[10];
FILE *pf;
pf= fopen("notas.dat", "....");
if(pf == NULL)
{
printf("\nNo se puede abrir archivo\n");
exit(1);
}
while(leebinario(....,......,......,......))
{
media=..............;
if(media<5)
{
printf("...........\.tSUSPENSO\n", nombre,media);
}
else
{
printf("...........\tAPROBADO\n", nombre,media);
}
}
fclose(pf);
}
int leebinario(char *nombre,float *nota1,float *nota2,FILE *pf)
{
int salida=1;
salida*=fread(.....,10*sizeof(char),1,....);
/* nombre */
salida*=fread(....,sizeof(.......),1,....);
/* nota1 */
salida*=fread(....,sizeof(.......),1,....);
/* nota2 */
return salida;
/* si funciona bien devuelve un 1 */
}
83
87