TEMA 1: CONCEPTOS BÁSICOS

Introducción: Informática, sistemas de información, abstracción.

1.1. Autómata, programas, máquina (virtual, física, programable), cómputo, computador, hardware, software. Máquina de von Newman.

Algoritmo (definición, ejemplo)

Programación, ingeniería de software.

Introducción al lenguaje C.

INTRODUCCIÓN

• Informática-Ciencia: Estudia lo referente al procesamiento automático de información.

• Informática-Técnica: Teoría, diseño, fabricación y uso de computadores.

• Sistemas de Información:

DATOS! se le aplica ! PROCESO ! genera!INFORMACIÓN

! ! !

antecedentes acciones como un aumento en los

necesarios para la reunión, selección conocimientos derivado

tener conocimientos cálculo o escritura del análisis de datos.

exacto de algo

(cantidades, cualidades

o hechos).

Al proceso de automatizar la información generada por la aplicación de un proceso a una serie de datos, se le llama Informática.

• Abstracción: Proceso mental que consiste en que un determinado proceso u objeto realiza un estudio basado en dos aspectos

Complementarios.

• destacar detalles relevantes e ignorar los irrelevantes.

• Buscar los relevantes e irrelevantes.

Para conseguir información no es posible analizarlo todo de golpe. Hay que tener en cuenta que lo más importante, lo esencial para uno no lo es para otro.

Este proceso se estructura siempre en nivel jerárquico de forma que para un determinado nivel unas cosas pueden ser relevantes y en otro no.

La utilidad básica está en reducir la complejidad de los problemas, de forma que se pueden estudiar y manipular con mayor facilidad.

AUTÓMATAS:

MÁQUINA: Dispositivo capaz de realizar un trabajo. No tiene porque ser físico (virtuales).

El primero en intentar construirla fue Babbage. Se clasifican en:

• No Automáticas: necesita un estímulo externo constante para operar (máquina de escribir)

• Automática: necesita de un estímulo mínimo externo para realizar un trabajo más o menos complejo. Se clasifican en:

• No programables: si siempre realiza la misma operación.

• Programable: si es capaz de realizar diferentes operaciones dependiendo de un programa que lo gobierna.

Una máquina automática es igual que una autómata. Esta consta de:

• Parte fija: Hardware

• Parte variable: Software.

BASE: Es la estructura de von Newman. Las máquinas autómatas de tipo ordenador se han desarrollado en base a esta estructura con estos elementos.

ALGORITMO: Una sucesión finita de instrucciones que describen con precisión como resolver todos los problemas de un mismo tipo.

Si un algoritmo es la descripción de los pasos en un computador abstracto, un programa será lo mismo en un computador determinado.

PROGRAMACIÓN E INGENIERIA DEL SOFTWARE.

Programación: Es la disciplina de la informática, que estudia las técnicas involucradas en el desarrollo del programa.

Los programas se dividen en 2 géneros: programación a pequeña escala y a gran escala (IS).

FASES de la programación:

Problema.

Elaboración o análisis de requerimiento: proceso que conduce desde el problema a la especificación.

Especificación: Representación del problema que de alguna forma indique el comportamiento deseado del programa. ¿Qué?

Diseño: Proceso que conduce desde la especificación hasta la implementación. ¿Cómo?

Implementación: Descripción de algoritmo, lenguaje genérico que explica como pasar de los datos que tengo al resultado que quiero.

Codificación: Proceso en el cual se obtiene el programa a partir de la implementación.

Análisis: Ver si la solución es la correcta.

Tres puntos a tener en cuenta a partir de la creación de un programa.

Corrección del algoritmo: si la implementación corresponde con la especificación, el algoritmo es correcto.

Eficiencia: hay que buscar si mi solución es suficientemente eficiente dentro de las que he encontrado. Debe ser ésta la que elijamos.

Claridad: Se pone al mismo nivel de la eficiencia. El programa debe ser correcto, eficiente y claro.

TEMA 2: TIPOS Y EXPRESIONES

2.1 Lexemas.

Tipos de datos.

Constantes y variables.

Tipos escalares.

Tipo real.

Expresiones.

Operadores de evaluación perezosa y sobrecarga de operadores.

Conversores de tipo.

Tipos y expresiones en C.

LEXEMA:

Alfabeto: Conjunto finito y no vacío de elementos, los cuales son llamados símbolos del alfabeto, y se llamará lexema a la unidad indivisible y mínima con significado en el lenguaje que se construya mediante una sucesión finita de símbolos.

Ej: a, a,....a

"={0,1,2,3,4,5,6,7,8,9,+,-}

Lexemas: combinación de esos elementos que tengan significado.

Ej: +3 , +1, -3, 258, 5+3-9 no.

Admitiremos que determinados lexemas estén sobrecargados, es decir que sirvan para más de un fin.

Lexemas que utilizaremos:

Identificadores: Nombres dados a los elementos del programa. Deben

Empezar por una letra y estar formados por letras, dígitos y símbolos de subrayado. Se escriben en minúscula.

Palabras reservadas: Conjunto de identificadores utilizado para uso

Exclusivo y privado por el lenguaje y no se puede utilizar para otro fin.

Se le asigna un código (negrilla)

Literales: Denotan valores concretos de los elementos computables.

Símbolos de operación: Indican operaciones que son válidas entre elementos de mi programa. Ej 14 +7. ( L+ O + L)

Separadores: Lexemas constituidos por uno o varios símbolos de puntuación. Ej. ., ; espacios blancos y líneas no significan nada.

TIPOS DE DATOS

Son las distintas clases de valores. Se define como un par (L, O) donde L es un conjunto de lexemas de tipo literal o literales y/o un conjunto de lexemas que llamaremos símbolos de operación.

Ej: L: conjunto enteros E:{ +, -, 0......9}

Para cada tipo de dato hay que dar la siguiente información: que llamaremos signatura o perfil, dominio-rango y condiciones. La signatura de una operación es una notación que representa el símbolo de la operación y el número de parámetros.

• Dominio- Rango: Refleja el significado de la operación, indicando la correspondencia entre el dominio de los argumentos que se operan y el rango que indicaría el resultado que se puede obtener.

• Condiciones- definición: Serán predicados o expresiones lógicas que establecen qué condiciones deben cumplir los elementos del dominio para que tengan imagen.

Si para todos los valores del dominio tienen imagen diremos que la operación es total y el predicado, entonces, será cierto. Si no, diremos que es parcial y especificaremos cuando no tiene imagen.

DECLARACIÓN DE TIPOS DE DATOS: Va a ser un enunciado que establece un vínculo entre un especificador y un tipo.

Tipos: A la izda. pondremos el identificador del tipo y a la derecha

T1: c1 constructores apropiados.

T2: c2 Habitualmente pondremos la T mayúscula para establecer un tipo.

..... Tnota_media: (", 10)

Tn: cn

CONSTANTES Y VARIABLES

Constante: Es un indicador que denota uno y sólo uno de los literales de un tipo. Datos que no se pueden modificar durante la ejecución. Da mayor claridad al código sustituyendo valores por dichas constantes o se puede usar cuando un valor (IVA: 16%) puede variar con el tiempo y basta con variar el nº de IVA en vez de cambiar el algoritmo. Por extensión a los literales de determinados valores.

• Declaración de constante: Al establecimiento del vínculo entre el identificador y el literal del tipo correspondiente. Las declararemos en una sección del programa que se llamará CONSTANTE o CONs y escribiremos a la izquierda la c1: I1 donde c1: identificadores, I1 literales.

Variables: Va a ser por el contrario, elementos que pueden modificar su valor durante la ejecución, por lo tanto su valor dependerá del estado actual del algoritmo. Se representará con un identificador. Irán tomando valores a lo largo del algoritmo.

• Declaración de variable: Se hará estableciendo un vínculo entre un tipo de dato y un identificador. En una sección que se llamará var. (idem cons).

Con el separador coma, podemos declarar variables del mismo tipo a la vez.

Con el punto y coma, de distinto tipo en la misma línea.

ELABORACIÓN LINEAL DE DECLARACIONES:

No se puede utilizar en una declaración, ningún elemento que no haya sido previamente declarado. Primero se declararán constantes, tipos y variables, siempre que sea posible.

Tipos de valores:

- Escalar: Cuando es posible definir un conjunto de literales indicando uno a uno sus elementos.

- Enumerado: Además de ser escalar tiene una ordenación estricta u orden total que se puede establecer si existe un valor máximo y un mínimo y dos operaciones (sucesor y predecesor).

Condiciones para establecer tipo enumerado:

• Todos los literales deben de ser distintos. ei" ej si i" j.

• Para todos los ei debe ser menor que ej si i< j.

• Sólo pertenecen a Te los ei....en, si 1" i"n

Operaciones asociadas a este tipo enumerado

L={e1,....en} conjunto de literales

Conjunto de operaciones: O:{suc, pred}

De manera que las operaciones son:

Descripción	Perfil	Condiciones
sucesor	Suc (_): Te!Te	Def (suc(e))"e " en
Predecesor	pred (_): Te!Te	Def (pred(e))"e " e1

Suc (ei): ei+1

Pred (ei): ei-1

Tdias semana (lunes, martes.....domingo)

Tipos clásicos:

• Enteros: Suponemos que se puede operar en el intervalo (-", +"), sin tener en cuenta las sobrecargas. Hacemos el conjunto L para los números enteros.

L={..., -2, -1, 0,1,2...} En LEA no podemos escribir infinito

Operaciones:

O={+,-,*, /, ^, %, -}

• Lógico: El que nos permite establecer condiciones sobre los estados actuales de un algoritmo.

Logico:{falso, cierto) además es un tipo enumerado.

Operaciones:{No, Y, O}

Descripción	Perfil	Condiciones
Negación	No: logico!logico	Def (No a)"cierto
Conjunción	_ Y_:logico x logico!logico	Def (a Y b)"cierto
Disyunción	_ O_:logico x logico!logico	Def (a O b)"cierto

• Tipo real: Se denota mediante el punto fijo. Distinguiendo un conjunto e y un conjunto d: e.d= 2.54

Pero como entre 2 números reales hay infinitos el 2.54 se refiere al (2.54, 2.55). Si lo queremos poner en forma exponencial:

Ej 2.54. 10-10 = 2.54e-10

Operaciones: Idem entero.

EXPRESION:

Es una composición bien formada de operandos (variables y constantes) y operadores de tipo conocido. Hay que distinguir dos aspectos.

- sintáctico: si está correctamente expresado.

- semántico: significado de cada operación.

SEMÁNTICA DE UNA EXPRESIÓN: El valor de un literal será el propio literal. Si tenemos una constante simbólica el valor se tomará de la definición , el de una variable del contenido actual para el estado del algoritmo y el valor de la operación es el resultado que evaluamos.

N*Iva +2

8x16+2= Resultado de las operaciones.

El problema surge cuando se mezclan operaciones. Tendremos que seguir unas normas de prioridad. Lo haremos:

• Explícitamente: Poniendo entre paréntesis lo que vamos a efectuar primero

• Implícitamente: Por el mecanismo de prioridad de operaciones. Si esto no es suficiente, aplicaremos la regla de asociatividad.

Tabla de prioridad

Operador	Asociatividad
- (opuesto)	Derecha
^	Derecha
*, /, %	Izquierda
+, -	Izquierda
<, <=, >, >=, < >	Izquierda
=	Izquierda
Y, O	Izquierda

Funciones predeclaradas: Permiten que el código sea más fácil.

Operaciones relacionables: Indican cual es el orden de mis valores, si están delante o detrás.

Expresiones lógicas: son expresiones que evalúan datos o resultados que nos van a dar como resultado, un resultado lógico.

Evaluación perezosa de los operadores:

Tenemos l1 y l2, si li es falso:

x Y y	Y perezoso
C C	C
C F	F
F C	¿
F F	¿

Determinados operadores como Y, O pueden dar fallos al compilar.

La evaluación perezosa hace que pierdan sus propiedades.

Sobrecarga de operadores: Si se aplica un operador a expresiones de tipos diferentes.

Conversión de tipo:

Funciones que permiten cambiar tipos. La función se aplica sobre un tipo y devuelve otro. Solamente entre real y entero admitiremos el cambio automáticamente. Cuando esto sucede se llama tipificación débil.

Ej 3+5.0

Real (3)+5.0

TEMA 3: NOTACIÓN ALGORÍTMICA

3.1 Especificación de algoritmos

3.1.1 Introducción a la lógica de 1º orden

3.1.2 Especificación pre-post

3.2 Implementación de algoritmos

3.2.1 Instrucciones simples

3.2.2 Instrucciones compuestas

Composición secuencial

Composición selectiva

Composición iterativa

Entrada y Salida

Estructura central en C

Entrada y salida en C

ESPECIFICACIÓN DE ALGORITMOS

Descripción del comportamiento deseado del mismo.

Requisitos esenciales:

• Precisión: Debemos ocuparnos de que no haya ambigüedades en el

algoritmo, si las hay nos encontramos con un problema

indeterminado.

• Claridad: Nuestro algoritmo debe ser entendido sin dificultad.

• Hay que sacrificar la claridad en aras de la precisión, el lenguaje que mejor cumple estos requisitos es el matemático.

INTRODUCCIÓN A LA LOGICA DE 1º ORDEN

Se basa en la construcción de términos y fórmulas . Admitiremos las operaciones lógicas normales.

!	Falso	No l
!	Cierto	L1 x>3

x!equivale a ø x " y. (no x o y)

x!y equivale (x!y) "(y!x)

X	Y	øx	ø x " y
Cierto	falso	falso	Falso
Cierto	cierto	falso	Cierto
Falso	falso	cierto	Cierto
Falso	cierto	cierto	Cierto

C.CUANTIFICADOR: Abreviatura que indica una composición de operaciones análogas. Va a tener asociada una variable “ligada” y un dominio D: .

Ej : "x: D. (P(x))

X es una variable ligada dentro de un dominio, sobre una fórmula lógica.

C.Universal:

" i: 1" i " N-1 .(i< N)

C.Existencial: (falso): elemento neutro.

" x : D . (P(x)) asociado a la disyunción

" i: 1 " i " N. (i=N)

C.Sumatorio: (0) elemento neutro que devuelve cuando no estamos dentro del dominio.

" x: D. (expresión) asociado a la suma.

" i: 1 " i " N.(i)

C.Producto (1). Devuelve 1 si estamos fuera del rango.

 x: D. (E(x))

 i : 1 " i " N.(i)

Contador:N (0)

N x: D. (P(x)) ¿Cuántos elementos dentro del dominio cumplen la propiedad?

N i : (1 " i " N). (i%2=0)

C.Máximo (-") MAX

MAX x: D.(E(x))

MAX i: (1 " i " N)(i) ! N

C:Mínimo: (+")

MIN x: D.(E(x))

MIN i: (1 " i " N)(i) !1

ESPECIFICACIÓN PRE-POST

Un lenguaje de especificación mediante predicados que llamaremos precondiciones y postcondiciones mediante un lenguaje formal de la lógica matemática, que permite describir mediante fórmulas los estados por los que discurre en la ejecución del algoritmo.

Llamaremos coordenadas o parámetros de un algoritmo al conjunto de variables que necesitamos para su resolución y distinguiremos 2 tipos:

• argumentos o parámetros de entrada

• resultados o parámetros de salida.

Los denotaremos: ai : Tai (entrada)

ri: Tri (salida)

Para especificar un algoritmo tendremos que especificar el conjunto de estados iniciales válidos y el subconjunto de estados finales a los que conduce el algoritmo. Si especifico claramente los dos conjuntos, tengo especificado el algoritmo.

Precondición: Aserto o predicado sobre los argumentos que describen los estados iniciales válidos.

Precondición: Pre:{P(a1,a2.....an )

Pre:{ n"0}

Postcondición: Predicado sobre los argumentos y los resultados que indiquen cuales son los estados a los que conduce la ejecución del algoritmo.

Poscondición: Pos:{ Q(a1,a2.....an, r1,r2.......rm)

Ej: x,y,z: reales.

Pre:{x=X " y=Y}

Pos:{x=X+Y " z=Y+x}

x entrada/salida.

y entrada.

z salida.

IMPLEMENTACIÓN DE ALGORITMO.

Es la descripción de su comportamiento real y este lenguaje, nos permite

Detallar las transformaciones de estado necesarias para que desde el estado inicial lleguemos al estado final del algoritmo. Denominaremos instrucciones o sentencias a dichas transformaciones de estado.

En cada instrucción describiremos la sintaxis que reflejará el modo en que debemos escribir la instrucción y la semántica que reflejará el cambio de estado que implica ejecutar la instrucción.

TRAZA: El conjunto de estados por los que pasa el algoritmo durante la ejecución.

ai:Tai

ri:Tri

Pre: {Predicado ai}

Nombre del algoritmo

Pos: {Predicado Q sobre (a1,a2.....rm)}

Declaración de variables locales

Algoritmo

S={Conjunto de instrucciones}

INSTRUCCIONES

Simples: Suponen una única transformación de estado.

I.nula: sintaxis

Semántica: No modifica el estado del algoritmo

I.asignación: sintaxis: v:= E

Donde v: (parte izquierda) debe ser un identificador de variable

:= separador y E= (parte derecha) una expresión bien construida y del mismo tipo.

Semántica: se evalúa la expresión de E respecto al estado actual de las coordenadas produciendo un valor v.

Se sustituirá el valor que representa v por el nuevo valor.

E!v

Es muy importante porque nos permite esta evaluación:

V:= v+1

El lenguaje podrá decidir si su sintaxis es correcta o no. Admitimos la conversión de enteros reales en expresiones enteras. Si escribimos:

M, n : entero

M:= n+3.0

M:= truncar (real(n)+3.0) lo admitimos por defecto en la asignación

ASIGNACIÓN MÚLTIPLE

Sintaxis: < u1,u2....un>:= < e1, e2.....en>

Semántica: En el estado actual de las variables, se evalúan cada una de las expresiones y posteriormente se sustituyen los valores obtenidos en las variables correspondientes.

n,m : entero

Pre:{ n= N " m= M}

Intercambio

Pos:{n=M " m=N}

Algoritmo

< n, m> :=< m, n>

3.2.2.1 COMPOSICIÓN SECUENCIAL

Composición de instrucciones: Asociación de un conjunto de instrucciones.

Sintaxis: S1

S2

Sn

Semántica: Se ejecuta una detrás de otra (orden textual)

Composición de instrucciones selectiva:

Sintaxis: si

B1 :S1

B2: S2

Bn: Sn

Fsi

Semántica: Se evalúan todas las protecciones de la selección, tienen que ser todas correctas, se ejecuta la instrucción asociada a la que resulte cierta que solo será una, porque debe cumplirse que B1 U B2 .........Bn tiene que ser cierto y además Bi " Bj sea falso, a menos que i=j. Esto se llama determinismo o exhaustividad.

Exhaustividad : Al evaluar todas las protecciones al menos una debe ser verdadera. Poniendo “otras” , se garantiza la exhaustividad.

Determinismo: Se produce cuando no hay más de dos protecciones abiertas o verdaderas. Si no se cumple el determinismo, el programa acaba porque el algoritmo se bloquea.

Ej: Hacer un algoritmo para calcular 2 máximos enteros.

Var

A,b,r: entero

Pre:{cierto}

Máximo entre a y b

Pos:{(a " b ! r = a) " (a< b !r =b) }

x!"ø x " y

Implementación

Si

a " b : r:=a

a " b : r:=b

fsi.

Solución no determinista, no tiene el caso a=b.

Si

a >b : r:=a

a< b : r:=b

fsi

Solución no exhaustiva

Si

a>=b : r:=a

a< b : r:=b

fsi

Solución correcta

3.2.2.3 COMPOSICIÓN ITERATIVA O BUCLE

Sintaxis: mientras B (expresión lógica)

S(instrucciones)

Fmientras

Mientras que se cumple B, realizar S, hasta que falle B. Se realiza en tres pasos:

Evaluar B

Si B es cierto, ejecutar S. Vuelve a B.

Si B es falso, fin del bucle.

Ej: Dado un número n, sumar los n primeros números al cuadrado:

n, suma : entero

Pre: { n " 0}

Suma de los n primeros números al cuadrado

Pos: { suma=" k : 1 " k " n . (k2) } Cuando n=0, se devuelve el elemento neutro del sumatorio= 0.

Implementación:

Var n=4

k: entero

algoritmo.

k:=1; suma:=0

mientras k" n

suma:= suma +k^2

K:=k+1

fmientras

k	suma	K<=n?
1	0	Si
2	1	Si
3	5	Si
4	14	Si
5	30	no!fm

Invariantes: Predicado que describe el estado del algoritmo que tiene que cumplirse para dar una vuelta al bucle.

I"{ Suma: " i: 0.....k-1 . (i2)}

Cota: Función que devuelve un número entero y que dice el número de vueltas que quedan por dar en el bucle.

C"{ n-k+1 }

Esto asegura que el bucle no va a dar infinito.

EN LEA

desde variable:= valor inicial hasta valor final

S

fdesde

suma:= 0

desde k:= 1 hasta n

suma:= suma +k^2

fdesde

En C (desde)

for (v=valor inicial; v " valor final; v++)

{

S;

}

En C (mientras)

while (B)

{

S;

}

ENTRADA Y SALIDA

Scanf leer v1, v2...... vn vi variable {entero, real, carácter..}

Printf escribir e1, e2.....en ej expresión

DOCUMENTACIÓN

Comentarios: Frases que sirven para un mejor entendimiento del programa.

Estos comentarios no deben repetir lo que dice el algoritmo, la precondición y la poscondición se pueden considerar como comentarios. Se escriben entre /* comentario */.

TEMA 4: PROCEDIMIENTO Y FUNCIONES

4.1 Introducción

4.2 Abstracción operacional

4.3 Funciones

4.4 Procedimientos

4.5 Visibilidad

4.6 Diseño mediante refinamiento usando abstracciones.

4.1 INTRODUCCION

Abstracción es la representación de un objeto que oculta lo que podría considerarse irrelevante, haciendo de esta manera que el uso del objeto sea más fácil y dando relevancia a los conceptos y no a los detalles.

4.2 ABSTRACCION OPERACIONAL

El uso básico es para conseguir modular programas de forma que se puedan construir mediante operaciones que me permitan resolver programas complejos.

Aparece cuando un problema necesite repetidamente un algoritmo o cuando en un algoritmo se presentes diferentes problemas.

Este procedimiento genera algunas ventajas como:

• Resolución de problemas complejos.

• Mejorar la lectura y mantenimiento de los códigos

• Independizar la especificación y la implementación

• Reutilizar los algoritmos

• Ampliar repertorios de operaciones

• Materialización de la abstracción operacional

• Parametrización: Nos permite reunir un conjunto de expresiones e instrucciones en un objeto superior, de forma que tendremos acceso a ellas mediante un nombre simbólico y un conjunto de variables que llamaremos parámetros.

• Ocultación: Nos permite precisar el comportamiento del objeto según su especificación de manera que no necesitemos conocer su implementación.

Ej: factorial (n)!parámetros que necesita para resolverlo

!

nombre de la abstracción

F=  1 " i " m. (i)

4.3 FUNCIONES

Llamaremos funciones a una abstracción operacional en la que todos sus parámetros son de entrada excepto uno que será de salida. De tal forma que si una función llamada f, mediante la asignación la nombraremos r.

r:= f(a1,a2......an)

Nota: r tomará el valor que resuelva la función mediante la asignación.

F será el nombre simbólico

(a1......an) parámetros de entrada.

Ai: Tai

Ri: Tri ! r evalúa el resultado del tipo Tr.

Nosotros escribimos la función de la siguiente manera:

Prototipo! func f(a1: Ta1, a2:Ta2, .......an: Tan ) dev (r: Tr)

! ! !

palabra nombre simbólico nombre de parámetro de

reservada salida y tipo

Precondición! Pre: {P (a1.....an)}

Poscondición!Pos: {Q(a1.....an, r)} CABECERA

La función y el procedimiento no van a ser más que un algoritmo.

Cons"

Var " constantes y variables locales, puedo usarlas dentro de la función pero nunca fuera.

Principio

Sentencias CUERPO

Fin

Sintaxis:

Nombre_función (e1.....en)

ei: expresión que debe corresponder en el orden textual con los tipos correspondientes a los parámetros indicados en el prototipo.

Semántica:

Se evalúan cada una de las expresiones ei y se asignan a cada uno de los parámetros ai. Se ejecuta el conjunto de sentencias entre el principio y el fin del algoritmo y se devuelve el contenido en r cuando finalice le ejecución.

4.4 PROCEDIMIENTOS

Son una abstracción operacional que nos va a permitir una amplia variedad de posibilidades. Es un algoritmo diseñado de tal forma que puede ser llamado por otro. Si un algoritmo “a”, necesita de la acción de otro “b”, diremos que “a” llama a “b”. La llamada de un procedimiento se hará igual que antes con un nombre y un conjunto de expresiones ( e1...en) y un conjunto de variables (v1....vn). Pero no podrá ser asignado a una variable.

Nombre_proc (e1.....en, v1.....vn)

PARÁMETROS:

• Entrada: Podrá ser usado su valor pero no modificado.

• Salida: Sus valores no podrán ser usados pero si modificados a la salida del procedimiento.

• Entrada/ Salida: Sus valores podrán ser usados durante el procedimiento y a la salida del mismo.

Sintaxis: Proc + nombre del procedimiento + un conjunto de variables que van a ser de entrada, salida, entrada/salida.

Proc nombre_procedimiento (ent a1: Ta1, a2: Ta2.... an :Tan; sal r1: Tr1...

rm: Trm ; ent/sal b1: Tb1.... bk: Tbk)

Pre:{ P(a.......an ; b ........bk)}

Pos:{Q(a1....an; r1 ........rm; b1 ......bk )}

cons"

var "

principio

sentencias

fin

Semántica: Para llamar a un procedimiento se debe hacer:

Nombre_procedimiento (e1.......en, v1........vm , w1........wk)

Se evalúan los ei y se hace una asignación múltiple:

< a1......an >:=< e1.....en >

Los parámetros de entrada/salida se asignan a los otros.

< b1.....br >:=< w1........wr >

Se ejecutan las sentencias correspondientes.

Se toman los valores, se hacen los cálculos y se devuelven:

< v1.......vm >:=< r1.......rm >

< w1.......wr >:=<b1......br >

Ej: Proc intercambiar (ent/sal a, b: entero)

Pre:{a=A " b=B}

Pos:{a=B " b=A}

Principio

<a, b >:= < b, a >

fin

Ej programa:

var n, m : entero

principio

n:=3

m:=5

intercambiar (n, m)

fin

VISIBILIDAD

DISEÑO MEDIANTE REFINAMIENTO

“ Divide y vencerás”

Identificaremos el problema complejo

Mejor descomposición para nuestro problema

• Cualquier problema que no tenga descomposición trivial, lo descompondremos en subproblemas.

• La mejor descomposición será aquella que me lleve a problemas triviales o simples en un menor número de niveles.

• El programa no tendrá especificación pre/pos porque no tiene parámetros de entrada. Las constantes que se declaran para el programa principal y sus tipos serán heredados por el resto de funciones y procedimientos, podremos usarlas en el resto de los problemas que yo haya descompuesto. Las variables que yo necesite para resolver el problema principal no podrán ser usadas en las funciones y procedimientos por lo tanto no se usarán variables globales sino locales.

TEMA 5. ESQUEMAS SECUENCIALES

5.0 Introducción

5.1 Acceso secuencial y directo

5.2 Acceso secuencial

5.3 Leer/ escribir flujos de datos

5.4 Esquema secuencial

5.5 Ejemplos

5.0 Introducción

5.1 Flujo de entrada o salida

Es un conjunto de datos, todos del mismo tipo y ordenados según su orden de llegada, a los que se le asociará lo que llamaremos un generador de datos.

Generador de datos: Admitimos que se pueden hacer las operaciones: primer elemento, siguiente elemento y último elemento.

Flujo de entrada: Se puede hacer las operaciones hay elementos, escribir, conectar escritura y marcar.

Secuencia: Un conjunto finito de elementos asociados a un flujo y al que se puede establecer los siguientes parámetros: longitud # , parte izquierda pi, parte derecha pd y elementos distinguidos = primer elemento de la parte derecha.

Ej: Secuencia (S) caracteres

Hola luis

!

elemento distinguido

pi! Hola_l

pd!uis

ed!u

#= 9

S=/a/

Pi/ed/pd

Multiplicidad de un elemento en una secuencia es el número de apariciones que tiene.

Tamaño: #(S)= 6

Declaración de flujos de datos

Var:

Identificador: flujo de entrada de Te

Identificador: flujo de salida de Te!tipo descrito anteriormente

OPERACIONES

Las especificaciones de estas instrucciones son:

Proc leer (sal r: Te; ent/sal fle: Flujo entrada Te)

Pre:{Pi(S)= " pd(S)=b}

Pos:{ r= a " pi(S)= a " pd(S) = b}

Proc escribir (ent r: Te; ent/sal fls: Flujo salida Te)

Pre:{ pi(S)= " r=a " r " M "pd(S)=<>}

Pos:{pi(S)=a " pd(S)= <>}

Siendo <> = secuencia vacía

Y en los flujos de salida consideramos la operación:

Proc marcar (ent/sal fls: flujo sal : Te)

Pre:{ (pi(S) =  " pd (S)= < > }

Pos:{ pi (S)=M " pd(S)=< >}

Para las siguientes operaciones tendremos:

Proc conectar_lectura (ent/sal fle: flujo entrada Te)

Pre:{ cierto}

Pos:{S=a " pi(S)= < > " pd(S)=a }

Proc conectar_escritura (ent/sal fls: flujo salida Te)

Pre:{cierto}

Pos:{S=< >}

Func hay_elementos (fle: flujo entrada Te) dev r:logico)

Pre:{ S=a } o {cierto}

Pos:{ pd(S)=< > ! r=falso " pd(S) " < > ! r=cierto}

5.4 ESQUEMA SECUENCIAL

El primero de ellos es el llamado Esquema Básico. Considerando que aparecerá en alguna sección del algoritmo. E: Te y fle: flujo de entrada de Te y fls flujo de salida de Te.

ESQUEMA BÁSICO DE RECORRIDO

conectar_lectura (fle)

inicializar_tratamiento

mientras hay_elementos (fle)

leer (e, fle)

tratar e

fmientras

finalizar_tratamiento

Son estructuras que permiten reducir a módulos sencillos los algoritmos fundamentales que actúan sobre los flujos de datos. Representación reducida de los rangos esenciales de un proceso.

PROGRAMACION POR ESQUEMAS: Se llama ~ al sistema de plantear algoritmos generales a partir de esquemas simples.

• ESQUEMA FILTRO:

conectar_lectura (fle)

conectar_escritura(fls)

mientras hay_elementos (fle)

leer (e, fle)

si condición

escribir (e, fle)

|otras: nula

fsi

fmientras

marcar (fls)

• ESQUEMA ACUMULADOR

l:= l0

conectar_lectura (fle)

mientras hay_elementos (fle)

leer (a, fle)

l:= l op a

fmientras

Donde l0 es ele elemento neutro del operador op.

• ESQUEMA DE BUSQUEDA

condición i=falso

conectar_lectura (fle)

tratamiento_inicial

mientras hay_elementos (fle) y NO condición

leer (e, fle)

tratar(e)

fmientras

tratamiento_final

TEMA 6: TABLAS Y REGISTROS

6.1 Acceso directo

6.2 Tablas

6.2.1 Declaración, literales y operaciones.

6.2.2 Esquema de recorrido

6.2.3 Esquema de búsqueda

6.2.4 Esquema de ordenación

6.3 Registros

6.3.1 Declaración, literales y operaciones

6.3.2 Tablas de registros

6.1 ACCESO DIRECTO

Decimos que una estructura de datos tiene acceso directo, si podemos alcanzar cualquier elemento de la misma sin necesidad de pasar por los elementos anteriores.

i

1	6
2	9
3	12
...	...

Debe de haber un índice o una variable

6.2 Tablas

Son estructuras de datos homogéneas con acceso directo lineal y de tamaño finito.

El concepto de estructura va a s3er el conjunto de datos.

• Homogénea ! Todos los datos son del mismo tipo

• Acceso directo ! Se puede disponer de un índice de un conjunto finito y ordenado que permite acceder a cualquiera de sus valores

• Lineal ! Está almacenada de forma continua

• Finito ! Valor máximo que puede manipular el algoritmo.

TIPOS DE TABLAS

• Vectores: Son tablas de una dimensión con un único índice, podemos acceder a cualquier casilla.

• Tabla de Tabla: Son de dos dimensiones con dos índices.

• Tabla de tabla de tabla: Son de 3 dimensiones con 3 índices.

6.2.1 DECLARACION DE TABLAS

cons

N=100

Max: 225

Var

Identificador: tabla (constante entera) de tipo de dato

T: tabla [20] de entero

Tdias: tabla[N] de entero

Nombre:tabla [Max] de caracteres

• Al utilizarlas debo declararlas primeramente.

Para construir una tabla se deben conocer primero los elementos que se van a tratar. En los tipos se pueden declarar tipos de tabla:

Ej: Ttabla: tabla [20] de entero

Tdias: tabla [N] de entero

Se declaran los tipos

Var t: Ttabla

Tdias: Ttdias

• LITERALES DE TIPO TABLA

Cons

N=100

Tipos

Tb: ....

Tt: Tabla[N] de Tb

Var

T:Tt

Func bisiesto (anyo : entero) dev (l:logico)

Principio

Si anyo%400=0 O (anyo%4=0 Y No anyo%100=0))

l:=cierto

|otras

l:=falso

fsi

fin

Un literal para una tabla lo vamos a considerar como un tipo de elemento.

L={ { a1, a 2 , ........an } con ai " Tb " 1 " i " N}

OPERACIONES: Realizadas sobre tablas

Descripción	Perfil condiciones
Acceso	_[ _ ] : Tt x entero!Tb def t[ i ]" 1 " i " N
Modificación	_[ _ ! _] : Tt x entero x Tb ! Tt Def t[ i! e ] " 1 " i " N

Ejemplo

T= {a,a, a .....a, e, a,a.....a}

Acceso: Como la operación es de acceso, lo que devuelve es el valor que ocupa (i) en la tabla.

 : = t[i] ! e Lo vamos a utilizar

t[i ! e] " t[i]

Modificación:

t[ i ] : = e' Esto indica que modifique la tabla y donde esté i, coloca el valor e'.

t={ a , a ,.....a , e', a ....}

Admitiremos también la operación inicialización, pero sólo una única vez.

t:={a ,......a }

Las operaciones de tablas de 2 dimensiones:

M: tabla [N] de tabla [M] de Tb

M: tabla [ N, M] de Tb

V:= m[ i, j] acceso

M[i, j] := v modifica

L:{ {a11,a12... a1m} {a21, a22 , .......a2m}....{an1 ,an2 ......anm}}

El tratamiento de tablas es análogo al de secuencia de datos.

Fe 1 3 5 7 9

• !

hay elementos (fe ) leer (e, f(e)) Guarda el dato 1 en e y luego se

pasa al siguiente

t[ i ] " 1 " i " N

Esquema básico

conectar lectura

tratamiento inicial

mientras (hay_elementos (fe))

leer (e, fe)

tratar (e)

fmientras

tratamiento final

Ej : Aplicamos este esquema

i:= 1

tratamiento_inicial

mientras ( i < > N+1)

tratar (t[ i ])

I:= i+1

fmientras

tratamiento final

Hay otro tipo de esquema más simple, que realizaría la misma función. Uno de ellos sería la estructura “desde”.

ESQUEMA SIMPLE DE RECORRIDO DE TABLAS

tratamiento_ inicial

desde i:=1 hasta N

tratar ( t[i])

fdesde

tratamiento final

Suponemos que en una tabla tenemos almacenada las ventas de un comercio, y queremos sumarlo todo.

Cons

Nmeses:12

Tipos

Tt: tabla[Nmeses] de entero

Var

t:Tt

Pre:{cierto}

Pos:{suma:"k: 1 " k " Nmeses. (t(k))}

Var var

i:entero i:entero

principio principio

suma:=0 < i, suma>:=< 1, 0>

desde i:=1 hasta Nmeses mientras (i< > Nmeses +1)

suma:=suma + t[ i ] suma:=suma + t[ i ]

fdesde i:=i+1

fmientras

fin fin

Cuando tenga una tabla de dos dimensiones:

Cons

N:...

M:...

Tipos

Tm: tabla[N,M] de Tb

Var

m:Tm

i, j : entero

Estructura para el tratamiento de una tabla de 2 dimensiones. Utilizaremos (desde).

inicializar_tratamiento (Por columnas)

desde i:=1 hasta N (M)

tratamiento_inicial_de_fila (_de_columna)

desde j:=1 hasta M (N)

tratar_elemento (m[i,j]) ( m[j,i])

fdesde !

tratamiento_final_de_fila Solo se puede cambiar m[j,i]

fdesde cuando la tabla es cuadrada

tratamiento_final

BUSQUEDA SECUENCIAL O LINEAL

inicializar

conectar_lectura

enc:falso

mientras (hay_elementos (f(e) Y No enc)

leer (e, fe)

si condicion: enc=cierta

| otras :nula

fsi

fmientras

Para tablas

inicializar

i:=1

enc:=falso

mientras (i < > N+1 Y No enc)

si condicion: enc:= cierto

| otras i:= i+1

fmientras

fin

Ej.

cons

N: 20

tipos

Tt: tabla[ N] de enteros

t: Tt

b: logico

Pre:{cierto}

Pos:{b="k: 1" k"N . (t(k)=0)

var

i:entero

enc:logico

inicializar

i:=1

enc:=falso

mientras (i < > N+1 Y No enc)

si (t[ i]=0) : enc:=cierto

| otras i:= i+1

fsi

fmientras

b:=enc

fin

En las tablas (si están ordenadas) hay un método de búsqueda más eficaz.

BUSQUEDA DICOTÓMICA O POR PARTICIÓN

cons

N...

tipos

Tt= tabla [N] de Tb

T:Tt

v: Tb

enc:logico

Pre:{t=T " " q : 1" q" N . (t(q) " t(q+1)}

busqueda_binaria

Pos:{enc=" k: 1 " k " N . (t(k)=v)}

var

m,i,d:entero

principio

<i,d,enc>:= < 1, N, falso>

mientras i<=d Y No enc

n:=(i+1)/2

si t[m]= v : enc:=cierto

|t[m]< v : i:=m+1

|t[m]> v : d:=m-1

fsi

fmientras

fin

*Ver ejemplo de los apuntes

La ordenación de tablas es bastante corriente y se puede aplicar a cualquier tipo de datos siempre que haya definido una relación total sobre todos sus elementos.

Los tipos de ordenación dependen del tamaño del vector, del tipo de dato y de la cantidad de memoria disponible. Las soluciones más simples necesitan N2 accesos a la tabla y las soluciones más eficientes pueden llegar a tener solamente N*logN accesos.

La especificación de la ordenación se puede realizar de esta manera:

CASO MAS SIMPLE (Método de ordenación por selección)

Suponemos un vector desordenado. Busca el menor y lo coloca en primera posición.

8

5

10

2

7

................

N

Esto lo hará mediante la operación de acceso y modificación t[i]:=t[j]

Y así sucesivamente

cons

N:...

tipos

Tt: Tabla [N] en Tb

t: Tt

Pre:{t=T " N > 0}

Pos:{t!permutaciones (T) "" k: 1" k"N. (t(k) " t(k+1))}

var

i,j, pos: entero

x:Tb

principio

i:=1

mientras < > N

< pos, j > := < i, i+1>

mientras j < > N+1

si

t[pos]> t[j] : pos:=j

|otras :nula

fsi

j:j+1

fmientras

x:=t[pos]

t[pos]:=t[i]

t[i]:=x

fmientras

i:=i+1

fin

METODO DE INSERCION

Busca en la tabla la posición adecuada e inserta el elemento deseado. (Recorre la tabla de abajo a arriba)

8	5	10	2	7	4	6
8	5	10	2	4	6	7
8	5	2	4	6	7	10
8	2	4	5	6	7	10
2	4	5	6	7	8	10

var

i, j,k : entero

x: Tb

principio

i:=N-1

mientras i < > 0

< x, k, j >:= < t[i], i, N>

mientras k < > j

si

t[ k+1] < x : < t[k], k>:= <t[k+1], k+1>

| t[k+1]>= x :j=k

fsi

fmientras

t[k]:=x

i:=i-1

fmientras

fin

REGISTRO: Es un conjunto de elementos que pueden ser de distintos tipos pero que están relacionados con una entidad particular. Cada componente de información de dicho elemento se llamará campo. Cada campo tendrá asociado un tipo de dato y un identificador.

Declaración:

registro

identificador_1: tipo 1 (declarado previamente)

“ _2: tipo 2 “

.

.

.

identificador_n: tipo n

fregistro

cons

N:20

tipos

Tnom: Tabla [N] de caracteres

Tpersona: registro

Nombre: Tnom

Apel1:Tnom

Apel2: Tnom

Edad: entero

Dni: entero

fregistro

• Elementos que podría contener una variable de tipo registro.

tipos

Tr: registro

c1: T1

c2: T2

.

.

cn: Tn

fregistro

OPERACIONES EN REGISTROS:

• Acceso: ! ci: Tr!Ti /Se aplica entre un registro y me va a devolver un elemento del tipo correspondiente al campo Ti/

• Modificación _.ci ! e : Tr x Ti ! Tr

• Tabla de registros: Es un conjunto finito y ordenado de elementos de tipo registros y la declararemos:

cons

N:20

MAX:100

tipos

Tnom: Tabla [N] de carácter

Tpersona: registro

nombre: Tnom

apel1: Tnom

apel2: Tnom

edad: entero

dni: entero

fregistro

persona: tabla [MAX] de persona

var

p1: Tpersona

tp:Ttpersona

Ej: p1.edad:20

Tp[5].edad

Tp[20].nombre [1]

CADENAS: EL tipo cadena está definido en C:

• Cuando se superan los 255 caracteres

• Operaciones: < >, <=, >=, <, >, =, asignacion:=

cad1:= cad2! strcpy (cad1, cad2) (copia cad2 en cad1)

! strcmp (cad1, cad2) (compara las cadenas)

Función :

longitud n:= longitud (cad1)

leer leer cad1

escribir escribir cad2

EN C

#define MAXCAR: 255

typedef char cadena [MAXCAR+1]

cadena cad1, cad2;

EN LEA

cons

MAXCAR: 255

tipos

cadena: tabla[MAXCAR] de carácter

var

cad1, cad2: cadena.

TEMA 7: FICHEROS

7.1 : Introducción

7.2: Definición y operaciones con ficheros

7.3: Esquemas de tratamiento.

7.4: Ficheros en lenguaje C

EL dispositivo no se puede usar directamente por lo que hay que utilizar una variable o fichero. Para la utilización de ficheros se crean unas zonas de memoria intermedia.

REGISTRO_LOGICO: Es la cantidad de memoria que el programador utiliza para obtener información.

Al dispositivo de almacenamiento hay que darle un nombre, que será el nombre del fichero.

La parte de la información del fichero que el programador utiliza se llama bloque.

SINTAXIS DE FICHEROS:

Fichero: Es el constructor que va a permitir declarar estructuras de datos permanentes con acceso secuencial o directo y que se van a especificar como secuencias de datos.

Tipo base: Puede ser cualquier tipo predeclarado o definido (carácter, entero, real, cadena o registro)

Su definición se realizará en el formato habitual :

var

f: fichero de Tb

tipos

Tpersona: registro

nombre: cadena

dni: entero

edad: entero

sueldo: real

fregistro

var

fp: fichero de Tpersona

fe: fichero de entero

fc: fichero de cadena

OPERACIONES SOBRE FICHEROS

Abrir: (nombre_externo, modo_apertura, variable_fichero)

Esta operación hay que realizarla antes del fichero.

Nombre_externo: Es una cadena de caracteres que contiene el nombre del fichero.

Modo_apertura:

ent, sal : soportes secuenciales

ent/sal: soporte de acceso directo

Cerrar (variable_fichero)

Ej: apertura de fichero/cierre

Abrir ( “Datos, trt, sal/ent, fc)

!

Los datos se encuentran en este fichero

var

fc: fichero cadena

cad: cadena

cerrar (fc)

Leer (variable_elemento, variable_fichero)

Leer (variable_elemento, variable_fichero, posición)

·Ej: var var

fc: fichero cadena fc: fichero cadena

cad: cadena cad: cadena

cad1: cadena cad1: cadena

leer (cad1, fc) leer (cad1, fc, m) n: 1 " n "#(Sf)

!

entero que está comprendido en el do

minio

escribir: En esta operación “abrir” debe estar en sal/ para poder escribir datos

var

fc: fichero cadena

cad: cadena

cad1: cadena

escribir( cad1, fc)

escribir (cad1, fc, n) n: 1 " n " #(Sf)

fdf (fc)

ESQUEMAS DE TRATAMIENTO

tipos

Tpersona: registro

nombre: cadena

edad: entero

fregistro

Tfpersona: fichero de Tpersona

var

f: Tfpersona

nom_fich: cadena

principio

abrir (“nombre_esterno”, modo, f)

tratamiento_fichero

cerrar (f)

principio

leer nom_fich

abrir (nom_fich, modo,f)

tratamiento_fichero

cerrar (f)

Ej:

A partir de un flujo de entrada de enteros crear fichero

fle: flujo entrada de entero

tratamiento_fichero Pre:{fle=}

crear_fichero

Pos:{f=}

var

r:entero

El modo será de salida.

La variable f cambiará a fichero de entero.

principio

conectar_lectura(fle)

mientras( hay_elementos (fle))

leer (r, fle)

escribir (r, f)

fmientras

*(Dentro de tratamiento)

Ahora queremos copiar un fichero

var

f1, f2: fichero de entero

nom_fich1: cadena

nom_fich2: cadena

principio

leer nom_fich1

leer nom_fich2

abrir (nom_fich1, ent, f1)

abrir (nom_fich2, sal, f2)

mientras (no fdf(f1)) fdf hasta que lea el último elemento

leer (r, f1) de f1

si (condicion): Si no queremos copiar todo el fichero

escribir (r, f2) 1, utilizaremos filtros.

|otras nula

fsi

fmientras

cerrar (f1)

cerrar (f2)

CARGA DE UN FICHERO EN UNA TABLA

Pre:{f= " #() " N}

Pos:{ t= }

cons

N:100

var

nom_fich: cadena

f: fichero de entero

t: tabla [N] de entero

r: entero

i: entero

principio

leer nom_fich

abrir (nom_fich, ent , f)

i:=1

mientras ( no fdf(f))

leer (r, f)

t[i]=r

i:=i+1

fmientras

cerrar (f)

ESQUEMA DE BÚSQUEDA

Pre:{f=}

Pos:{enc= " i : 1 " i " #() . P ((i))}

Esquema

var

nom_fich: cadena

f:fichero de entero

r:entero

enc: logico

principio

leer nom_fich

abrir (nom_fich , ent, f)

enc:=falso

mientras (no fdf (F) Y No enc)

leer (r, f)

si (r=0): enc:=cierto

|otras: nula

fsi

fmientras

cerrar (f)

ESQUEMA DE CONCATENACION

f1, f2!f

Pre:{f1= " f2=}

Pos:{f=}

var

r: Tb

principio

abrir( “nom_fich 1”, ent, f1)

“ (“nom_fich 2”, ent, f2)

abrir (“nom_fich 3”, sal, f)

mientras (No fdf (f2))

leer (r, f2)

escribir (r,f)

fmientras

cerrar (f1)

“ (f2)

“ (f)

fin

ESQUEMA DE PARTICIÓN

f1, f2, f: fichero de Tb

Pre:{f=}

Pos:{f1= " f2=  " B"  " f"  " pertenece

( (i), , , P}

Pertenece{(e, , , P)=P(e)! e" B " ø P(e) !e " .

var

r: Tb

principio

abrir (“nom_fich1”, sal, f1)

abrir (“nom_fich2”, sal, f2)

abrir (“nom_fich”, ent, f)

mientras (no fdf (f))

leer (r,f)

si P(r): escribir (r, f1)

|otras: escribir (r, f2)

fsi

fmientras

cerrar (f1)

cerrar (f2)

cerrar (f)

fin

ESQUEMA DE FUSIÓN

f1, f2, f: fichero de Tb

Pre:{f1= " f2=  " ordenado (f1) " ordenado f2}

Pos:{f= "  "  "  "  " ordenado )}

var

r1,r2: Tb

principio

abrir (“nom_fich 1”, ent, f1)

abrir (“nom_fich 2”, ent, f2)

abrir (“nom_fich”, sal, f)

leer (r1, f1)

leer (r2, f2)

mientras (no fdf (f1) Y No fdf (f2))

si r2 <= r2

escribir (r2, f)

leer (r2, f2)

fsi

fmientras

si fdf(f1) Y No fdf(f2): tratamiento_final_fusion (r1, r2, f2, f1)

|fdf (f2) Y No fdf(f1): “”””” (r2, r1, f1, f)

|otras : insertar_dos(r1, r2, f)

fsi

cerrar(f1)

“ (f2)

“ (f)

proc trat_final_fusion (ent: r1, re: Tb, ent/sal fe,fs: fichero de Tb)

Pre:{r= " re =b " fe= a < B " fs= }

Pos:{fs=  " < a > " < b > " < c > "  " ordenado ()}

var

insertado:logico

principio

insertado:=falso

mientras No fdf(f(e)) Y No insertado

si re<= ri

escribir (re, fs)

leer (re , fe)

|otras

escribir (r, fs)

escribir (re ,fs)

fsi

encontrado:= Existe

fmientras

si No insertado: insertar_dos (re , r, f)

|otras

mientras No fdf (fe)

leer (re , fe)

escribir(re , f)

fmientras

fsi

fin

ORDENACIÓN DE FICHEROS

Llevar fichero a tabla #(Sf)" MAX

Ordenar tabla

Crear nuevo fichero

cons

MAX: 1000

t: tabla[Max] de Tb

FICHEROS EN C

• Streams

• Ficheros

• Puntero o fichero

• Funciones relativas o ficheros

• Apertura

• Cierre

• Entrada / salida

STREAMS:

Dispositivos lógicos que pueden asociarse indistintamente con teclado, pantalla, discos, disquetes o puertos de comunicación asociándoles una zona intermedia de memoria denominada buffer y un conjunto de operaciones E/S que permiten el tratamiento de los datos almacenados en el dispositivo, de forma que para el programador, todos los dispositivos sean idóneos y solamente estarán delimitados por sus características técnicas, como velocidad o tipo de acceso.

En C van a existir dos tipos de stream:

• Stream de texto: compuesto por un conjunto de caracteres que terminan en uno o más caracteres que simbolizan fin de linea.

• Stream binario: Cuando la información no está delimitada por el fin de línea, está formado por un conjunto de bits sin más.

Un fichero en C, se considera como aquella información almacenada en un dispositivo externo y asociado a una variable lógica mediante una operación que vamos a llamar “apertura”.

Existen 3 ficheros en C abiertos automáticamente, que nos permite acceder a ellos. Son las correspondientes a la salida y entrada estándar.

• Salida estándar: stdont (pantalla)

• Entrada estándar: stdin (teclado)

• Salida error: stden (pantalla)

Definición de un fichero:

FILE"* f;

FILE"*fopen (char *nombre fichero, car *modo)

T:=fopen (“imagen_txt”, “w”);

I.T. Informática de Sistemas.

Introducción a la programación 1.

43

1

I. T. I. S