introduccion pascal

Introducción a la ió lprogramación con Pascal

Profesor: Isidro Calvo

ISBN: 978-84-693-3713-4

Asignatura

Asignatura: Fundamentos de InformáticaDepto: Ingeniería de Sistemas y

AutomáticaAutomáticaTitulación: Ingeniero IndustrialgCurso: 1er CursoC édit 6 T 3 LCréditos: 6 T + 3 L

Isidro Calvo - DISA (UPV/EHU) 2

Objetivos de la asignaturaFamiliarizarse con los conceptos básicos de programación:programación:

AlgoritmosEstructuras de datosEstructuras de datos

Diseño, implementación y depuración de programas de complejidad mediaprogramas de complejidad mediaConocer la arquitectura de los ordenadoresF ili i l j d lFamiliarizarse con el manejo de los ordenadores


Temario TeoríaTEMA1.- Introducción a la informáticaTEMA2.- Metodología del desarrollo de programas.

Introducción a la programación estructuradaIntroducción a la programación estructuradaTEMA3.- Tipos de datos simplesTEMA4.- Sentencias de controlTEMA5 S bTEMA5.- SubprogramasTEMA6.- Funciones y procedimientosTEMA7.- Tipos definidos por el usuarioTEMA8.- Tipos estructuradosTEMA9.- Arrays y registrosTEMA10.- ArchivosTEMA11.- Codificación de la informaciónTEMA12.- Hardware – C.P.U.TEMA13 - Lenguajes de programación


TEMA13. Lenguajes de programación

DocumentaciónBásica:

Apuntes de la asignatura (Publicaciones)Apuntes de la asignatura (Publicaciones)Libros de teoría y prácticas

Avanzada:Introducción a la informática. 2ª Edición

A. Prieto, A. Lloris y J.C. Torres. Ed. McGraw-Hill, 1995I t d ió l t ió T b P l (5 0/5 5/6 0/TPW)Introducción a la computación con TurboPascal (5.0/5.5/6.0/TPW)

W.I. Salmon. Ed. Addison-Wesley Iberoamericana, 1993Fundamentos de programación. Algoritmos y estructuras de datos

Luis Joyanes Aguilar Ed McGraw Hill 1991Luis Joyanes Aguilar – Ed. McGraw-Hill, 1991Programación en Pascal

Sandford Leestma y Larry Nyhoff – Ed. Prentice Hall, 1998


Otros recursos

Página Web de la asignaturahttp://www.disa.bi.ehu.es

Uso de eKasiUso de eKasihttp://ekasi.ehu.es


http://www.disa.bi.ehu.es


Página de la asignatura


http://ekasi.ehu.es


d d f á iFundamentos de Informática

IntroducciónIntroducción

Definiciones de la R.A.E.Informática:

Conjunto de conocimientos científicos y técnicos queConjunto de conocimientos científicos y técnicos que hacen posible el tratamiento de la información por medio de ordenadores.

Hardware:Conjunto de componentes que integran la parte material de una computadoramaterial de una computadora.

Software:Conjunto de programas, instrucciones y reglasConjunto de programas, instrucciones y reglas informáticas para ejecutar ciertas tareas en una computadora.


Estructura funcional de un computador

Salida EntradaMemoria principal- Datos temporales -

- Programa -Memoria principal

AlmacenamientoU id d d Almacenamiento externoUnidad de

Control

Unidad A it éti Ló i


Aritmético-Lógica

Esquema básico HardwareDispositivo de

Almacenamiento Secundario

Procesador

Unidad de Control

+U id d

Procesador

Unidades deUnidades de UnidadAritmético-Lógica

Unidades de Salida

Unidades de Entrada

Unidad Central de Procesamiento

Memoria Central


Unidad Central de Procesamiento

Creación de programas

AlgoritmoProgramaLenguaje

ProgramaLenguaje

Cálculo o ProcesoAlgoritmo Lenguaje

de Alto nivelLenguaje Máquina

Procesodeseado

ProgramaciónTraducción

(Compilación)Ejecución

en el computador


Ejemplo de algoritmo:Ejemplo de algoritmo:Cálculo del máximo común divisor

Sean NUM_1 y NUM_2 dos números enteros positivospositivos

1 - Si los números NUM 1 y NUM 2 son iguales1. Si los números NUM_1 y NUM_2 son iguales ir al punto 4

2 - Al mayor de ellos se le resta el menor2. Al mayor de ellos se le resta el menor3.- Volver al punto 14 - El Máximo Común Divisor es el valor de4. El Máximo Común Divisor es el valor de

NUM_1 ( NUM_1 = NUM_2)


Diagrama de flujoLeer NUM_1 y NUM_2

NUM_1 = NUM_2SI NO

NUM_1 > NUM_2SI NO

NUM_2 ← NUM_2 – NUM_1NUM_1 ← NUM_1 – NUM_2

Mostrar que MCD es el valor NUM 1Isidro Calvo - DISA (UPV/EHU) 16

Mostrar que MCD es el valor NUM_1

PROGRAM MCD ;VAR

NUM_1, NUM_2 : Integer ;BEGIN

Write ('Escribe dos enteros positivos: ') ;ReadLn (NUM 1, NUM 2) ;

Lenguaje C( _ , _ ) ;

WHILE NUM_1 <> NUM_2 DOIF NUM_1 > NUM_2 THEN

NUM_1 := NUM_1 - NUM_2ELSE

NUM_2 := NUM_2 - NUM_1 ;WriteLn ('Máximo Común Divisor = ', NUM_1)

END. #include <stdio.h>void main (void)void main (void){

int NUM_1, NUM_2 ;

printf ("Escribe dos enteros positivos:") ;scanf ("%d %d", &NUM_1, &NUM_2) ;

while ( NUM_1 != NUM_2 )if ( NUM_1 > NUM_2 )

NUM 1 = NUM 1 - NUM 2 ;L j T b P l NUM_1 = NUM_1 - NUM_2 ;else

NUM_2 -= NUM_1 ;printf ("Máximo Común Divisor = %d", NUM_1) ;

}

Lenguaje Turbo Pascal


}


Estructura de un programaEstructura de un programa

Creación de programas

AlgoritmoProgramaLenguaje

ProgramaLenguaje

Cálculo o ProcesoAlgoritmo Lenguaje

de Alto nivelLenguaje Máquina

Procesodeseado

ProgramaciónTraducción

(Compilación)Ejecución

en el computador


Algoritmo que sumar 5 a un número

Pedir númeroEscribir mensaje por pantallaLeer dato de entradaLeer dato de entrada

Efectuar operaciónMostrar resultado

Escribir resultado por pantallaEscribir resultado por pantalla


PROGRAM S 5PROGRAM Sumar5;(* Programa que pide un número y le suma 5.

El programa mostrará el resultado de la suma *)USES CRT;CONST

iCINCO = 5;VAR

iRtdo, iSumando: Integer;BEGING

ClrScr;Write ('Introduce un numero para sumarle 5: ');ReadLn (iSumando);ReadLn (iSumando);iRtdo := iSumando + iCINCO;WriteLn ('El resultado es : ', iRtdo);

ENDEND.


Elementos del lenguajeSímbolos: +, -, :=, =, {, }…P l bPalabras

Palabras reservadas:PROGRAM, USES, VAR, CONST, BEGIN, END

Identificadores estándar:d ado s s á daCRT, Integer, ClrScr, Write, ReadLn, WriteLn

Identificadores del programador:Identificadores del programador:iCINCO, iRtdo, iSumando


Palabras reservadasDefinición del lenguaje de programación.No pueden ser redefinidas por losNo pueden ser redefinidas por los programadoresDif t t íDiferentes categorías:

Operaciones (+,-,*,/,DIV,MOD,AND,OR…)Definiciones y declaraciones (PROGRAM, USES, VAR)Estructuras de control (BEGIN, IF..THEN, WHILE..DO, FOR..DO, END…)


Identificadores estándarRelativos a constantes del compilador, tipos de datos, variables, procedimientos y funcionesdatos, variables, procedimientos y funcionesConocidos por el compilador pero no son palabras reservadaspalabras reservadas.Pueden variar en función del compiladorPueden redefinirse aunque se desaconsejaPoner USES con la unidad (biblioteca) que lo ( ) qdefinePor defecto USES SYSTEM


Por defecto USES SYSTEM

Identificadores del programadorNombres dados por el programador.P.e. Nombres de variables y funcionesDeben cumplir unas reglas:b u p u as g as

Hasta 127 caracteresCaracteres: A Z a z (excepto Ñ ñ yCaracteres: A..Z, a..z (excepto Ñ,ñ y vocales acentuadas)Números: (No pueden empezar por unNúmeros: (No pueden empezar por un número)Carácter de subrayado:


Carácter de subrayado: _

Líneas de programaComo máximo 127 caracteres.ElElementos:

SímbolosPalabras Literales (Datos que el programa usa directamente) Delimitadores: Espacio, separador de líneas ';', …Comentarios:

Ignorados por el compilador '(*' y '{'Ayudan a la comprensión del programa


Estructura de un programaCabecera (PROGRAM)

No obligatoria en TURBOPASCALgDeclaración de unidades (USES)

Archivos objeto: UnidadesBloque

Declaraciones y definicionesEti tEtiquetasConstantesTiposVariablesProcedimientos y funciones

Sentencias del programa principal


Sentencias del programa principal

Diagrama sintáctico

C b d BlCabecera de programa

Cláusula USES

Bloque ·Cláusula USES


PROGRAM Nombre_Programa;g ;USES {unidades separadas por comas, SYSTEM por defecto}

LABEL {etiquetas del programa}

CONST {constantes del programa}

TYPE {type del programa}

VAR {declaración de variables}VAR {declaración de variables}

{Declaración de SUBPROGRAMAS}FUNCTION ...PROCEDURE ...

{Declaración de PROGRAMA PRINCIPAL}BEGIN...END.


PROGRAM Sumar5;(* Programa que pide un número y le suma 5.


iCINCO = 5;;VAR

iRtdo, iSumando: Integer;BEGINBEGIN


ENDEND.



Datos básicosDatos básicos



iCINCO = 5;VAR



ENDEND.


Dato

Cualquier información manipulada por el ordenador y que necesita un espacio de almacenamiento en memoria.almacenamiento en memoria.

Constantes: Valor no modificable durante la ejecución.Variables: Valor modificable durante laVariables: Valor modificable durante la ejecución.


SintaxisConstantes

CONST ;Identificador constante=

Variables

Identificador tipo ;:VAR

,


Tipos de constantesPredefinidas

MAXINT MAXLONGINT PI TRUE FALSE NILMAXINT, MAXLONGINT, PI, TRUE, FALSE, NIL...Literales

Enteros decimal-hexadecimal $80 (*-128*)R l 6 67E 11Reales 6.67E-11;Carácter 'A', #65, #$41, '''' (Comilla)Cadenas 'Hola, soy una cadena'

Con nombre (Sección CONST)Enteros decimal-hexadecimal iDireccion = $80; (*-128*)Reales rG = 6.67E-11;Reales rG 6.67E 11;Carácter cCOMILLAS = ''''; Cadenas sNomFichero='datos.dat'


Variables

Tipo: Características de las variables.Valores que pueden tomarOperaciones que se pueden hacer con ellasOperaciones que se pueden hacer con ellas

PASCAL es fuertemente tipado => Se vigilan especialmente las operaciones que se puedenespecialmente las operaciones que se pueden hacer con los datos en función del tipo al que pertenecen

Espacio en memoria que necesitan


Espacio en memoria01101111 10011001

11100010 10100101

11010110 10101000

11100101 00010110

11001001 1100100111001001 11001001

11000010 01100100

00000000 00000000

...

Las variables deben inicializarse. Por defecto contienen información ‘basura’


Tipos simplesOrdinales o escalares

Clasificación de tipos en PASCALOrdinales o escalares

PredefinidosEntero (Integer, Byte, ShortInt, LongInt, Word)CharBoolean

Definidos por el programadorp p gEnumeradoSubrango

Reales (Real Single Double Extended Comp)Reales (Real, Single, Double, Extended, Comp)Tipos estructurados

ConjuntoConjuntoString (o cadena)ArrayArrayRegistroFichero (Binario / Texto)


Fichero (Binario / Texto)Tipo puntero

Tipo IntegerTamaño: 2 bytesRango: 32768 32767Rango: -32768..32767Overflow: 32767+1=-32768!!!

Produce resultados erróneos no error en ejecución!Produce resultados erróneos, no error en ejecución!Operaciones permitidas: (Operandos de tipo Integer)

Aritméticas: +, - , * , / , DIV, MODComparación: =,<>,>,<,>=,>=Bit a bit: NOT, AND, OR,…Funciones y procedimientos: Abs Sqr Exp Sin CosFunciones y procedimientos: Abs,Sqr,Exp,Sin,Cos,…I/O: Read, ReadLn, Write, WriteLn


Otros tipos enteros

Nombre Rango Tamaño Formato

Integer -32768.. 32767 2 bytes Entero con signo

Word 0..65536 2 bytes Entero sin signo

ShortInt -128..127 1 byte Ent. corto c. signo

Byte 0 255 1 byte Ent corto s signoByte 0..255 1 byte Ent. corto s. signo

LongInt -2147483648..2147483647 4 bytes Ent. largo c. signo


Tipo RealTamaño: 6 bytesRango: ( 1 7E38 2 9E 39) 0 ( 1 7E38 2 9E 39)Rango: (-1.7E38..-2.9E-39) 0 (-1.7E38..-2.9E-39)Overflow:

Abs(Dato)<2 9E-39 => Dato=0Abs(Dato)<2.9E 39 => Dato=0Abs(Dato)>1.7E38 => Error en ejecución (FIN de programa)

Operaciones permitidas:Aritméticas: +, - , * , /Comparación: =,<>,>,<,>=,>=Funciones y procedimientos: Abs Sqr Exp Sin CosFunciones y procedimientos: Abs,Sqr,Exp,Sin,Cos,…I/O: Read, ReadLn, Write, WriteLn


Otros tipos reales

Nombre Rango Tamaño Precisión

Real 2.9E-39 .. 1.7E38 6 bytes 11-12

Single 1.5E-45 .. 3.4E38 4 bytes 7-8

Double 5.0E-324 .. 1.7E308 8 byte 15-16

Extended 3 4E-4932 1 1E4932 10 byte 19-20Extended 3.4E 4932 .. 1.1E4932 10 byte 19 20

Comp -9.2E18 .. 9.2E18 8 bytes 19-20


I/O básicas (Teclado / Pantalla)

Lectura (De teclado)ReadReadLnReadLn

Escritura (Por pantalla)WriteWriteLn


Lectura: SintaxisRead

Identificador Variable( ),

Id tifi d V i bl

ReadLn

( )Identificador Variable

,( )


,

Comportamiento Read/ReadLnLectura a través del BUFFER de teclado

El usuario puede modificar los datos antes deEl usuario puede modificar los datos antes de aceptarlos (Tecla Enter )

Aconsejable mostrar mensajes informativosj jLectura de cero, uno o varios datosMenos datos introducidos que solicitados q

Programa no continúaMás datos introducidos que solicitados

Read: Datos sobrantes en el buffer de tecladoReadLn: Datos sobrantes descartados


Escritura: SintaxisWrite

Expresión( ),

E ió

WriteLn

( )Expresión

,( )


,

Comportamiento Write/WriteLn

Muestra por pantalla las expresiones indicadas en la llamada al procedimientoLa primera expresión se escribe en la posición del cursorDifferencia Write / WriteLn (Posición del cursorDifferencia Write / WriteLn (Posición del cursor después de la ejecución)EjemploEjemplo

WriteLn ('Alto: ', iDato1, ' - Ancho: ' iDato2); Alto: 14 - Ancho: 23


Formato de las expresiones

Indica cómo debe mostrarse por pantalla la expresión.Expresion: formatoExpresion: formato

Los formatos varían en función del tipo de i bl (E t R l C d )variable (Entero, Real o Cadena)

Ejemplo:j pWriteLn ('Palabra ': 14);


Formatos de cadenasWriteLn (Cadena_de_caracteres: Anchura);

Soy una cadena

12345678901234567890

Opciones:

12345678901234567890

Opciones:Sin indicar anchuraAnchura MAYOR que el número de caracteresAnchura MAYOR que el número de caracteresAnchura MENOR que el número de caracteres


Formato de enterosWriteLn (Expresión_Entera: Anchura);

23103

12345678901234567890

Opciones:

12345678901234567890

Opciones:Sin indicar anchuraAnchura MAYOR que el número de caracteresAnchura MAYOR que el número de caracteresAnchura MENOR que el número de caracteres


Formato de reales

Sin formato:Representación en formato científico o coma flotanteWriteLn (Expresión_Real);

-d.ddddddddddE±dd

12345678901234567

El exponente siempre tiene como mínimo 2 dígitos

12345678901234567

p p gEl signo de la parte entera es opcionalEl signo del exponente es obligatorio


g p g

Formato de reales

Con anchura:Representación en formato científico o coma flotanteWriteLn (Expresión_Real: Anchura);

-d.dE±dd

12345678

Anchura mínima de 8 espacios

12345678

pEjemplos libro


Formato de reales

Con anchura y precisión:Representación en formato científico o coma flotante

WriteLn(Expresión_Real:Anchura:Precisión);

123456.679

12345678901234567890

Anchura total del campo

12345678901234567890

pNúmero de decimales significativosEjemplos libro


je p os b o

d lEstructuras de control

Fundamentos de InformáticaFundamentos de Informática



iCINCO = 5;VAR



ENDEND.


Bloque de sentencias

Delimitado por BEGIN…ENDOperaciones ejecutadas por el programa

Definición previa de las estructuras putilizadas:

Tipos de datosTipos de datosDatos (Variables y constantes)Funciones y ProcedimientosFunciones y Procedimientos

Sentencias separadas por ';'


Tipos de sentenciasSentencias Simples

Sentencia de asignación ‘: ’Sentencia de asignación ‘:=’Llamadas a un procedimiento ClrScr;

Sentencias EstructuradasSentencias compuestas

BEGIN ... END;Sentencias de control de flujo

SelectivasIF iA>5 THEN … ELSE …||CASE … OF … ELSEIterativasFOR i:= 1 TO 5 DO||WHILE i>5 DO||REPEAT UNTIL


FOR i: 1 TO 5 DO||WHILE i>5 DO||REPEAT … UNTIL

Sentencia de asignación ‘:=’Escribe datos en variables

Siempre se asigna el valor de la derecha a laSiempre se asigna el valor de la derecha a la variable de la izquierda iRtdo:= 7;Formato: identificador variable := expresión;Formato: identificador_variable := expresión;

Evalúa la expresión de la derecha si es necesarioSobrescribe el contenido previo de la variableSobrescribe el contenido previo de la variable

NO es el ‘=‘ matemáticoiCont:= iCont + 1;

Ejemplos libro


j p

Diferencias entre ‘:=’ y ‘=’‘=’

Sección CONSTSección CONSTComparación. Contenidos de variables igualesiDato1 = iDato2; > TRUE | FALSEiDato1 = iDato2; -> TRUE | FALSE

‘:=’óSentencia de asignación (Dar valor a una variable)

Ejemplo:iCont := iCont+1; -> iCont pasa de 6 a 7iCont = iCont+1; -> Siempre FALSE


Expresiones aritméticas

Ej: iRtdo := iSumando + iCINCO;Combinación de operandos y operadoresOperandos de tipo real y entero (igual que elOperandos de tipo real y entero (igual que el resultado)Operadores:Operadores:

Integer: +,- (unario y binario),*,DIV,MOD,/Real:+ (unario y binario) * /Real:+,- (unario y binario),*,/

Ejemplos libro


Conversión automática de tiposOp. Descr. Tipo Operando Tipo Rtdo

+ Suma Integer o Real Real si alguno real+ Suma Integer o Real Real si alguno real

- Cambio signo Integer o Real Mismo que operando

- Resta Integer o Real Real si alguno real

* Producto Integer o Real Real si alguno real

/ División real Integer o Real Real

DIV División entera Integer IntegerDIV División entera Integer Integer

MOD Módulo o resto Integer Integer


Orden de precedencia

Indica qué operaciones se hacen primeroiRtdo:= 2 - 2 * 3; -> ??

Para ejecutar primero operaciones conPara ejecutar primero operaciones con menor precedencia -> Usar paréntesisiRtdo:= (6 – 2)* 3; -> ??

En caso de duda -> Usar paréntesisEn caso de duda Usar paréntesis


Tabla de precedencia p(Sólo Op. Aritméticos)

Nivel de precedencia OperadorespMáximo - (Unario: Cambio de signo)

Medio * / DIV MODMedio , /, DIV, MOD

Mínimo +, - (Binario: Resta)


Ejemplos

iRtdo := 2 * - 2 -3 + - 4 / 2; -> ??

iRtdo := 2 * - 3 + - 2 * 2; -> ??

iRtdo := 2 ( - 3 + - 2 ); -> ??


Funciones aritméticas estándarFunción Descripción Tipo param. Tipo result.Abs(x) Valor absoluto Integer/Real Igual que x

Funciones aritméticas estándar

( ) g / g q

Sqr(x) Cuadrado Integer/Real Igual que x

Sqrt(x) Raíz cuadrada Real (>0) Real (>0)

Int(x) Parte entera Real Real

Frac(x) Parte decimal Real Real

Round(x) Redondeo Real LongInt

Trunc(x) Truncado Real LongInt

Si ( ) S I /R l R lSin(x) Seno Integer/Real Real

Cos(x) Coseno Integer/Real Real

ArcTan(x) Arctangente Integer/Real Real ( /2 /2)ArcTan(x) Arctangente Integer/Real Real (-π/2, π/2)

Exp(x) Exponencial ex Integer/Real Real

Ln(x) Logaritmo neperiano Integer/Real (>0) Real


Ln(x) Logaritmo neperiano Integer/Real (>0) Real

Ejemplos{Función Tangente}rTan Sin(rAng)/Cos(rAng)rTan:= Sin(rAng)/Cos(rAng);{Función Potencia ax}rRtdo:=Exp(x*Ln(a));rRtdo:=Exp(x*Ln(a));{Funciones de redondeo}rDato:=32.57;rDato: 32.57;rRtdo1:=Int(rDato); -> rRtdo1:=32.0rRtdo2:=Frac(rDato); -> rRtdo2:=0.57( );iRtdo1:=Trunc(rDato); -> iRtdo1:=32iRtdo2:=Round(rDato); -> iRtdo2:=33


Tipo BooleanTamaño: 1 byteRango: TRUE (1) / FALSE (0)Rango: TRUE (1) / FALSE (0)Operaciones permitidas:

Lógicas: NOT AND OR XORLógicas: NOT, AND, OR, XORComparación: =,<>,>,<,>=,<=

Aunque en realidad sólo son útiles = y <>Se cumple que TRUE > FALSE

I/O: Sólo Write, WriteLnEjemplos:Ejemplos:

boCierto:= TRUE;boEncontrado:= FALSE;


boEncontrado:= FALSE;

Expresiones lógicasEj: boRtdo := boA AND boB;

iRtd iD t 1 AND iD t 2iRtdo := iDato1 AND iDato2;

Operandos de tipo boolean o enteroOperandos de tipo boolean o enteroOperandos Boolean -> Resultado BooleanOperandos Enteros -> Resultado EnteroOperandos Enteros > Resultado Entero

Operadores lógicos:p gNOT (negación), AND (Y o producto lógico), OR (O o suma lógica), XOR (O exclusivo)


Tablas de verdad

A B NOT A A AND B A OR B A XOR BA B NOT A A AND B A OR B A XOR B

FALSE FALSE TRUE FALSE FALSE FALSEFALSE FALSE TRUE FALSE FALSE FALSE

TRUE FALSE FALSE FALSE TRUE TRUE

FALSE TRUE FALSE TRUE TRUE

TRUE TRUE TRUE TRUE FALSETRUE TRUE TRUE TRUE FALSE


Tabla de precedencia p(Sólo Op. Lógicos)

Nivel de precedencia OperadorespMáximo NOT (Unario)

Medio ANDMedio AND

Mínimo OR, XOR


EjemplosBEGIN

R:=TRUE;;S:=FALSE;T:=TRUE;Q:=FALSE;boRtdo:=R OR Q; -> ??boRtdo:=R XOR Q AND S; -> ??boRtdo:=R XOR Q AND S; -> ??boRtdo:=(R OR Q)AND S; -> ??boRtdo:=R OR Q AND S; -> ??QboRtdo:=R AND NOT R; -> ??boRtdo:=R OR NOT Q AND T; -> ??


END.

Op. Lógicas con enteros

Operaciones bit a bitAND, OR, NOT, XOR

Ej: 67 AND 5 -> 101000011 AND 00000101 -> 00000001

Operaciones desplazamientoSHL, SHR

Ej: 7 SHL 2 -> 2800000111 SHL 4 -> 00011100


Expresiones relacionales p(comparativas)

Ej: boRtdo := iDato1 > iDato2;

Evalúan la veracidad de una comparación entreEvalúan la veracidad de una comparación entre dos operandos

Resultado: TRUE / FALSEResultado: TRUE / FALSEOperandos de cualquier tipo simple:

Integer, real, boolean, char, …g , , , ,

Operandos deben ser del mismo tipo o de tipos compatibles


Operandos relacionales

Op. Descr. Tipo Operando Tipo Rtdo= Igual que Ordinal o Real Boolean

<> Distinto que Ordinal o Real Boolean<> Distinto que Ordinal o Real Boolean

< Menor que Ordinal o Real Boolean

<= Menor o igual que Ordinal o Real Boolean

> Mayor que Ordinal o Real Boolean

>= Mayor o igual que Ordinal o Real Boolean


EjemplosboRtdo:= iDato1 <> iDato2;boRtdo:= iDato1 > rDato1;boRtdo:= iDato1 > rDato1;boRtdo:= (iDato1 > 10) AND (iDato2 <> 0);…rNum1:= 1.234E20;rNum2:= rNum1 + 1000;b d 1 2 b dboRtdo:= rNum1=rNum2; -> boRtdo????…boRtdo:= Sqr(x)+Sqr(y)<= 25; -> boRtdo?boRtdo:= Sqr(x)+Sqr(y)<= 25; > boRtdo?…Intervalo matemático [-10, 10] ????


[ , ]

Tabla de precedencia p(Todos los operadores)

Nivel deNivel de precedencia Operadores

Máximo - (unario)( )

Medio superior NOT (unario)

M di * / DIV MOD ANDMedio *, /, DIV, MOD, AND

Medio inferior +, -, OR, XOR

Mínimo =, <>, >, >=, <, <=


Sentencias compuestas

Tres sentencias simples Una sentencia compuesta

Sentencia1; BEGINSentencia2;Sentencia3;

Sentencia1;Sentencia2;Sentencia3END


Sentencias compuestas

Una sentencia compuesta AGRUPA varias sentencias simples

Delimitada por BEGIN y ENDDelimitada por BEGIN y ENDA todos los efectos comportamiento igual que una sentencia simpleuna sentencia simpleLas sentencias incluidas pueden ser de

l i ti (I l d t t icualquier tipo (Incluyendo otras sentencias compuestas)


Control de flujo

Por defecto: Las instrucciones de un programa se ejecutan en secuencia (una tras otra)(una tras otra)

Sentencias de control de flujoAlternativas (o selectivas)( )Iterativas (o repetitivas)


Sentencias selectivas

Permiten escoger entre unas u otras isentencias

Evalúan alguna expresión para decidir qué sentencias se ejecutanqué sentencias se ejecutan

IF..THENIF THEN ELSEIF..THEN..ELSECASE..OF


IF..THEN (Sentencia Selectiva simple)

Ejecuta (o no) una sentencia del programa en óbase a una expresión booleana

Condición

FalsoVerdadero

Sentencia

FalsoVerdadero

IF THENExpr. Booleana Sentencia


EjemplosIF iDato=3 THENSentencia1;

IF (iDato>0) AND (iDato<8) THENBEGINS t i 1Sentencia1;Sentencia2;END

IF rDato<0 THEN IF rDato1>=0 THENSentencia1;

IF rDato=0 THENSentencia2;

BEGINSentencia1;IF rDato2>0 THENSentencia2;

IF rDato>0 THENSentencia3;

IF rDato2>0 THENSentencia2;

END


Buscar erroresPROGRAM Errores;VAR

lA, B: Real;BEGINReadLn(A, B);IF (B 0) THENIF (B:=0) THEN

WriteLn (‘El 2. num no puede ser 0’);Write (‘Dime otro n.:’)ReadLn (B);ReadLn (B);

ReadLn(B)IF A:=0 THEN

WriteLn(‘A/B vale’ 0);WriteLn( A/B vale 0);IF A<>0 AND B<>0 THEN

WriteLn(‘A/B vale: ‘, A/B:0:3);END.


.

Máximo de 3 númerosIFs anidadosIF (iA >= iB) AND (iA >= iC) THEN

iMax:= iA;IF (iB > iA) AND (iB > iC) THEN

iMax:= iB;iMax: iB;IF (iC > iA) AND (iC > iB) THEN

iMax:= iC;

Variable iMaximoiMax:= iA;IF iB > iMax THEN

iMax:= iB;IF iC > iMax THEN


iMax:= iC;

IF..THEN..ELSE (Selección doble)

Escoge una sentencia u otra de un programa en óbase a una expresión booleana

FalsoVerdaderoCondición

Sentencia2Sentencia1

IF THENExpr. Booleana Sentencia1 ELSE Sentencia2


IF..THEN..ELSE

Si j t l t iSiempre se ejecuta alguna sentencia, pero nunca ambasNUNCA d b l á t ‘ ’ d l tNUNCA se debe poner el carácter ‘;’ delante del ELSECon iene tili a sang ado pa a comp endeConviene utilizar sangrado para comprender mejor los programasCada ELSE a asociado al IF más ce canoCada ELSE va asociado al IF más cercano


EjemplosIF iB=0 THENWrite(‘Division por 0’)

ELSE

IF iDato1>0 THENIF iDato2>0 THEN

W it (‘S l ’)ELSEWrite(‘Cociente:’,iA/iB:0:3);

Write(‘Se cumple’)ELSE

Write(‘No se cumple’);

IF iDato1>0 THENIF iDato2>0 THEN

IF iDato1>0 THENBEGINIF iDato2>0 THEN

Write(‘Se cumple’)ELSE

i (‘ l ’)

BEGINIF iDato2>0 THEN

Write(‘Se cumple’)Write(‘No se cumple’); END

ELSEWrite(‘No se cumple’);


CASE..OF (Selección múltiple)

Permite escoger entre más de dos alternativas excluyentes entre síexcluyentes entre síUtiliza expresiones ordinales en vez de booleanas

De tipo Entero (Integer Byte ) Boolean o CharDe tipo Entero (Integer, Byte…), Boolean, o Char

Expresión

Sentencia 1

ValorNValor1

Sentencia 2 Sentencia N

Valor2

Sentencia 1 Sentencia 2 Sentencia N. . .


CASE..OF (Sintaxis)

Constante Sentencia:

,

.. Constante

CASE OFExpr. Ordinal Caso END

Caso por defecto;

ELSE

;

Sentencia


;

EjemplosCASE i OF1: Write (‘uno’);2 4 W it (‘d t ’)

CASE iDato OF1: BEGIN

W it (‘Ot ’)2,4: Write (‘dos o cuatro’);3: Write (‘tres’);5..8: Write(‘entre cinco y ocho’);

Write(‘Otro n.’);ReadLn(iDato);END;

ELSEWrite(‘Opcion no valida’);Write(‘Introduce n. (1..8)’)

2: BEGINWrite(‘N. valido’);Write(iA/2);( ( ) )

ENDWrite(iA/2);END;

ELSEWrite(‘Ni 1 ni 2’)

END


Menúse úsPROGRAM Menu;VAR

iO i tiOpcion: Integer;BEGINWriteLn(‘Menú’){Opciones del menu}{ p }WriteLn(‘1. Opcion 1’);WriteLn(‘2. Opcion 2’);...W it (‘I t d t i ‘)Write (‘Introduce tu opcion: ‘);ReadLn (iOpcion);CASE iOpcion OF

{Sentencias opcion 1}{ p }1: WriteLn(‘Escogiste la opcion 1’);{Sentencias opcion 2}2: WriteLn(‘Escogiste la opcion 2’);...

ELSE{Mensaje de error}WriteLn(‘Opción no válida’);


( p );END.

IF..ELSE..IF (Selección múltiple)

Selección múltiple en base a condiciones booleanas

Verdadero

Sentencia1Condición1

Falso

Sentencia2Condición2

Verdadero

Falso

SentenciaN-1CondiciónN-1

Verdadero

FalsoSentenciaN


EjemploPROGRAM Raices;VAR

C i i i t lrA, rB, rC, rDiscriminante: Real;BEGIN

Write(‘Coeficientes de ec de 2º grado’);ReadLn(rA rB rC);ReadLn(rA, rB, rC);rDiscriminante:= Sqr(rB)-4*rA*rC;

IF rDiscriminante < 0 THENWriteLn(‘Dos raíces imaginarias’)

ELSE IF rDiscriminante =0 THENWriteLn(‘Una raíz real doble’)

ELSEELSE WriteLn(‘Una raíz real doble’)

END.


Comparación diagramasIF..ELSE..IFIF..THEN

Verdadero

Sentencia1Condición1Falso

VerdaderoCondición1

Sentencia1Falso

l

Sentencia2Condición2Verdadero

VerdaderoCondición2

Falso

Falso

SentenciaN-1CondiciónN-1VerdaderoFalso Sentencia2

Verdadero FalsoSentenciaN

Falso

VerdaderoCondiciónN

SentenciaN


Tabla de multiplicar (I)PROGRAM Tabla;CONST

Tabla del 22 * 1 = 2CONST

NUMERO = 2;VAR

i: Integer;

2 * 2 = 42 * 3 = 6...g

BEGINWriteLn(‘Tabla del ’, NUMERO);i:= 1;

2 * 10 = 20

WriteLn(‘2 * ‘, i, ‘ = ‘, NUMERO*i);i:= i + 1;WriteLn(‘2 * ‘, i, ‘ = ‘, NUMERO*i);i:= i + 1;WriteLn(‘2 * ‘, i, ‘ = ‘, NUMERO*i);...


END.

Sentencias repetitivas (bucles)

FOR .. DOSentencia repetitiva definida

Incluye el número de veces que se repite una sentencia

WHILE .. DOSentencia repetitiva indefinida

Comprobación de una condición de entrada al bucle

REPEAT .. UNTILSentencia repetitiva indefinida

Comprobación de una condición de salida del bucle


Tabla de multiplicar (II)PROGRAM Tabla;CONST

Tabla del 22 * 1 = 2CONST

NUMERO = 2;VAR

i: Integer;

2 * 2 = 42 * 3 = 6...g

BEGINWriteLn(‘Tabla del ’, NUMERO);

2 * 10 = 20

FOR i:= 1 TO 10 DOWriteLn(‘2 * ‘, i, ‘ = ‘, NUMERO*i);

END.


Tabla de multiplicar (III)FOR .. DOFOR i:= 1 TO 10 DO

WriteLn(‘2 * ‘, i, ‘ = ‘, NUMERO*i);( , , , );

WHILE .. DOi:= 1;WHILE i < 10 DOWHILE i <= 10 DOBEGIN

WriteLn(‘2 * ‘, i, ‘ = ‘, NUMERO*i);i:= i+1;

END

REPEAT .. UNTILi 1i:= 1;REPEAT



UNTIL i>10;

Sentencia FOR..DO (diagrama TO)

FOR Var. Control :=TO

Valor Inicial Valor FinalDOWNTO

DO Sentencia

Falso ValorInic<=ValorFin

DOWNTO

VerdaderoValorFin

VarControl:=ValorInic

Sentencia VarControl:=Succ(VarControl)

VarControl >=ValorFin

Verdadero

Falso


Verdadero

FOR..DO

Ejecución de una sentencia (simple o compleja) un núme o definido de ecesnúmero definido de vecesVariable de control, valor inicial y valor final de tipo ordinal (Entero, Char, Boolean)ordinal (Entero, Char, Boolean)TO:

Aumenta en 1 el valor de la variable de controlDOWNTO:

Disminuye en 1 el valor de la variable de controlN d b difi d t d l b l l i blNunca se debe modificar dentro del bucle la variable de control (aunque se puede utilizar)


Ejemplosi:= 13;FOR i:= 20 TO 5 DO

W it (i)

i:= 13;FOR i:= 20 DOWNTO 5 DO

W it (i)Write(i);Write(i);

Write(i);Write(i);

{ l l d l f i l} { ú i }{Calculo del factorial}{Buscar error}iFact:=1;

{Suma números impares}iSuma:=0;FOR i:=1 TO 10 DO

FOR i:=1 TO 10 DOiFact:=iFact*i;

WriteLn(‘Resultado =‘ iFact);

BEGINiNum:= 2*i-1;iSuma:= iSuma + iNum;WriteLn(‘Resultado =‘, iFact); iSuma:= iSuma + iNum;END;

WriteLn(‘Resultado =‘, iSuma);


Fibonacci (0,1,1,2,3,5,8,13,21,…)bo acc (0, , , ,3,5,8, 3, , )PROGRAM Fibonacci;VARiNum, iNum 1, iNum 2, i, N: Integer;, _ , _ , , g

BEGINWrite('N? ');ReadLn(N);iN 1 0iNum_1:= 0;iNum_2:= 0;FOR i:= 1 TO N DO

BEGINIF i=1 THEN {El primer num es 0}

iNum:= 0ELSE IF i=2 THEN {El segundo num es 1}

iNum: 1iNum:= 1ELSE {Suma de los dos anteriores}

BEGINiNum 2:= iNum 1;_ _iNum_1:=iNum;iNum:= iNum_1 + iNum_2;END;

Write(iNum ' ');


Write(iNum, ',');END;

END.

Sentencias FOR anidadasPROGRAM Matriz;VAR 11 12 13VAR

i, j: Integer;BEGIN

11 12 1321 22 2331 32 33

WriteLn('La matriz es');FOR i:=1 TO 3 DO

BEGINBEGINFOR j:=1 TO 3 DO

Write(i,j,' ');WriteLnEND

END.






END




UNTIL i>10;

WHILE..DO (Condición de entrada)

Evalúa la condición (expr. Booleana) al inicio del bucleTras cada ejecución se vuelve a evaluar la condiciónTras cada ejecución se vuelve a evaluar la condiciónLa sentencia debe modificar el valor de la condición

VerdaderoCondición

F l

Verdadero

Sentencia

WHILE DOExpr. Booleana Sentencia

Falso


PROGRAM Suma; PROGRAM Pos_Neg;

EjemplosVARiNum, iSuma: Integer;

BEGIN

VARiPos, iNeg, iNum: Integer;

BEGIN

Inicialización

Condición booleanaGiSuma:=0;iNum :=1;WHILE iN < 26 DO

iPos:=0;iNeg:=0;Write(‘Escribe un num: ‘);

de entrada

WHILE iNum < 26 DOBEGINiSuma:= iSuma+iNum;

ReadLn(iNum);WHILE iNum <> 0 DO {CENTINELA}

BEGIN

iNum:= iNum +1;END;

WriteLn(‘Suma: ‘

IF iNum > 0 THENiPos:= iPos+1

ELSE IF iNum < 0 THENWriteLn( Suma: , iSuma);END.

iNeg:= iNeg+1;Write(‘Escribe un num: ‘);ReadLn(iNum);Preparación siguienteEND;

WriteLn(‘Pos: ‘,iPos,‘ Neg: ‘,iNeg);END.

p ginstrucción


PROGRAM Pos_Neg;VAR

EjemplosiPos, iNeg, iNum, iContinuar: Integer;

BEGINiPos:=0;;iNeg:=0;Write(‘Pulsa 1 para continuar 0 para acabar: ‘);ReadLn(iContinuar);ead ( Co t ua );WHILE iContinuar = 1 THEN {1 = CONTINUAR || 0 = ACABAR}

BEGINWrite (‘Introduce un numero: ‘);Write ( Introduce un numero: );ReadLn(iNum);IF iNum > 0 THEN

iPos:= iPos+1iPos:= iPos+1ELSE IF iNum < 0 THEN

iNeg:= iNeg+1;Write(‘Pulsa 1 para continuar 0 para acabar: ‘);Write( Pulsa 1 para continuar 0 para acabar: );ReadLn(iContinuar);END;

WriteLn(‘Pos: ‘ iPos ‘ Neg: ‘ iNeg);



EjemploPROGRAM Haz_algo;VARVAR

i: Integer;BEGIN

Write(‘Introduce un numero’);ReadLn(i);WHILE i>10 DOBEGINWriteLn(‘Hola que tal. Iteracion ’, i);i:= i+1i: i+1END;

END.






END




UNTIL i>10;

REPEAT..UNTIL (Condición salida)Se ejecuta la sentencia y luego se evalúa la condición

La sentencia se evalúa como mínimo una vezLa sentencia debe modificar el valor de la condición

Sentencia

CondiciónFalso

VerdaderoVerdadero

REPEAT Sentencia Expr. BooleanaUNTIL


;

PROGRAM Suma; PROGRAM Pos_Neg;

EjemplosVARiNum, iSuma: Integer;

BEGIN

VARiPos, iNeg, iNum: Integer;

BEGIN

Inicialización

GiSuma:=0;iNum :=1;REPEAT

iPos:=0;iNeg:=0;Write(‘Escribe un num: ‘);Preparación

Si i t i t ióREPEATiSuma:= iSuma+iNum;iNum:= iNum +1;

ReadLn(iNum);REPEAT

IF iNum > 0 THEN

Siguiente instrucción

UNTIL i>=26;WriteLn(‘Suma: ‘, iSuma);

END

iPos:= iPos+1ELSE IF iNum < 0 THEN

iNeg:= iNeg+1;END.Write(‘Escribe un num: ‘);ReadLn(iNum);

UNTIL iNum = 0;

Condición booleanade Salida



Comparación FOR..WHILE..REPEAT

FOR es un bucle definido Se conoce cuántas veces se ejecutará la sentenciaSe conoce cuántas veces se ejecutará la sentencia

WHILE y REPEAT son bucles indefinidosEl número de veces que se repite depende de la condiciónq p p

FOR y WHILE son bucles con condición de entradaUn FOR se puede convertir en un WHILEUn WHILE no siempre se puede convertir en un FOR

Un bucle WHILE se puede convertir en un bucle REPEATRequiere NEGAR la condiciónRequiere NEGAR la condición

WHILE -> entradaREPEAT -> salida

C bi l ló i d l b l


Cambiar la lógica del bucle

Qué tipo de bucle escoger?

Se sabe cuántas veces se ejecutará la sentenciaSí FOR N WHILE REPEATSí -> FOR No -> WHILE o REPEAT

Es necesario ejecutar al menos una vez la t isentencia

Sí -> REPEAT No -> WHILEE l j tili WHILE REPEATEn general, es mejor utilizar WHILE que REPEAT

Mayor claridadP á b t fi blProgramas más robustos y fiablesSe estima que sólo en el 5% de los casos es mejor usar REPEAT (P e menus)


usar REPEAT (P.e. menus)

PROGRAM Menu;VAR

iOpcion: Integer;iOpcion: Integer;BEGINREPEAT

WriteLn(‘Menú’){Opciones del menu}WriteLn(‘1. Opcion 1’);WriteLn(‘2. Opcion 2’);...WriteLn(‘0. Salir’);Write (‘Introduce tu opcion: ‘);ReadLn (iOpcion);CASE iOpcion OF

{Sentencias opcion 1}1: WriteLn(‘Escogiste la opcion 1’);{Sentencias opcion 2}{Sentencias opcion 2}2: WriteLn(‘Escogiste la opcion 2’);...0: ;

ELSE{Mensaje de error}WriteLn(‘Opción no válida’);

END


ENDUNTIL iOpcion = 0;

END.

Tabla ASCII estándar


Tabla ASCII extendida


Tipo CharTamaño: 1 byteRango: NULL (0) (255)Rango: NULL (0)..(255)Overflow: Succ(255) -> NULL (0)

No se produce la finalización del programaNo se produce la finalización del programaOperaciones permitidas:

Comparación: =,<>,>,<,>=,>=

‘0’>’9’>… >’A’>’Z’>…>’a’>’z’>…>’ñ’>’Ñ’

Funciones y procedimientos: UpCase, Chr, Ord, Pred, Succ, Inc, y p p , , , , , ,DecI/O: Read, ReadLn, Write, WriteLn, ReadKey


Ejemplos{Declaración de variables}VAR

C Ch

{Asignación de un carácter}BEGINC ‘A’ {Lit l á t }cCar: Char;

BEGINcCar:= ‘A’;

cCar:= ‘A’; {Literal carácter}cCar:= #65; {Codigo Decimal}cCar:= $#41; {Codigo Hexadec}

WriteLn(‘Letra: ‘, cCar);END.

ReadLn(cCar); {Desde teclado}cCar:=ReadKey; {Desde teclado}ENDEND.

{Función Ord}{iCod->65}

{Función Chr}{cCar->’A’}

iCodigo:= Ord(‘A’); {iCod->48}iCodigo:= Ord(‘0’);

cCar:= Chr(65);{cCar->’0’}cCar:= Chr(48);


iCodigo: Ord( 0 ); cCar: Chr(48);

Mostrar la tabla ASCIIPROGRAM T_ASCII;USES

C tCrt;VAR

i: Integer;cCar: Char;cCar: Char;

BEGINClrScr;WriteLn('Tabla ASCII');WriteLn( Tabla ASCII );FOR i:=1 TO 255 DO

BEGINIF i MOD 20 = 0 THEN {Muestra de 20 en 20 caracteres}IF i MOD 20 0 THEN {Muestra de 20 en 20 caracteres}

BEGINWriteLn('Pulsa INTRO para acabar');cCar:=ReadKey;y;ClrScr;END;

WriteLn(i, ' ', Chr(i));


END;END.

PROGRAM Mayus;USES

Crt;Crt;VAR

cCar, cMayus, cResp: Char;boFin: Boolean;

BEGINboFin := FALSE;WHILE NOT boFin DO

BEGINBEGINWriteLn;Write('Introduce un caracter ');ReadLn(cCar);IF (cCar>='a') AND (cCar<='z') THEN

BEGIN{cMayus:=Chr(Ord(cCar) -Ord('a') + Ord('A'));}cMayus:=Chr(Ord(cCar) - 32);cMayus:=Chr(Ord(cCar) - 32);WriteLn('Minuscula: ', cCar, 'Mayuscula: ':20,cMayus);END;

Write('Quieres continuar (s/n) ');{cResp:=ReadKey;}ReadLn(cResp);IF (cResp<>'S') AND (cResp<>'s') THEN

boFin:=True;


boFin:=True;END;

END.

Función o Proc. Devuelve Ejemplo

UpCase (Valor Char) Si Valor Char está entre ‘a’ ’z’ cCar:=UpCase(‘a’);UpCase (Valor_Char) Si Valor_Char está entre a .. z -> misma letra en mayúsculas

Si no, -> valor de entrada

cCar: UpCase( a );{cCar->’A’}cCar:=UpCase(‘?’);

,Chr(Numero) Carácter a partir de su número de

código ASCIIcCar:=Chr(65);{cCar->’A’}

Ord (Valor_Char) Número de código ASCII a partir de un carácter

iCod:=Ord(‘A’);{iCod->65}

P d (V l Ch ) C á t ASCII t i { i l } C P d(‘B’)Pred (Valor_Char) Carácter ASCII anterior {circular} cCar:=Pred(‘B’);

Succ (Valor_Char) Carácter ASCII siguiente {circular} cCar:=Succ(#255);

I (V Ch [ N ]) Si [ N ] I ( C ) { C >’B’}Inc(Var_Char [, Num]){circular}

Si [,Num]-> Var_Char:=Var_Char+[,Num]

Si no Var Char:=Var Char+1

Inc(cCar); {cCar->’B’}Inc(cCar, 3);{cCar->’D’}

Si no Var_Char:=Var_Char+1

Dec(Var_Char [, Num]){circular}

Si [,Num] -> Var Char:=Var Char-[ Num]

Dec(cCar); {cCar->’C’}Dec(cCar, 2);


{circular} > Var_Char: Var_Char [,Num]Si no Var_Char:=Var_Char-1

{cCar->’A’}

S bSubprogramas


IntroducciónHasta ahora -> Programas muy sencillos

Subprogramas escritos por otras personas. Write, Sqrt, Sin, Chr, UpCase, ClrScr, ReadKey, etc.Bibliotecas SYSTEM TPU y CRT TPUBibliotecas SYSTEM.TPU y CRT.TPUFuncionan como una CAJA NEGRA

Resuelven una tarea determinadaNo sabemos cómo (Sólo nos interesa el resultado)

Interfaz: Nombre + parámetrosrRaiz:= Sqrt(rDato);WriteLn(‘Raiz: ‘, rRaiz);

A ti d h S b iIsidro Calvo - DISA (UPV/EHU) 129

A partir de ahora -> Subprogramas propios

Ventajas

Reutilización de códigoN i ibi ódiNo es necesario reescribir código

Programas más compactosMás fácil comprobar su funcionamientoMás fácil comprobar su funcionamiento

Programas más robustos y fiablesBibliotecas de funciones

División de un problema complejo en otros más sencillos

Divide y vencerásColaboración entre varios programadores


p g

Diseño modular de programas

Diseño TOP – DOWND l é i l tDe lo genérico a lo concreto

Paso 1: Descripción amplia y general de lo que debe hacer el programap gPaso 2: División de la tarea en otras más simplesPaso 3 y siguientes: Subdivisiones de las tareas hasta otras más simplesotras más simples…=> Tareas simples y sencillas de programar

Aplicaciones grandes (p.e Word, Excel, …)


Diseño de subprogramasSubprogramas claros y sencillos con una misión únicamisión única

Mostrar datos de salidaObtener datos de entradaResolver un cálculoUtilizar otros módulos…

Módulos independientes (Cajas negras)Comunicación sólo con parámetros (no usarComunicación sólo con parámetros (no usar variables globales)


Modular vs. Orientada a objetos

ModularProgramación de módulos (subprogramas)

Funciones y procedimientosy p

Orientada a objetosOrientada a objetosProgramación de clases

éAtributos y métodos

Mayor independencia y abstracción


Tipos de subprogramas

ProcedimientosRealizan una tareaNo devuelven ningún valor explícitamenteEj: ClrScr, WriteLn, ReadLn,…

FuncionesEfectúan un cálculo y devuelven información que seEfectúan un cálculo y devuelven información que se guardará en una variableEj: Sqrt, Ln, ReadKey, UpCase, Chr,…


Ej: Sqrt, Ln, ReadKey, UpCase, Chr,…

Formas de ver un subprogramaDesde fuera:

¿Qué hace?¿Qué hace?Documentación (P.e. Descripción con comentarios)

¿Cómo usarlo? - InterfazParámetros de entrada, salida y valor de retorno

Desde dentro:Desde dentro:¿Cómo lo hace?

Código del subprograma¿Qué datos necesita y que resultados genera?

Parámetros de entrada, salida y valor de retorno


Ej lEjemplosPROGRAM Ej1; PROGRAM Ej1;VAR...PROCEDURE Haz Algo;

VARiRtdo:=Integer

FUNCTION fnr Haz Calculo: Integer;PROCEDURE Haz_Algo;BEGIN {Código Haz_Algo}WriteLn(‘Algo’);

FUNCTION fnr_Haz_Calculo: Integer;BEGIN {Código fnr_Haz_Calculo}

fnr_Haz_Calculo:= ...;END; {Fin Haz_Algo}

BEGIN {Prog. PPal}

END; {Fin fnr_Haz_Calculo}

BEGIN {Prog. PPal}BEGIN {Prog. PPal}...Haz_Algo;

BEGIN {Prog. PPal}...iRtdo:=fnr_Haz_Calculo;

...END. {Fin Prog. PPAL}

...END. {Fin Prog. PPAL}


PROGRAM Nombre;Cabecera SubPrograma1;

EjemplosBEGIN

Sentencias;END;Cabecera SubPrograma2;BEGIN

SentenciasLlamada a Subprograma SubPrograma2_1;

END;Cabecera SubPrograma2 1;g _ ;BEGIN

Sentencias;END;END;BEGIN

Llamada a Subprograma SubPrograma1;SentenciasSentenciasLlamada a Subprograma SubPrograma2;SentenciasLlamada a Subprograma SubPrograma1;


Llamada a Subprograma SubPrograma1;END.

Ej ió d bPROGRAM Ejecuta;

Ejecución de subprogramasPROGRAM Ejecuta;PROCEDURE Uno;BEGIN

Write('1');

...PROCEDURE Cuatro;BEGIN

Uno;Write( 1 );END;PROCEDURE Dos;BEGIN

Uno;Dos;Tres;Write('4');BEGIN

Write('2');END;PROCEDURE T

Write('4');END;BEGIN {Prog. Ppal}

W it ('S i ')PROCEDURE Tres;BEGIN

Write('3');U

Write('Secuencia: ');Dos;Cuatro;TUno;

END;...

Tres;WriteLn;

END. {FIN Prog. Ppal}


Definición de subprogramase c ó de subp og a as{SIN parámetros de entrada}PROCEDURE Haz_Algo;

{SIN parámetros de entrada}FUNCTION fnrCalc:Real;

VAR...

BEGIN

VARrDato: Real;

BEGIN...

END;...fnrCalc:= rDato*3;

ENDEND;

{CON parámetros de entrada} {CON parámetros de entrada}PROCEDURE Haz_Algo(rA:Real);VAR

FUNCTION fnrCalc (rA:Real):Real;VARrDato: Real;

rDatoInterno:Real;BEGIN

BEGIN...fnrCalc:= rDato*rA;


... END;

fnrCalc:= rDato*rA;END;

Uso de subprogramasp gPROGRAM Proc_Sin_Param;BEGIN {Prog. Principal}

PROGRAM Func_Sin_Param;BEGIN {Prog. Principal}

...HazAlgo;...

...rResul:=fnrCalc;......

END....

END.

PROGRAM Proc Con Param; PROGRAM Func Sin Param;PROGRAM Proc_Con_Param;VARrDato: Real;

PROGRAM Func_Sin_Param;VARrDato, rResul: Real;

BEGIN {Prog. Principal}...HazAlgo(rDato)

BEGIN {Prog. Principal}...rResul:= fnrCalc(rDato);g ( )

...END.

( );...

END.


PROGRAM Operaciones;VAR

FUNCTION fniSumar(iSuma1, iSuma2:Integer): Integer;

iOpcion, iRtdo, iA, iB: Integer;

PROCEDURE Restar;

g gBEGIN

fniSumar:= iSuma1 + iSuma2;END; {Acaba FUNCTION fniSumar};

{Empieza Procedure Titulo2}PROCEDURE Titulo2;BEGIN

; { }

BEGIN {Programa Principal}WriteLn('1. Sumar');G

WriteLn('Programa que resta’);END; {Acaba PROCEDURE Titulo2}

{Variables de Restar}

te ( . Su a );WriteLn('2. Restar');Write(‘Tu opcion? (1 o 2): ');ReadLn(iOpcion);{Variables de Restar}

VAR iOp1, iOp2: iNumero;

BEGIN {Codigo de Restar}

ReadLn(iOpcion);CASE iOpcion OF1: BEGIN

Write('a y b? ');BEGIN {Codigo de Restar}Titulo2;Write('Introduce a y b: ');ReadLn(iOp1 iOp2);

Write( a y b? );ReadLn(iA, iB);iRtdo:=fniSumar(iA, iB);WriteLn('Rtdo: ' iRtdo);ReadLn(iOp1, iOp2);

WriteLn('Rtdo: ',iOp1 - iOp2);END; {Acaba PROCEDURE Restar}

WriteLn( Rtdo: , iRtdo);END;

2: Restar;END;


END;END. {PROGRAM Operaciones}

PROGRAM Num_Combinatorio; {Programa que calcula nums combinatorios}VARVAR

i_M, i_N: Integer;rResul: Real;

FUNCTION fnrFactorial(iNum:Integer):Real; {Cálculo del Factorial}FUNCTION fnrFactorial(iNum:Integer):Real; {Cálculo del Factorial}VAR

i: Integer;rFactorial: Real;rFactorial: Real;

BEGINrFactorial:= 1;FOR i 1 TO iN m DOFOR i:=1 TO iNum DO

rFactorial:= rFactorial*i;fnrFactorial:= rFactorial;

ENDEND;BEGIN {Programa Principal}

Write('Introduce M y N? ');ReadLn(i_M, i_N);rResul:= fnrFactorial(i_N) * fnrFactorial(i_M - i_N);rResul:= fnrFactorial(i_M)/rResul;


WriteLn('Combinatorio: ', rResul:0:0);END.

Tipos de ParámetrosEntrada

Datos que el programa necesita para poder ejecutarseCondicionan la ejecución del subprogramaCondicionan la ejecución del subprograma

Los proporciona el módulo que invoca el subprogramaEj Biblioteca Estándar: Write, WriteLn

SalidaResultados obtenidos durante la ejecución del subprogramaEl módulo que invoca (‘llama’) al subprograma usa los datosEl módulo que invoca ( llama ) al subprograma usa los datosEj Biblioteca Estándar: Read, ReadLn

Entrada/SalidaEntrada/SalidaSon valores que se pasan al subprograma para que éste los utilicePueden ser modificados durante la ejecución del subprogramaEj Biblioteca Estándar: Inc, Dec


j ,

{Varios Parámetros de entrada de distintos tipos}PROCEDURE Haz Algo (iParam1, iParam2: Integer; cParam3:Char);_ g ( , g ; );...BEGIN {Programa Principal}

H Al (iN 1 iN 2 C )Haz_Algo(iNum1, iNum2, cCar);END.

{Parámetros de Salida}{Parámetros de Salida}PROCEDURE Haz_Algo (iParam: Integer; VAR cParam:Char);...BEGIN {Programa Principal}

Haz_Algo(iNum1, cCar);END.

{Parámetros de Entrada/Salida}PROCEDURE Haz_Algo (VAR iParam: Integer);_...BEGIN {Programa Principal}

Haz Algo(cCar);


Haz_Algo(cCar);END.

Ejemplo (Sin parámetros)

PROCEDURE Escribe20Asteriscos;BEGINBEGIN

WriteLn(‘********************’);END;

PROCEDURE Escribe20Asteriscos;VAR

i: Integer;: tege ;BEGIN

FOR i:=1 TO 20 DOW it (‘*’)Write(‘*’);

WriteLn;END;


Ejemplo (Con un parámetro)

{Un único parámetro de entrada}PROCEDURE EscribeAsteriscos (iLongitud: Integer);PROCEDURE EscribeAsteriscos (iLongitud: Integer);VAR

i: Integer;BEGIN

FOR i:=1 TO iLongitud DOWrite(‘*’);

WriteLn;END;


Ejemplo (Con dos parámetros)

{Dos parámetros de entrada}PROCEDURE EscribeCar (iLongitud: Integer; cCar: Char);PROCEDURE EscribeCar (iLongitud: Integer; cCar: Char);VAR

i: Integer;BEGIN

FOR i:=1 TO iLongitud DOWrite(cCar);

WriteLn;END;


Ejemplo (Parámetros de salida)PROGRAM Ecuacion;VAR

j p ( )

rN1,rN2,rN3,rN4,rN5,rN6,rN7,rN8:Real{6 parámetros de entrada y 2 de salida}PROCEDURE Ec1Grado(rA,rB,rC,rD,rE,rF:Real; VAR rX,rY:Real);( , , , , , , )BEGIN

rX:= (rC*rE-rB*rF)/(rA*rE-rB*rD);Y ( A* F C* D)/( A* E B* D)rY:= (rA*rF-rC*rD)/(rA*rE-rB*rD);

END;BEGIN {Programa Principal}

ReadLn(rN1,rN2,rN3,rN4,rN5,rN6);Ec1Grado(rN1,rN2,rN3,rN4,rN5,rN6,rN7,rN8);WriteLn(‘x: ‘ rN7 ‘ y: ‘ rN8);WriteLn( x: ,rN7, y: , rN8);

END.


Ejemplo (Pa ámet os de Ent /Sal){Dos parámetros de entrada/salida}

Ejemplo (Parámetros de Entr/Sal)

PROCEDURE Intercambiar (VAR iNum1, iNum2: Integer);VAR

iTemp: Integer;iTemp: Integer;BEGIN

iTemp:= iNum1;i 1 i 2iNum1:= iNum2;iNum2:= iTemp;


iA:= 3;iB:= 7;iB:= 7;Intercambiar(iA, iB);

END.


Parámetros formales vs. actualesPROGRAM Ecuacion;VAR

rN1,rN2,rN3,rN4,rN5,rN6,rN7,rN8:Real{6 parámetros de entrada y 2 de salida}PROCEDURE Ec1Grado(rA,rB,rC,rD,rE,rF: Real; VAR rX,rY:Real);( , , , , , , )BEGIN

rX:= (rC*rE-rB*rF)/(rA*rE-rB*rD);Y ( A* F C* D)/( A* E B* D)rY:= (rA*rF-rC*rD)/(rA*rE-rB*rD);


Param Formales

ReadLn(rN1,rN2,rN3,rN4,rN5,rN6);Ec1Grado( rN1,rN2,rN3,rN4,rN5,rN6,rN7,rN8 );WriteLn(‘x: ‘ rN7 ‘ y: ‘ rN8);WriteLn( x: ,rN7, y: , rN8);

END. Param Actuales


Parámetros formales vs. actuales

Parámetros formalesFuncionan como variables locales al subprogramaSon inicializadas con el valor del parámetro actual o una referencia al mismoreferencia al mismo

Parámetros actualesExpresiones (constantes, variables, funciones o expresiones) cuyos tipos sean iguales o compatibles a los p. formales

NOTA: Los parámetros formales y actuales deben coincidir en número, posición y tipo


Paso de ParámetrosValor

Parámetros de entradaCopia del parámetro actual usada en el subprogramaCopia del parámetro actual usada en el subprogramaSi se modifica su valor NO afecta al parámetro actual

ReferenciaReferenciaParámetros de salida y entrada/salida

Es un enlace a una variableSi se modifica su valor SI afecta al parámetro actualSe indica con la palabra VAR

ConstanteParámetros de entrada

Datos constantes dentro del subprograma (no se pueden modificar)Más eficiente que el paso por valor con datos de gran tamañoSe indica con la palabra CONST


Se indica con la palabra CONST

Paso por Valor (Stack o pila)PROCEDURE Nombre (iUno, iDos:Integer;

cTres: Char); VAR

…

‘A’ cTres SubprogramaiLocal

VAR iLocal: Integer;

BEGIN

‘A’

32

-3

cTres

iDos

iUno

SubprogramaNombre

...END;BEGIN {Programa Principal}

...

-3

3

iNumero

b Ed dProgramaBEGIN {Programa Principal}

...Nombre (iNumero, byEdad+29,

3

‘a’

byEdad

cLetraPrincipal

UpCase(cLetra));...

END.


Llamada al subprograma p g(Paso por Valor)

1. Se almacena en la pila (stack) la dirección de retorno del subprogramap g

2. Se crean en la pila nuevas variables:Parámetros formalesV i bl l lVariables locales

3. Se inician los parámetros formales con el valor de los parámetros actualeslos parámetros actuales

4. Se ejecutan las sentencias del subprograma5. Se eliminan los parámetros formales y variables p y

locales6. Se retorna el flujo de control al módulo que llama


Paso por Referencia o direcciónPROCEDURE Nombre (VAR iUno: Integer;

iDos:Integer;iDos:Integer;VAR cTres: Char);

BEGIN

10000001

32

10000100

cTres

iDos SubprogramaNombre

10001110

1000110010001000...


10000100

...

-3 iNumero

iUno10001000

10000100...Nombre (iNumero,

byEdad+29,

3

‘a’byEdad

cLetra

ProgramaPrincipal10000010

10000001cLetra);

...END.


Llamada al subprograma p g(Paso por Referencia)

1. Se almacena en la pila (stack) la dirección de retorno del subprograma

2. Se crean en la pila nuevas variables:Parámetros formalesVariables locales

3. Se inician los parámetros formales con la direcciónde los parámetros actualesSe ejecutan las sentencias del subprograma4. Se ejecutan las sentencias del subprograma (Pudiendo ser modificado indirectamente el contenido de las variables del módulo que llama)

l l á f l bl5. Se eliminan los parámetros formales y variables locales

6 Se retorna el flujo de control al módulo que llama


6. Se retorna el flujo de control al módulo que llama

Parámetros constantesSólo válido para parámetros de entradaNo se copia la variable en memoriaNo se copia la variable en memoria

Se pasa una referencia

íSe prohíbe modificar su valorNo se puede pasar por referencia a otro p p psubprogramaSe indica con CONSTSe indica con CONSTEs más eficiente que el paso por valor (sobre todo con variables de gran tamaño)


todo con variables de gran tamaño)

ResumenValor Referencia Constante

Parámetros de Entrada Parámetros de Salida Parámetros de Entrada

Resumen

Parámetros de Entrada Parámetros de SalidaEntrada/Salida

Parámetros de Entrada

Parámetro Formal: Parámetro Formal: Parámetro Formal:Parámetro Formal:Variable inicializada con el

valor del p. actual

Parámetro Formal:Variable inicializada con

la dirección del p. actual

Parámetro Formal:Busca máxima eficiencia

en el paso de parámetrosLas modificaciones en los p.

formales no se reflejan en los p. actuales

Las modificaciones en los p. formales se reflejan en los p. actuales

Se pasa por valor o referencia en base al tamaño de las variables. p p

Precedidas por VAR Precedidas por CONSTParámetro actual: Parámetro actual: Parámetro actual:Expresiones compatibles

con el p. formal (Constantes variables

Variable del mismo tipo que el p. formal

Expresiones compatibles con el p. formal


(Constantes, variables, funciones o expresiones)

SintaxisPaso por valor

Ident parametro : Ident tipo

,

Ident. parametro : Ident. tipo

Paso por referencia

VAR Ident. parametro : Ident. tipo

Parámetro constante

,

Parámetro constante

CONST Ident. parametro : Ident. tipo


,

PROGRAM Ent_Dec;VARrNumero, rOutEntera, rOutDecimal: Real;

PROCEDURE EnteraDec(rNum: Real; VAR rEntera, rDecimal: Real);

BEGINrEntera:= Int(rNum);rEntera:= Int(rNum);rDecimal:= Frac(rNum);

END;

BEGIN {Programa Principal}Write('Dame un numero real: ');Write( Dame un numero real: );ReadLn(rNumero);EnteraDec(rNumero, rOutEntera, rOutDecimal);WriteLn('Parte entera: ', rOutEntera:0:0,

' Parte decimal: ', rOutDecimal:0:3);END.


Procedimientos vs. Funciones (Cuándo usar Procedimientos)Sentencias agrupadas que realizan una tarea concretaPueden tener parámetros de Entrada, Salida o Entrada / Salida/Estructura (Igual que la de un programa salvo la cláusula USES))

CabeceraBloque

Definiciones y declaracionesBloque de sentencias

Llamada al procedimiento


Llamada al procedimiento

Procedimientos (Sintaxis cabecera)

PROCEDURE Identificador

Lista Parámetros Formales

;

( )Lista Parámetros Formales( )


VAR ,

CONST;


Procedimientos (Sintaxis llamada)

Identificador Procedimiento

Lista Parámetros Actuales( )Lista Parámetros Actuales( )

expresión

variable

expresión

,


PROGRAM InterCambiar;VARVAR

iA, iB: Integer;PROCEDURE Intercambiar (VAR iNum1, iNum2: Integer);VAR

iTemp: Integer;BEGIN

iTemp:= iNum1;iNum1:= iNum2;iN 2 iTiNum2:= iTemp;


Write(‘Introduce 2 N. enteros: ‘)ReadLn(iA, iB);IF iA > iB THENIF iA > iB THENIntercambiar(iA, iB);

WriteLn(‘Ordenados de menor a mayor son: ‘, iA, iB);


END.

Procedimientos vs. Funciones (Cuándo usar Funciones)

Subprograma cuya principal finalidad es obtener UN ÚNICO VALOR.Estructura (Igual que la de un programa salvo la cláusula USES y la declaración del valor devuelto)

CabeceraCabeceraBloque

Definiciones y declaracionesBloque de sentenciasBloque de sentencias

Llamada a una funciónNOTA: En la declaración de las funciones se permite usar el paso por referencia para utilizar parámetrosusar el paso por referencia para utilizar parámetros de salida y E/S. (-> SE RECOMIENDA usar un procedimiento)


( p )

Funciones (Sintaxis cabecera)

FUNCTION Identificador

Lista Parámetros Formales( )Lista Parámetros Formales( )

Ident Tipo Resultado: ;Ident. Tipo Resultado: ;

VAR ,


CONST;


Funciones (Sintaxis llamada)

Identificador Función

Lista Parámetros Actuales( )Lista Parámetros Actuales( )

expresión

variable

expresión

,


PROGRAM Num_Combinatorio; {Programa que calcula nums combinatorios}VARVAR


FUNCTION fnrFactorial(iNum:Integer):Real; {Cálculo del Factorial}FUNCTION fnrFactorial(iNum:Integer):Real; {Cálculo del Factorial}VAR

i: Integer;rFactorial: Real;rFactorial: Real;

BEGINrFactorial:= 1;FOR i 1 TO iN m DOFOR i:=1 TO iNum DO

rFactorial:= rFactorial*i;fnrFactorial:= rFactorial;

ENDEND;BEGIN {Programa Principal}

Write('Introduce M y N? ');ReadLn(i_M, i_N);rResul:= fnrFactorial(i_N) * fnrFactorial(i_M - i_N);rResul:= fnrFactorial(i_M)/rResul;



PROCEDURE EsPrimo(iNumero: Integer; VAR boEsPrimo:Boolean);VARVAR

j: Integer;BEGIN

j:=2;j:=2;boEsPrimo:=True;WHILE boEsPrimo AND (j <= iNumero DIV 2) DO

BEGINBEGINIF iNumero MOD j = 0 THEN

boEsPrimo:=False;j j 1j:=j+1;END;

END;

BEGIN {Programa Principal}Write(‘Dame un numero: ‘);ReadLn(iNum);EsPrimo(iNum, boPrimo);...

END.


FUNCTION fnboEsPrimo(iNumero: Integer):Boolean;VARVAR

j: Integer;boEsPrimo: Boolean;

BEGINBEGINj:=2;boEsPrimo:=True;WHILE boEsPrimo AND (j <= iNumero DIV 2) DOWHILE boEsPrimo AND (j <= iNumero DIV 2) DO

BEGINIF iNumero MOD j = 0 THEN

boEsPrimo:=False;boEsPrimo:=False;j:=j+1;END;

fnboEsPrimo: boEsPrimo;fnboEsPrimo:= boEsPrimo;END;

BEGIN {Programa Principal}Write(‘Dame un numero: ‘);ReadLn(iNum);IF fnboEsPrimo(iNum) THEN


WriteLn(iNum, ‘ es un número primo!’);END.

Identificadores locales y globales

Región del programa en la que se puedeRegión del programa en la que se puede usar un identificador

Ámbito / Alcance / Dominio de visibilidad del / /identificador

GlobalLocalLocal

Aplicable a:VariablesFunciones / procedimientos


PROGRAM Gl b l L lPROGRAM Global_Local;CONSTTOPE=1;

FUNCTION fniCalcular(p,j: Integer):Integer;

VARi, j, k: Integer;a b c: Real;

VARk: Integer;a b: Real;a, b, c: Real;

PROCEDURE LeerDatos(VAR x,y: Real);

a,b: Real;BEGIN {fniCalcular}...

VARl, m: Integer;z: Real;

END; {FIN fniCalcular}

BEGIN {Programa Principal};BEGIN {LeerDatos}...

END {FIN L D t }

{ g p }...

END. {FIN Programa Principal}END; {FIN LeerDatos}


PROGRAM Global_Local;CONST

TOPE=1;VAR

i, j, k: Integer;a, b, c: Real;

PROCEDURE LeerDatos (VAR x,y: Real);VAR

l, m: Integer; z: Real;FUNCTION fniCalcular (p,j: Integer):Integer;VAR

k: Integer; a, b: Real;BEGIN {fniCalcular}

...END; {FIN fniCalcular}

BEGIN {LeerDatos}...

END; {FIN LeerDatos}BEGIN {Programa Principal}

...


...END. {FIN Programa Principal}

PROGRAM Global_Local;VAR

FUNCTION fniCalcular(p,j: Integer) :Integer;

i, j, k: Integer;a, b, c: Real;

g ;VARk: Integer;a,b: Real;

PROCEDURE LeerDatos(VAR x,y: Real);

VAR

a,b: Real;BEGIN {fniCalcular}p:=10; j:=20; k:=30; a:=40;b:=50;VAR

l, m: Integer;z: Real;

BEGIN {LeerDatos}

b: 50;WriteLn(i,j,k,a,b,c,x,y,l,m,z);fniCalcular:= p+ j;

END; {FIN fniCalcular}BEGIN {LeerDatos}x:=1; y:=2; l:=3; m:=4; z:=5;WriteLn(‘2 numeros?’);

END; {FIN fniCalcular}

BEGIN {Programa Principal}i:= 1;j:= 2;k:= 3;a:= 4;b:= 5;c:=WriteLn(‘2 numeros?’);

ReadLn(x, y);WriteLn(i,j,k,c,x,y,l,m,z);

END {FIN LeerDatos}

i:=-1;j:=-2;k:=-3;a:=-4;b:=-5;c:=-6;LeerDatos(a, b);WriteLn(i j k a b c x y l m z);END; {FIN LeerDatos} WriteLn(i,j,k,a,b,c,x,y,l,m,z);i:= -100; j:= -200;WriteLn(‘fniCalcular: ',

fniCalcular(i j));


fniCalcular(i, j));WriteLn(i,j,k,a,b,c,x,y,l,m,z);

END. {FIN Programa Principal}

Variables globales:Variables globales: (Efectos secundarios)

Rompen con el concepto de CAJA NEGRALos programas pierden independenciaLos programas pierden independenciaMás difíciles de depurarPueden afectar al módulo que llamaPueden producir resultadosPueden producir resultados inesperados


PROGRAM InterCambiar;VARVAR

iA, iB, iTempGlobal: Integer;PROCEDURE Intercambiar (VAR iNum1, iNum2: Integer);BEGIN

iTempGlobal:= iNum1;iNum1:= iNum2;;iNum2:= iTempGlobal;

END;BEGIN {P P i i l}BEGIN {Programa Principal}

Write(‘Introduce 3 N. enteros: ‘)ReadLn(iA, iB, iTempGlobal);Intercambiar(iA, iB);WriteLn(iA,‘,‘,iB,‘,‘,iTempGlobal);

ENDEND.


RecursividadUn programa puede llamarse a sí mismoSe ejecuta sucesivamente sobre la pilaSe ejecuta sucesivamente sobre la pilaEs necesario controlar la recursividad (D b h b t i di i l(Debe haber una sentencia condicional que permita terminar la recursividad, si no se entraría en un lazo infinito)


PROGRAM Num_Combinatorio; VARVAR


FUNCTION fnrFact (iNum:Integer):Real;BEGINIF iNum <> 0 THEN

fnrFact:= iNum * fnrFact(iNum-1) {Llamada recursiva}ELSE

fnrFact:= 1; {Fin de la recursividad}fnrFact:= 1; {Fin de la recursividad}END;

BEGIN {Programa Principal}Write('Introduce M y N? ');ReadLn(i M, i N);ReadLn(i_M, i_N);rResul:= fnrFact(i_N) * fnrFact(i_M - i_N);rResul:= fnrFact(i_M) / rResul;

i ( bi i l 0 0)



Términos de la serie de FibonacciPROGRAM Fibonacci;VAR

iNum: Integer;

é os de a se e de bo acc

iNum: Integer;FUNCTION fniFibonacci(n:Integer):Integer;BEGINIF 0 THENIF n=0 THEN

fniFibonacci:=0ELSE IF n=1 THEN

f iFib i 1fniFibonacci:=1ELSE

fniFibonacci:= fniFibonacci(n-1)+fniFibonacci(n-2);END;BEGIN

WriteLn('Calculo del termino n de la serie de fibonacci');Write('N? ');ReadLn(iNum);WriteLn('El termino ', iNum, ' de la serie es: ',


fniFibonacci(iNum));END.

Recursividad vs. IteraciónMuchos algoritmos pueden ser descritos de f i it tiforma recursiva o iterativaLas definiciones recursivas son más compactasNormalmente son menos eficientes (más (tiempo de ejecución, mas memoria, mayor complejidad conceptual)p j p )Posibilidad de recursión infinita.


Generación deGeneración de números aleatorios

Ej: Programa de adivinar un númeroSecuencias seudoaleatorias: Secuencias de números sin ninguna relación aparente entre síNormalmente se repiten en periodos determinados (Ej: Máquinas tragaperras)( j q g p )Se asocia una “semilla“ (normalmente asociada al reloj del sistema) para hacer lasasociada al reloj del sistema) para hacer las secuencias más impredecibles


Random y RandomizeSubprogramas propios de TurboPascalP it ú l t iPermiten generar números aleatoriosRandom: Función que retorna un número l t ialeatorio Entero (0 .. N-1) iNum:=Random(100);

Rango 0 65535Rango 0 .. 65535Real (0.0 <= N <1.0) rNum:=Random;

Randomize: Procedimiento que inicializa elRandomize: Procedimiento que inicializa el generador de números aleatorios (la semilla)

Randomize;


Randomize;

Ejemplo{Generación de números aleatorios enteros entre 0 y 9}PROGRAM Aleatorios;VARVARi: Integer;

BEGIN{Randomize;}FOR i:=1 TO 10 DO

{Números aleatorios enteros entre 0 y 9}Write(Random(10), ', ');

WriteLn;WriteLn;WriteLn('************************************');

END.


Ejemplosje p os{Números aleatorios 0..99}iNumAleatorio := Random(100);

{Números aleatorios reales en el intervalo [0.0, 1.0) }rNumAleatorio := Random;rNumAleatorio := Random;

{Letra aleatoria entre ‘a’..’z’}cLetra := Chr(Random(Ord('z')-Ord('a')+1)+Ord('a'));

{Número aleatorio entre ‘1900’ ’2006’}{Número aleatorio entre 1900 .. 2006 }iNumero := 1900+Random(2003-1900+1) ;

{Número aleatorio entre ‘-5’..’28.5’}rNumero := 33.5*Random – 5.0 ;


{Comprueba si un año es bisiesto o no}FUNCTION fnboEsBisiesto(iAnyo: Integer): Boolean;y g{Calcula los años bisiestos entre dos años dados}FUNCTION fniBisiestos(iAnyo1, iAnyo2: Integer): Integer;{Obtiene el ultimo dia de un mes de un determinado año}{ }FUNCTION fniMaxMes(iMes, iAnyo: Integer): Integer;{Averigua que día del año corresponde a una fecha}FUNCTION fniDiaDelAnyo(iDia, iMes, iAnyo: Integer): Integer;U C O a e yo( a, es, yo: tege ): tege ;{Averigua que día de la semana corresponde un día del año}FUNCTION fniDiaSemana(iDia, iComienzo: Integer): Integer;{Elimina sobrepasos en las fechas (Ej: 32/1/95 -> 1/2/95)}{Elimina sobrepasos en las fechas (Ej: 32/1/95 > 1/2/95)}PROCEDURE FechaCorrecta(VAR iDia, iMes, iAnyo: Integer);{Muestra un menú en pantalla para seleccionar una opción válida}FUNCTION fnchMenu: Char;FUNCTION fnchMenu: Char;{Opción 1: Cálculo de años bisiestos}PROCEDURE Opcion1;{Opción 2: Calcula los días transcurridos de un año}{Opción 2: Calcula los días transcurridos de un año}PROCEDURE Opcion2;{Opción 3: Calcula la fecha de vuelta de vacaciones}PROCEDURE Opcion3;


PROCEDURE Opcion3;{ Programa Principal }

ProgramaPrincipal

fncMenu Opcion1 Opcion2 Opcion3

p

:Char

p p

f iBi i t f iDi D lA f iDi S F h C t

p

fniBisiestosiAnyo1iAnyo2

:Integer

fniDiaDelAnyoiDia :IntegeriMesiAnyo

fniDiaSemanaiDia :Integer

iComienzo

FechaCorrectaiDiaiMesiAnyo

fnboEsBisiesto

iAnyo yo

fniMaxMes fniMaxMesfnboEsBisiestoiAnyo :Boolean

fniMaxMesiMes :IntegeriAnyo

fniMaxMesiMes :IntegeriAnyo

fnboEsBisietoiAnyo :Boolean

fnboEsBisietoiAnyo :Boolean


{Comprueba si un año es bisiesto o no}FUNCTION fnboEsBisiesto(iAnyo: Integer): Boolean;y gVAR

boEsBisiesto: Boolean;BEGIN

IF iAnyo MOD 400 = 0 THENboEsBisiesto:=TRUE

ELSE IF iAnyo MOD 100 = 0 THENS yo O 00 0boEsBisiesto:= FALSE

ELSE IF iAnyo MOD 4 = 0 THENboEsBisiesto:= TRUEboEsBisiesto: TRUE

ELSEboEsBisiesto:= FALSE;

fnboEsBisiesto:= boEsBisiesto;fnboEsBisiesto:= boEsBisiesto;END;


{Calcula los años bisiestos entre dos años dados}FUNCTION fniBisiestos(iAnyo1, iAnyo2: Integer): Integer;y y g g

VARi, iBisiestosEnMedio:Integer;

BEGINBEGINiBisiestosEnMedio:=0;FOR i:= iAnyo1 TO iAnyo2 DO

IF fnboEsBisiesto(i) THENInc(iBisiestosEnMedio);

fniBisiestos:=iBisiestosEnMedio;fniBisiestos: iBisiestosEnMedio;END;


{Obtiene el último día de un mes de un determinado año}FUNCTION fniMaxMes(iMes, iAnyo: Integer): Integer;y g gVAR

iMaximo: Integer;BEGIN

CASE iMes OF1,3,5,7,8,10,12: iMaximo:= 31;2: IF fnboEsBisiesto(iAnyo) THEN: bo s s esto( yo)

iMaximo:= 29ELSE

iMaximo:= 28;iMaximo: 28;4,6,9,11: iMaximo:= 30;

END;fniMaxMes:= iMaximo;fniMaxMes:= iMaximo;

END;


{Averigua que día del año corresponde a una fecha}FUNCTION fniDiaDelAnyo(iDia, iMes, iAnyo: Integer): Integer;y y g gVAR

iDias, i: Integer;BEGIN

iDias:=iDia;{La funcion va sumando 31, 30, 28 o 29 en funcion del mes y año}FOR i:= 1 TO iMes-1 DOO : O es O

BEGINiDias:= iDias + fniMaxMes(i, iAnyo);END;END;

fniDiaDelAnyo:= iDias;END;

{Averigua que día de la semana corresponde un día del año}FUNCTION fniDiaSemana(iDia, iComienzo: Integer): Integer;BEGINBEGIN

fniDiaSemana:= (iDia + iComienzo -1) MOD 7;END;


{Elimina sobrepasos en las fechas (Ej: 32/1/95 -> 1/2/95)}PROCEDURE FechaCorrecta(VAR iDia, iMes, iAnyo: Integer);y gVAR

iMaximo: Integer;BEGIN

iMaximo:= fniMaxMes(iMes, iAnyo);{ Mejor WHILE: Los días de vacaciones pueden ser más de un mes.

Ej: Fecha inicio: 31/1/2006 + 31 -> 3/3/2006}j: ec a c o: 3 / / 006 3 3/3/ 006}WHILE iDia > iMaximo DO

BEGINiDia:= iDia - iMaximo;iDia: iDia iMaximo;IF iMes < 12 THEN

Inc(iMes)ELSEELSE

BEGINiMes:= 1;Inc(iAnyo);Inc(iAnyo);END;

iMaximo:= fniMaxMes(iMes, iAnyo);END;


END;END;

{Muestra un menú en pantalla para seleccionar una opción válida}FUNCTION fnchMenu: Char;VAR

cOpcion: Char;BEGIN

REPEATWriteLn('1. Calculo de años bisiestos');WriteLn('2. Dias transcurridos de un año');te ( . as t a scu dos de u a o );WriteLn('3. Vacaciones anuales');WriteLn('0. Salida');Write('Teclea la opcion escogida: ');Write( Teclea la opcion escogida: );ReadLn(cOpcion);IF (cOpcion < '0') OR (cOpcion > '3') THEN

BEGINBEGINWriteLn('Has introducido una opcion no valida');WriteLn('Introduce otra opcion');WriteLn;WriteLn;END;

UNTIL (cOpcion >= '0') AND (cOpcion <= '3');fnchMenu:= cOpcion;


fnchMenu:= cOpcion;END;

{Opción 1: Cálculo de años bisiestos}PROCEDURE Opcion1;pVAR

iAnyo1, iAnyo2: Integer;BEGIN

WriteLn;Write('Introduce el intervalo (año inferior-año superior): ');ReadLn(iAnyo1, iAnyo2);ead ( yo , yo );WHILE iAnyo1 > iAnyo2 DO

BEGINWriteLn;WriteLn;WriteLn('El primer año es menor que el segundo. ');Write('Introduce el intervalo (año inferior-año superior): ');ReadLn(iAnyo1 iAnyo2);ReadLn(iAnyo1, iAnyo2);END;

WriteLn;WriteLn('Hay ' fniBisiestos(iAnyo1 iAnyo2)WriteLn( Hay , fniBisiestos(iAnyo1, iAnyo2),

' años bisiestos entre los años ', iAnyo1, ' y ', iAnyo2);

END;


END;

{Opción 2: Calcula los días transcurridos de un año}PROCEDURE Opcion2;VAR

iDia, iMes, iAnyo, iComienzo, iDiaAnyo, iDiaSemana: Integer;BEGIN

Write(‘Introduce (Dia Mes Año): ');ReadLn(iDia, iMes , iAnyo);Write('Dia de la semana correspondiente al comienzo del año: ');ReadLn(iComienzo); {Dia 0-Domingo .. 6-Sábado}iDiaAnyo:=fniDiaDelAnyo(iDia, iMes, iAnyo);iDiaSemana:= fniDiaSemana(iDiaAnyo, iComienzo);WriteLn('Dias transcurridos: ', iDiaAnyo);CASE iDiaSemana OF

1: WriteLn('Dia de la semana: Lunes');2: WriteLn('Dia de la semana: Martes');3: WriteLn('Dia de la semana: Miercoles');4: WriteLn('Dia de la semana: Jueves');5: WriteLn('Dia de la semana: Viernes');6: WriteLn('Dia de la semana: Sabado');0: WriteLn('Dia de la semana: Domingo');


( g )END;

END;

{Opción 3: Calcula la fecha de vuelta de vacaciones}PROCEDURE Opcion3;pVAR

iDia, iMes, iAnyo, iVacaciones: Integer;BEGIN

WriteLn;WriteLn('Introduce la fecha de principio de vacaciones: ');Write(‘Introduce (Dia Mes Año): ');te( t oduce ( a es o): );ReadLn(iDia, iMes , iAnyo);Write('Introduce el numero de dias de vacaciones: ');ReadLn(iVacaciones);ReadLn(iVacaciones);iDia:= iDia + iVacaciones;FechaCorrecta(iDia, iMes, iAnyo);WriteLn;WriteLn;Write('Tienes vacaciones hasta el dia: ',

iDia, '/', iMes, '/', iAnyo);WriteLn;WriteLn;

END;


{ Programa Principal }BEGIN

ClrScr;cOpcion:=fnchMenu;WHILE cOpcion <> '0' DOp

BEGINCASE cOpcion OF

'1': Opcion1;: Opc o ;'2': Opcion2;'3': Opcion3;END;END;

cOpcion:=fnchMenu;END;

ENDEND.


C d dCadenas de caracteres


Tipos definidos por el usuarioHasta ahora -> Siempre tipos simples predefinidos (Integer, Real, Boolean, Char)predefinidos (Integer, Real, Boolean, Char)

Conocidos por el compiladorCaracterísticas (Rango de valores, Espacio de ( g , palmacenamiento y Operaciones permitidas)

Nuevos tipos de datos Definidos por el programador a partir de tipos básicos

Tipos simples Tipos est ct ados (Cadenas a a s egist os )Tipos estructurados (Cadenas, arrays, registros, …)

Mejoran la claridad del programa Mismas operaciones que sobre los tipos básicos


Mismas operaciones que sobre los tipos básicos

Definición de tipos : Sintaxis

TYPE Declaración de tipo ;

Identificador = TipoIdentificador Tipo


Tipos simples definidosTipos simples definidos por el programador

Definidos por el programador a partir de tipos básicos

Integer, Real, Char, Boolean

Asignación de un identificador de tipo (un alias))

Mejoran la claridad del programa

Mismas operaciones que sobre los tiposMismas operaciones que sobre los tipos básicos


PROGRAM Tipos;TYPETYPEtcLetrasMayusculas= 'A'..'Z';tiEdad= Integer;

20030 10tlFecha= LongInt; {20030410}tlTiempo = LongInt;{23:59:59 -> 23*3600 + 59*60 + 59 = 86399}{23:59:59 -> 235959}

VARcLetra: tcLetrasMayusculas;cLetra: tcLetrasMayusculas;cResp: Char;Anyos: tiEdad;Hoy, Manyana, Pasado: tlFecha;HoraDesayuno, HoraComida, HoraCena: tlTiempo;

BEGINBEGINcLetra:='M';Hoy:=20060327;


END.

PROGRAM Tipos;CONSTOK=0; {Cualquier número salvo el 0 representa un error}

TYPEtiSTATUS I ttiSTATUS: Integer;

VARiCodError: tiSTATUS;

FUNCTION fntHazAlgo(iNum: Integer): tiSTATUS;BEGINIF THENIF … THENfntHazAlgo:= iCodigoError {Código de error asociado}

ELSEfntHazAlgo:= OK;

END;BEGINIF fntHazAlgo(iNumero) = OK THEN

…END


END.

Tipos estructurados

Siempre definidos por el programador a partir de los tipos básicostipos básicos

Agrupan varias variables de los tipos básicosInteger, Real, Char, BooleanInteger, Real, Char, Boolean

Asignación de un identificador de tipo (un alias)Espacio en memoria (igual que la suma de los tiposEspacio en memoria (igual que la suma de los tipos básicos + información de gestión)Operaciones:p

Sobre el nuevo estructura como un todoSobre los componentes individuales


Tipo Cadena (STRING)Definido a partir del tipo Char

Es una agrupación de caracteresEs una agrupación de caracteresSe utiliza para representar palabras, frases, etc

Tipos de operacionesTipos de operacionesDe modo conjunto (sobre la variable de tipo STRING como un todo)Sobre los caracteres individuales

No existe en PASCAL estándarEs un caso particular del tipo ARRAYMuy sencillo de utilizar y muy útil


Muy sencillo de utilizar y muy útil

Sintaxis y yRepresentación en memoria

STRING Entero sin signo(N Char 0 255) ][ (N. Char 0..255)

5 ‘a’ ‘d’ ‘i’ ‘o’ ‘s’

1 byte 1 byte 1 byte 1 byte 1 byte 1 byte

sCadena 5 a d i o s

Indices 0 1 2 3 4 5

sCadena

4 ‘h’ ‘o’ ‘l’ ‘a’ ?sCadena


EjemploPROGRAM Cadenas;TYPE

b [20]tsNombres= STRING[20];tsProverbios= STRING[120];

VARsNombre: tsNombres;sFrase: STRING[100];sRefran: tsProverbios;sRefran: tsProverbios;

BEGINWrite(‘Dime tu nombre: ‘);ReadLn(sNombre);Write(‘Escribe algo: (menos de 100 caracteres) ‘);ReadLn(sFrase);ReadLn(sFrase);sRefran:= ‘A quien madruga Dios le ayuda’;WriteLn(‘Hola, ‘, sNombre, ‘ Has escrito: ‘, sFrase);W it L (‘U f á ‘ R f )


WriteLn(‘Un refrán: ‘, sRefran);END.

Uso de cadenas en programas

La estructura completaCon un identificador o nombre de la variableCon un identificador o nombre de la variableEj: sCadena, sVariableCadena

Los caracteres individuales de la cadena

Valor del índiceVariable String [ ]

Ej: sCadena[1], sVariableCadena[iIndex]


Ejemplosje p osTYPEtsCadenas=STRING[10];

TYPEtsCadLarga= STRING[80];

VARsCad1, sCad2: tsCadenas;

BEGIN

VARi, iLong: Integer;sCad: tsCadLarga;

sCad1:= ‘HOLA’;sCad2:= ‘ADIOS’;W it (‘E ib l ‘)

gBEGINWrite(‘Longitud de cadena: ‘);R dL (iL )Write(‘Escribe algo: ‘);

ReadLn(sCad1);sCad2:= ‘Soy una cadena’;

ReadLn(iLong);Write(‘Escribe la cadena: ‘);FOR i:=1 TO iLong DO

WriteLn(sCad2);sCad2[0]:= 3;sCad2[0]:= Chr(3);

BEGINWrite(‘Carácter[‘,i,’]=’);sCad[i]:=ReadKey;sCad2[0]:= Chr(3);

sCad1:= sCad2;WriteLn(sCad1);

sCad[i]:=ReadKey;END;

sCad[0]:= Chr(iLong);


END. END.

EjemplosEjemplosPROCEDURE ReadLn2(VAR sCadena: STRING);PROCEDURE ReadLn2(VAR sCadena: STRING);VARcCar: Char;i: Integer;

BEGINcCar:= ReadKey;cCar: ReadKey;i:=0;WHILE cCar <> #13 DO {#13 -> Retorno de carro}BEGINi:= i + 1;sCadena[i]:= cCar;cCar:= ReadKey;END;

sCad[0]:= i;


sCad[0]:= i;END.

Longitud de la cadenaEl byte 0 de la cadena contiene su longitudFormas de averiguar la longitud de laFormas de averiguar la longitud de la cadena:

iLongitud: Ord(sNombreApellidos[0])iLongitud:=Ord(sNombreApellidos[0]);iLongitud:=Length(sNombreApellidos);

!CUIDADO! -> Si un programa realiza operaciones que cambian la longitud de laoperaciones que cambian la longitud de la cadena, se debe reflejar en el byte 0


EjemplosEjemplosTYPEtsCadLarga= STRING[80];tsCadLarga= STRING[80];

VARi, iLong, iSuma: Integer;sCad: tsCadLarga;

BEGINWrite(‘Escribe una cadena: ‘);( );ReadLn(sCad);iLong:= Ord(sCad[0]);iS 0iSuma:= 0;FOR i:= 1 TO iLong DOiSuma:= iSuma + Ord(sCad[i]);

WriteLn(‘Suma: ‘, iSuma);END.


PROGRAM Espacios;TYPEtsCad= STRING[70];

VARbyLong i: Byte;byLong, i: Byte;sCadIn, sCadOut: tsCad;

BEGINWrite('Cadena: ');ReadLn(sCadIn);byLong:=0;y gFOR i:=1 TO Length(sCadIn) DO

IF sCadIn[i]<>' ' THENBEGINBEGINbyLong:=byLong +1;sCadOut[byLong]:=sCadIn[i];END;

sCadOut[0]:=Chr(byLong);END


END.

Operaciones con cadenasOperaciones con cadenas(Lectura y escritura)

Write / WriteLnEj: WriteLn(sCadena: iAnchura);Ej: WriteLn(sCadena: iAnchura);

Read / ReadLnRead (Deja en el buffer de teclado los caracteres ( jno leídos)ReadLn (Los caracteres no asignados a la cadena son borrados)


EjemploPROGRAM LeerCadena;TYPE

tsCadenas = String [10];VAR

sUnaCadena sOtraCadena: tsCadenas;sUnaCadena, sOtraCadena: tsCadenas;BEGIN

Write (‘Escribe una frase: ‘);( );Read (sUnaCadena); WriteLn(‘Escribe otra frase: ‘);Read (sOtraCadena);WriteLn;WriteLn(‘ sUnaCadena: #’ sUnaCadena ‘#’);WriteLn(‘ sUnaCadena: #’, sUnaCadena, ‘#’);WriteLn(‘sOtraCadena: #’, sOtraCadena, ‘#’);

END.


Operaciones con cadenasOperaciones con cadenas(Operadores)

Asignación -> ':=' (Expresiones cadena o carácter)Ej: sCadena:= 'Soy una cadena';Ej: sCadena:= Soy una cadena ;

sCad:= ''; sCad:=#65; sCad:=UpCase('c');

Concatenación -> '+'Concatenación > +Ej: sNombreApellidos:= 'Jon' + ' ' + 'Iza';

Comparación -> '=' '<>' '>' '<' '>=' '<='Comparación -> = , <> , > , < , >= , <=Ej: boResul:= sNombre = 'Pepe'; {Cod ASCII}

boResul:= sFecha = '20060330';boResul:= '2006330' > '20060401';boResul:= 'Cesar' < 'alicia' ;


Eliminar espacios

PROGRAM Espacios2;

de una cadenaPROGRAM Espacios2;TYPEtsCad= STRING[70];

VARbyLong, i: Byte;sCadIn, sCadOut: tsCad;

BEGINWrite('Cadena: ');ReadLn(sCadIn);ReadLn(sCadIn);sCadOut:='';FOR i:=1 TO Length(sCadIn) DO

IF sCadIn[i]<>' ' THENsCadOut:= sCadOut + sCadIn[i];

END.


END.

Operaciones con cadenasOperaciones con cadenas(Paso de parámetros)

Se pueden pasar cadenas por valor o por referencia (VAR) al igual que los tiposreferencia (VAR) al igual que los tipos básicos

Cuando se trata de parámetros de entrada es más eficiente utilizar el paso constantep(CONST)

Las funciones pueden devolver valores de tipo cadena


p

PROGRAM Min_May;TYPEtsCadenas=STRING[80];

FUNCTION fnsPasarAMayus(sCad: tsCadenas):tsCadenas;VARVARi: Integer;

BEGINFOR i:= 1 TO Length(sCad) DOCASE sCad[i] OF'a' 'z': sCad[i]:= UpCase(sCad[i]);a .. z : sCad[i]:= UpCase(sCad[i]);'ñ': sCad[i]:= 'Ñ';'á': sCad[i]:= 'Á';

É'é': sCad[i]:= 'É';'í': sCad[i]:= 'Í';'ó': sCad[i]:= 'Ó';[ ]'ú': sCad[i]:= 'Ú';

END;f P AM C d


fnsPasarAMayus:= sCadEND;

PROGRAM Min_May;TYPEtsCadenas=STRING[80];

PROCEDURE PasarAMayus(VAR sCad: tsCadenas);VARVARi: Integer;

BEGINFOR i:= 1 TO Length(sCad) DOCASE sCad[i] OF'a' 'z': sCad[i]:= UpCase(sCad[i]);a .. z : sCad[i]:= UpCase(sCad[i]);'ñ': sCad[i]:= 'Ñ';'á': sCad[i]:= 'Á';

É'é': sCad[i]:= 'É';'í': sCad[i]:= 'Í';'ó': sCad[i]:= 'Ó';[ ]'ú': sCad[i]:= 'Ú';

END;END


END.

PROGRAM Separar_Cadenas;TYPE

tsFrase=STRING[100];VAR

sCad, sCad1, sCad2: tsFrase;, , ;i, byPos: Byte;

BEGIN {Programa principal}Write('Escribe una cadena: ');te( sc be u a cade a: );ReadLn(sCad);byPos:= fnbyBuscar(sCad);sCad1:= ''; sCad2:= '';sCad1: ; sCad2: ;IF byPos<> 0 THEN

BEGINFOR i:=1 TO byPos-1 DOFOR i:=1 TO byPos 1 DOsCad1:= sCad1 + sCad[i];

FOR i:=byPos+1 TO Length(sCad) DOsCad2:= sCad2 + sCad[i];sCad2:= sCad2 + sCad[i];

END;WriteLn('Cad1: ', sCad1); WriteLn('Cad2: ' sCad2);


WriteLn('Cad2: ', sCad2);END.

FUNCTION fnbyBuscar(sCadena: tsFrase):Byte;CONSTCONSTBUSCAR='#';

VARi: Byte;boEncontrado: Boolean;

BEGIN {Algoritmo de búsqueda secuencial}boEncontrado:= FALSE;i:= 1;WHILE NOT boEncontrado AND (i<=Length(sCadena)) DOWHILE NOT boEncontrado AND (i<=Length(sCadena)) DOIF sCadena[i] = BUSCAR THEN

boEncontrado:= TRUEELSE

i:= i+1;IF boEncontrado THENIF boEncontrado THEN

fnbyBuscar:= iELSE

f b 0


fnbyBuscar:= 0;END;

Subprogramas para trabajar conSubprogramas para trabajar con cadenas (FUNCIONES)

LENGTH: Devuelve la longitud actual de la cadenaFUNCTION LENGTH (sCad: STRING):Integer;( ) g ;

COPY: Retorna una subcadena de la cadena originalFUNCTION COPY (sCad: STRING; iPos Ini: Integer;FUNCTION COPY (sCad: STRING; iPos_Ini: Integer;

iNumCar: Integer): STRING;

CONCAT: Concatena cadenasCONCAT: Concatena cadenasFUNCTION CONCAT (sCad1, sCad2,..., sCadN:

STRING): STRING;

POS: Busca una subcadena dentro de otraFUNCTION POS (sPatron, sCad: STRING): Byte;


EjemploTYPEtsCadenas=STRING[80];

j p

VARsCad1, sCad2, sCad3: tsCadenas;byLong, byPos: Byte;byLong, byPos: Byte;

BEGINsCad1:= 'Soy una cadena';byLong:= Length(sCad1);sCad2:= COPY(sCad1, 5, 3);sCad3:= ' y yo otra ';y ysCad3:= CONCAT(sCad1, sCad3, COPY(sCad1, 9, 6));byPos:= POS('cadena', sCad3);sCad1:= 'cadena';sCad1:= 'cadena';byPos:= POS(sCad1, sCad3);

END.


{Busca cuántas veces aparece sCad2 dentro de sCad1}TYPEtsCadenas=STRING[80];

VARC d1 C d2 t C dsCad1, sCad2: tsCadenas;byPos, byCont: Byte;

BEGINsCad1:= 'Cadena1, Cadena2, Cadena3, Cadena4';sCad2:= 'Cadena'; {sCad2 -> Cadena a buscar}byPos:= POS(sCad2 sCad1);byPos:= POS(sCad2, sCad1);byCont:=0;WHILE byPos <> 0 DOBEGINbyCont:= byCont+1;sCad1:= COPY(sCad1, byPos+Length(sCad2), Length(sCad1));( , y g ( ), g ( ))byPos:= POS(sCad2, sCad1);END;

W it L ( C d2 ' ' b C t ' ')


WriteLn(sCad2, ' aparece ', byCont, ' veces');END.

Subprogramas para trabajar conSubprogramas para trabajar con cadenas (PROCEDURES)

DELETE: Elimina N caracteres de sCad a partir de Pos_IniPROCEDURE DELETE (VAR sCad: STRING; Pos_Ini, N:

Integer);

INSERT: Inserta sSub_Cad en sCad a partir de Pos_IniPROCEDURE INSERT (sSub_Cad: STRING; VAR sCad:

STRING; Pos_Ini: Integer);

STR: Convierte N (entero o real)-> sCadPROCEDURE STR (N: Entero ó Real; VAR sCad: STRING);

VAL: Convierte sCad -> N (entero o real)PROCEDURE VAL (sCad: STRING; VAR N; VAR Pos_Error:

)


Integer);

EjemploTYPEtsCadenas=STRING[80];

j p

[ ];VARsCad1, sCad2, sCad3: tsCadenas;b L b P b C t B tbyLong, byPos, byCont: Byte;

BEGINsCad1:= 'Soy una cadena';sCad2:= 'otra';sCad3:= 'una';byPos:= POS(sCad3 sCad1);byPos:= POS(sCad3, sCad1);byLong:= Length(sCad3);DELETE(sCad1, byPos, byLong); {DELETE(sCad1, 5, 3)}INSERT(sCad2, sCad1, byPos); {INSERT('otra', sCad1, 5)}WriteLn(sCad1);

END.


PROGRAM Cadena2;TYPETYPE

tsCadenas= String[40];VAR

C d1 C d2 C dsCad1, sCad2: tsCadenas;byPos: Byte;

BEGINWrite('Introduce una cadena: ');ReadLn(sCad1);Write('Introduce la subcadena a borrar: ');Write( Introduce la subcadena a borrar: );ReadLn(sCad2);byPos:= Pos(sCad2, sCad1);WHILE byPos <> 0 DO

BEGINDelete(sCad1, byPos, Length(sCad2));Delete(sCad1, byPos, Length(sCad2));byPos:= Pos(sCad2, sCad1);END;

W it L ('L d ' C d1)


WriteLn('La nueva cadena es: ', sCad1);END.

Ejemplo ConversionesTYPEtsCadenas=STRING[80];

j p

[ ];VARsCad1, sCad2, sCad3: tsCadenas;D t R lrDato: Real;

iNum: Integer;BEGINiNum:= 104;Str(iNum, sCad1); {sCad1-> ‘104’}rDato:= 3 432E-01;rDato:= 3.432E 01;Str(rDato, sCad2); {sCad2-> ‘3.4320000000E-01’}Str(rDato:8:3, sCad2); {sCad2-> ‘ 0.343’}sCad1:= ‘123.3’;Val(sCad1, iNum, iPosError) {iPosError->4, iNum->123}Val(sCad1, rNum, iPosError) {rNum=123.3, iPosError->0}


( , , ) { , }END.

Cadenas de caracteres (Ejercicio 20 Página 72)


DescripciónPrograma que descomprime datos compactados cara a disminuir su espacio dePrograma que descomprime datos compactados cara a disminuir su espacio de almacenamiento.

El algoritmo de compresión se basa en la COMPARACIÓN de la información aEl algoritmo de compresión se basa en la COMPARACIÓN de la información a compactar con información (palabra) previa.

Se sustituyen aquellos caracteres de la palabra a compactar que coinciden conSe sustituyen aquellos caracteres de la palabra a compactar que coinciden con los de la palabra anterior por un NÚMERO y un SIGNO que hace referencia al NÚMERO y POSICIÓN de los caracteres repetidos.

Si iti C t l PRINCIPIO d l l b iSigno positivo: Caracteres al PRINCIPIO de la palabra previaSigno negativo: Caracteres desde el FINAL de la palabra previaNúmero 0: No hay ninguna relación con la palabra previa

EjemplosÓANTERIOR ACTUAL COMPRESIÓN

ONOMATOPEYA EPOPEYA -5EPEPOPEYA EPOCA 3CA


EPOPEYA EPOCA 3CACENTRAL FILANTROPO 0FILANTROPO

S b (I)Subprogramas (I)

SepararNumerosLetrasDescripción:p

Procedimiento que parte una palabra leída por teclado en dos: Parte numérica(al principio de la palabra) y parte de texto (al final de la palabra).NOTA: Puede haber palabras compuestas sólo por números, pero no formadasNOTA: Puede haber palabras compuestas sólo por números, pero no formadassólo por texto.Se debe dar un error cuando la palabra no sigue un formato válido.

Parámetros:ENTRADA sCadIn: Cadena con la palabra a partirSALIDA iNumOut: Parte numérica de la palabra (0 si hay error)SALIDA iNumOut: Parte numérica de la palabra (0 si hay error)

sCadOut: Texto de la palabra ('' si hay error)boErrorOut: Indica si el formato de sCadIn es válido


S b (II)f C P l b

Subprogramas (II)fnsCrearPalabra:

Descripción:Función que descomprime la palabra introducida por teclado a partir de la palabra anterior.

Parámetros:Parámetros:ENTRADA sPalAnterior: Palabra anterior

sCad: Parte no numérica de la palabra compactadaiNum: Parte numérica de la palabra compactada (Incluyendo el signo)iNum: Parte numérica de la palabra compactada (Incluyendo el signo)

RETORNO Palabra descompactada.

fnsConvertirMayusculas:fnsConvertirMayusculas:Descripción:

Convierte una palabra a mayúsculas. En caso de que el carácter no sea alfabético, la función lo deja tal cual.j

Parámetros:ENTRADA sCadena: Contiene la cadena a pasar a mayúsculasRETORNO La cadena en mayúsculas.


y

PROCEDURE SepararNumerosLetras (sCadIn: tsCadenas; VAR iNumOut: Integer; VAR sCadOut: tsCadenas; VAR boErrorOut: Boolean);

VARiErrorPos, iNum: Integer;sNum, sCad: tsCadenas;boError: Boolean;

BEGINboError:=FALSE; iNum:=0; sCad:=''; {Inicialización variables}Val(sCadIn, iNum, iErrorPos); IF iErrorPos <> 0 THEN {Si hay parte no numérica}

BEGINsNum:=Copy(sCadIn, 1, iErrorPos-1); {Obtención parte numérica}sCad:=Copy(sCadIn, iErrorPos, Length(sCadIn) - iErrorPos+1); Val(sNum, iNum, iErrorPos);IF iErrorPos <> 0 THEN {En caso de que haya error}

BEGINboError:=TRUE; iNum:=0; sCad:='';END;

END;


iNumOut:=iNum; sCadOut:=sCad; boErrorOut:=boError; {Valor Salida}END;

FUNCTION fnsCrearPalabra (sPalAnterior, sCad: tsCadenas; iNum: Integer):tsCadenas;

VARsSubCad, sConcat: tsCadenas;iPos: Integer;

BEGINIF iNum < 0 THEN {Caracteres al final de la palabra}

BEGINiPos:= Length(sPalAnterior) - Abs(iNum) + 1;sSubCad:=Copy(sPalAnterior, iPos, Abs(iNum));sConcat:=Concat(sCad, sSubCad);END

ELSE {Caracteres al principio de la palabra}BEGINsSubCad:=Copy(sPalAnterior, 1, iNum);sConcat:=Concat(sSubCad, sCad);END;

fnsCrearPalabra:=sConcat;END;


FUNCTION fnsConvertirMayusculas(sCadena: tsCadenas): tsCadenas;VAR

i: Integer;sCadOut: tsCadenas; {Se ha utilizado una variable auxiliar}

BEGINFOR i:= 1 TO Length(sCadena) DO

BEGINCASE sCadena[i] OF

'a'..'z': sCadOut[i]:=Upcase(sCadena[i]);'ñ': sCadOut[i]:='Ñ';'á': sCadOut[i]:='A';'é': sCadOut[i]:='E';'í': sCadOut[i]:='I';'ó': sCadOut[i]:='O';'ú': sCadOut[i]:='U';ELSE

sCadOut[i]:= sCadena[i];END;

END;sCadOut[0]:=Chr(Length(sCadena));


[ ] ( g ( ))fnsConvertirMayusculas:= sCadOut;

END;

P i i lPROGRAM Pg72Ej20;

Programa principalPROGRAM Pg72Ej20;USES

Crt; {Incluye el procedimiento ClrScr}CONST

sFIN = 'FIN'; {Cadena a teclear para dejar de introducirdatos}datos}

TYPEtsCadenas = String[30];

VAR {Variables globales del programa principal}sCadAnterior, sCadTeclado, sCad: tsCadenas;iNum, iNumPalabra, iCarLeidos, iCarMostrados: Integer;grPorcentaje: Real;boError: Boolean;


BEGIN {Programa principal}Write('1. Palabra: ');ReadLn(sCadTeclado);sCadTeclado:=fnsConvertirMayusculas(sCadTeclado);{Se comprueba que la primera palabra no esté compactada}WHILE ((sCadTeclado[1] >= '0') AND (sCadTeclado[1] <='9')) OR

(sCadTeclado[1]='-') DOBEGINWriteLn('La primera palabra no debe estar compactada');Write('1. Palabra: ');ReadLn(sCadTeclado);sCadTeclado:=fnsConvertirMayusculas(sCadTeclado);END;

{Cuenta de Caracteres leídos para obtener estadísticas}sCadAnterior:= sCadTeclado;iCarLeidos:= Length(sCadAnterior);iCarMostrados:= iCarLeidos;iNumPalabra:=2;Write('2. NumeroPalabra (para terminar -> FIN): ');ReadLn(sCadTeclado);


( )sCadTeclado:= fnsConvertirMayusculas(sCadTeclado);...

WHILE sCadTeclado <> sFIN DOBEGINSepararNumerosLetras(sCadTeclado, iNum, sCad, boError);IF NOT boError THEN

BEGINsCadAnterior:=fnsCrearPalabra(sCadAnterior, sCad, iNum);WriteLn(' ', sCadAnterior);iNumPalabra:= iNumPalabra +1;iCarLeidos:=iCarLeidos + Length(sCadTeclado);iCarMostrados:= iCarMostrados + Length(sCadAnterior);END

ELSEWriteLn(' ', 'ERROR: FORMATO --> NumeroPalabra');

Write(iNumPalabra, '. NumeroPalabra (para terminar -> FIN): ');pReadLn(sCadTeclado);sCadTeclado:= fnsConvertirMayusculas(sCadTeclado);END; {End WHILE}; { }WriteLn('Numero de caracteres leidos: ', iCarLeidos);WriteLn('Numero de caracteres mostrados: ', iCarMostrados);rPorcentaje:= iCarLeidos/iCarMostrados*100;


rPorcentaje: iCarLeidos/iCarMostrados 100;WriteLn('Porcentaje de compresion: ', rPorcentaje:0:2, '%');

END.

Arrays


Ecuación de Niklaus Wirth

Programas =Programas =

Algoritmos + Estructuras de datosAlgoritmos + Estructuras de datos


Ejemplo:Ejemplo:Calcular temperaturas medias

Usando variables independientespSolución no adecuada para manejar muchos datosPoco flexiblePérdida de información

Usando un array de variablesPe mite maneja a iables dent o de la osPermite manejar variables dentro de lazos


TYPEtarTemp = ARRAY[1..7] OF Real;

VARi: Byte; rSuma, rMax: Real;arTemp: tarTemp;arTemp: tarTemp;

BEGINFOR i:= 1 TO 7 DO

BEGINWrite('Introduce Temperatura: ');ReadLn(arTemp[i]);ReadLn(arTemp[i]);END;

rSuma:=0; rMax:=0;FOR i 1 TO 7 DOFOR i:= 1 TO 7 DO

rSuma:= rSuma + arTemp[i];FOR i:= 1 TO 7 DO

IF arTemp[i]>rMax THENrMax:= arTemp[i];

WriteLn('T media: ' rSuma/7:0:1 'T media: ' rMax)


WriteLn( T. media: , rSuma/7:0:1, T. media: , rMax)END.

Arrays de variables

Permite agrupar variables del mismo tipo bajo un identificadorun identificadorLas variables pueden ser de diferentes tipos:

Integer, Char, Boolean, Real, String, Array, Registro…

Facilita las operaciones con muchas variables del mismo tipo dentro de lazosOtros nombres:

Vectores, matrices, tablas, arreglos, formaciones...

Las cadenas son un caso particular de arrays


p y

Arrays unidimensionalesArrays unidimensionales (o vectores)

Estructura de información en memoria Almacenamiento consecutivo de los componentesAlmacenamiento consecutivo de los componentes

Número finito de elementos (del mismo tipo)áCada componente ocupará N bytes en

memoria dependiendo de su tipoEspacio de almacenamiento

Nº máximo elementos * Tamaño del elemento base

Único índice para referenciar un elementoÍndice de tipo ordinal


Sintaxis: Definición de arrays

R d l[ARRAY OF]Rango de valoresdel índice Tipo Base

,

..Límite inferior Límite superiorp


Sintaxis: Acceso a los elementos de un array

Arrays unidimensionales

[ ]Indice del elementoVariable Array

Arrays multidimensionales



elemento

,


,

CONSTMIN=1; MAX=10;MIN 1; MAX 10;

TYPEtaiNumeros = ARRAY[MIN..MAX] OF Integer;tacLetras = ARRAY[1..10] OF Char;tarTemps = ARRAY['A'..'G'] OF Real; {'A'->Lunes; 'G'->Dom}tasNombres= ARRAY[0..9] OF STRING[20];taarTemps = ARRAY[8..14] OF tarTemps;

VARarNotas: ARRAY[1 64] OF Real;arNotas: ARRAY[1..64] OF Real;asAlumnos: tasNombres;tarTemp1200: tarTemps;

BEGIN arNotas[1]:= 9.5;asAlumnos[0]:= 'Juanito';asAlumnos[0]: Juanito ;tarTemp1200['C']:= 28.5; {'C'->Miércoles}FOR i:= 0 TO 9 DO

i ( l [i])


WriteLn(asAlumnos[i]);END.

Almacenamiento en memoria410116

410216

aiVector[1]

CONSTMIN=1;MAX=6;410216

410316

410416

aiVector[2]

6;TYPEtaiNumeros = ARRAY[MIN..MAX]

OF Integer;410416

410516

410616

aiVector[3]

gVARaiVector: taiNumeros;

BEGIN16

…

410B16iV t [6]

...aiVector[3]:= iDato;

END.

410C16aiVector[6]

Loc(aiVector[K]) = Base(aiVector)+W*(K-INF)


Loc(aiVector[K]) Base(aiVector)+W (K INF)

Operaciones con arraysOperaciones con los elementos individuales

Ej: Operaciones de lectura y escritura (Read Write)Ej: Operaciones de lectura y escritura (Read, Write)Ej: Read(aiVector[i]) / Write(aiVector[i])NOTA: No está permitido hacer Read(aiVector)p ( )

Operaciones con la estructura completa:óAsignación (:=)

Se copia en una variable del MISMO TIPO la estructura completacompletaEj: aiVector1:= aiVector2; {Dos variables

del tipo taiVectores = ARRAY…}


Operaciones con arraysOperaciones con arrays(Paso de parámetros)

Se pueden pasar arrays por valor o por referencia (VAR) al igual que los tiposreferencia (VAR) al igual que los tipos básicos y cadenas

Por razones de eficiencia se recomienda usar el paso constante (CONST) para parámetros p ( ) p pde entrada

Las funciones NO pueden devolver resultados de tipo array


p y

TYPEtaiVectores = ARRAY[1..10] OF Integer;

PROCEDURE Rellenar(VAR aiVector: taiVectores; VAR iLong: Integer);VARcResp: Char;

BEGINWrite ('Añadir algún valor: ');ReadLn(cResp);WHILE (UpCase(cResp) = 'S') AND (iLong < 10) DO

BEGINiLong:= iLong +1;g gWrite('Introduce el valor', iLong, 'º : ');ReadLn(aiVector[iLong]);IF iLong < 10 THENg

BEGINWrite ('Añadir algún valor: ');ReadLn(cResp);ReadLn(cResp); END;

END;END


END.

TYPEtaiVectores = ARRAY[1 10] OF Integer;taiVectores = ARRAY[1..10] OF Integer;

PROCEDURE Rellenar(VAR aiVector: taiVectores; VAR iLong: Integer);

PROCEDURE Mostrar(CONST aiVector: taiVectores; ( ;iLong: Integer);

VARi I ti: Integer;

BEGINFOR i:=1 TO iLong DO

WriteLn(‘Elemento ‘, I, ‘º : ‘, aiVector[i]); END.


Longitud lógica vs. longitud físicaLongitud física:

Número máximo de componentes del arrayNúmero máximo de componentes del arrayDetermina el espacio utilizado en memoria

Nº componentes * Tamaño elemento baseNº componentes * Tamaño elemento base

Se determina al definir la variable y no varía hasta su destrucciónsu destrucción

Longitud lógica:Determina el número de componentes válidos en elDetermina el número de componentes válidos en el arrayEs responsabilidad del programador


Es responsabilidad del programador

Mecanismos para controlar laMecanismos para controlar la longitud lógica

Poner todos los elementos con valores significativos al inicio del arrayg

Utilizar una variable que indique cuántos elementos son válidos (Ej: iLong)Marcar el primer elemento con información noMarcar el primer elemento con información no válida (Ej: -1)

Los elementos con valores significativos gpueden estar mezclados con otros no válidos

El índice del elemento también se utiliza para proporcionar informaciónproporcionar informaciónIndicar con un valor fuera de rango los datos no válidos


Algoritmos sobre arraysAlgoritmos sobre arrays unidimensionales

RECORRIDO de un arrayINSERCIÓN de un elemento en un array en unaINSERCIÓN de un elemento en un array en una posición determinadaBORRADO de un elemento de un array, conocida su posiciónBÚSQUEDA SECUENCIAL de un elemento en un arrayarrayBÚSQUEDA BINARIA de un elemento en un arrayarrayORDENACIÓN de los elementos de un array en base a algún criterio


Recorrido de un arrayTYPE taiArray= ARRAY[1..10] OF Integer;

VAR

iMIN iMAXiLong

VARaiArray: taiArray;

PROCEDURE ProcesarElemento(VAR iNum: Integer);

A B C D E F

(VAR iNum: Integer);BEGIN {Programa principal}FOR iIndice:= iMIN TO iLong DOProcesarElemento(aiArray[iIndice]);

iIndice

ProcesarElemento(aiArray[iIndice]);

iIndice:= iMIN;WHILE iIndice<= iLong DOWHILE iIndice< iLong DOBEGINProcesarElemento(aiArray[iIndice]);iIndice:= iIndice+1;


END;END.

Inserción de un elementoInserción de un elemento en un array en una posición

{ iElemento -> Elemento a añadiriPos -> Posición donde añadiriMIN iMAXiLong }

IF iLong < iMAX THENBEGIN A B D E F G

iMIN iMAXiLong

FOR iIndice:= iLong DOWNTO iPos DOaiArray[iIndice+1]:=aiArray[iIndice];

aiArray[iIndice]:= iElemento;1º5º 4º 3º 2ºCiLong:= iLong +1;END

ELSEALGORITMOWriteLn(‘El array está lleno’);1. Desplazar una posición

todos los elementos2. Insertar el elemento en el hueco


3. Aumentar en 1 la longitud lógica

Borrado de un elementoBorrado de un elemento de un array conocida su posición

{iPos -> Posición donde borrar}

IF (iMIN <= iPos) AND (iPos <= iLong) THENBEGINFOR iIndice:= iPos +1 TO iLong DO

iMAX

A B C D E F

iMIN iLongiPos

O d ce: os O o g OaiArray[iIndice-1]:=aiArray[iIndice];

iLong:= iLong – 1;END

A B C D E F

3º1º 2ºELSEWriteLn(‘El array está vacío’);

ALGORITMO1. Desplazar una posición

todos los elementos2 D t 1 l l it d ló i


2. Decrementar en 1 la longitud lógica

Búsqueda secuencialBúsqueda secuencial de un elemento en un array

1. Recorrer el array mientras t l

iMIN iMAXiLong

que no se encuentre el elemento buscado y no se haya llegado al final efectivo

A B C D E F

haya llegado al final efectivo del array.

iIndice2. Si la búsqueda ha finalizado

con éxito; el elemento buscado se encontrará en labuscado se encontrará en la posición indicada por la variable auxiliar iIndice.


Búsqueda secuencialBúsqueda secuencial de un elemento en un array

{ iElemento -> Elemento a buscarboEncontrado -> Encontrado o no encontradoiPos -> Posición donde se encuentra

}boEncontrado:= FALSE;iIndice:= iMIN;WHILE (NOT b E t d ) AND (iI di < iL ) DOWHILE (NOT boEncontrado) AND (iIndice <= iLong) DOIF aiArray[iIndice] = iElemento THEN

boEncontrado:= TRUEELSEELSE

IIndice:= iIndice + 1;

IF boEncontrado THENIF boEncontrado THENWriteLn(‘El elemento ESTA en la posición: ‘, iIndice)

ELSEWriteLn(‘El elemento NO ESTA en el array);


WriteLn( El elemento NO ESTA en el array);

Búsqueda binariaBúsqueda binaria de un elemento en un array

1. Recorrer el array mientras que no se encuentre el elemento buscado y no se haya llegado al final efectivo del array

iMIN iMAXiLong


1. Si no se encuentra el elemento se busca el elemento que está en el medio

A B C D E F

q

2. Si la búsqueda ha finalizado con éxito; el elemento buscado se encontrará en la

i ió i di d l i bl iliiIndice

posición indicada por la variable auxiliar iIndice.

NOTA E t l it ól d tiliNOTA: Este algoritmo sólo se puede utilizar cuando los elementos del array están ordenados


{Búsqueda binaria}{Búsqueda binaria}boEncontrado:= FALSE;iIndice:= iMIN;iFinal:= iLong;g

REPEATIMitad:= (iPrincipio + iFinal) DIV 2;

IF aiArray[iMitad]= iElemento THENboEncontrado:= TRUE

{En caso de que el array esté ordenado de forma ascendente}ELSE IF aiArray[iMitad] > iElemento THEN

iFinal:= iMitad + 1SELSEIPrincipio:= iMitad –1;

UNTIL boEncontrado OR (iPrincipio > iFinal);

IF aiArray[iMitad] = iElemento THENfniBusquedaBinaria:= iMitad

ELSE


ELSEfniBusquedaBinaria:= NO_ENCONTRADO;

EjemploPrograma que gestione un array con los DNI’s de los alumnos que hanlos DNI s de los alumnos que han aprobado una asignatura.

L DNI’ d b á t dLos DNI’s deberán estar por orden. Menú con las siguientes opciones:

1. Mostrar el array2. Añadir nuevo elemento al array3. Eliminar elemento del array0. Salir


PROGRAM AlgoritmArrays;USES Crt;CONSTiMIN=1;iMAX=5;iNO_ENCONTRADO= -1;

TYPEtaiAprobados= ARRAY[iMIN..iMAX] OF Integer;

VARVARaiAprobados: taiAprobados;iLong, i, iPos, iAlumno: Integer;cOpcion: Char;cOpcion: Char;

PROCEDURE InsertarElemento(iAlumno, iPos: Integer; VAR aiAprobados: taiAprobados; VAR iLong: Integer);VAR aiAprobados: taiAprobados; VAR iLong: Integer);

PROCEDURE BorrarElemento(iPos: Integer; VAR aiAprobados: taiAprobados; VAR iLong: Integer);

PROCEDURE MostrarArray(CONST aiAprobados: taiAprobados;PROCEDURE MostrarArray(CONST aiAprobados: taiAprobados; Long: Integer);

FUNCTION BuscarPosInsertar(CONST aiAprobados: taiAprobados;iLong, iAlumno: Integer): Integer;


o g, u o: tege ): tege ;FUNCTION BuscarPosBorrar(CONST aiAprobados: taiAprobados;

iLong, iAlumno: Integer): Integer;

PROCEDURE InsertarElemento (iAlumno, iPos: Integer; VAR aiAprobados: taiAprobados;VAR iLong: Integer);

VARi: Integer;

BEGINIF iLong < iMAX THENIF iLong < iMAX THEN

BEGINFOR i:=iLong DOWNTO iPos DO

aiAprobados[i+1]:=aiAprobados[i];aiAprobados[i+1]:=aiAprobados[i];aiAprobados[iPos]:=iAlumno;iLong:= iLong +1;END

ELSEBEGINWrite ('No se puede insertar elemento: ');WriteLn ('El array esta lleno');END


END;

PROCEDURE BorrarElemento(iPos: Integer;PROCEDURE BorrarElemento(iPos: Integer; VAR aiAprobados: taiAprobados;VAR iLong: Integer);

VARVARi: Integer;

BEGINIF (iMIN <= iPos) AND (iPos <= iLong) THEN

BEGINFOR i:= iPos+1 TO iLong DOg

aiAprobados[i-1]:= aiAprobados[i];Dec(iLong);ENDEND

ELSEBEGINWrite ('No se puede borrar elemento: ');Write ( No se puede borrar elemento: );WriteLn ('El array esta vacio');END

END


END;

PROCEDURE MostrarArray(CONST aiAprobados: taiAprobados; iL I t )iLong: Integer);

VARi: Integer;

BEGINIF iLong - iMIN + 1 = 0 THEN

WriteLn('El array esta vacio')yELSE

BEGINWriteLn('Mostrando array con los aprobados: ');WriteLn( Mostrando array con los aprobados: );FOR i:=iMIN TO iLong DO

Write(aiAprobados[i], ', ');END;END;

END;


FUNCTION BuscarPosInsertar(CONST aiAprobados: taiAprobados;FUNCTION BuscarPosInsertar(CONST aiAprobados: taiAprobados;iLong, iAlumno: Integer): Integer;

VARi: Integer;i: Integer;boEncontrado: Boolean;

BEGINboEncontrado:= FALSE;bo co t ado: S ;IF iLong = iMIN-1 THEN {El array esta vacio}

i:= 1ELSE

BEGINi:= iMIN;WHILE (NOT boEncontrado) AND (i<=iLong) DO

IF aiAprobados[i] > iAlumno THENboEncontrado:=TRUE

ELSEi:= i+1;

END;BuscarPosicionInsertar:= i;


END;

FUNCTION BuscarPosBorrar(CONST aiAprobados:taiAprobados;FUNCTION BuscarPosBorrar(CONST aiAprobados:taiAprobados;iLong, iAlumno: Integer): Integer;

VARi I ti: Integer;boEncontrado: Boolean;

BEGINboEncontrado:= FALSE;i:= iMIN;WHILE (NOT boEncontrado) AND (i<=iLong) DOg

IF aiAprobados[i] = iAlumno THENboEncontrado:=TRUE

ELSEELSEi:= i+1;

IF boEncontrado THENBuscarPosicionBorrar:= iBuscarPosicionBorrar:= i

ELSEBuscarPosicionBorrar:= iNO_ENCONTRADO;

END


END;

PROCEDURE InsertarElemento (iAlumno: Integer; VAR aiAprobados: taiAprobados;VAR iLong, iPos: Integer);

VARi: Integer;

BEGINIF iLong < iMAX THENIF iLong < iMAX THEN

BEGINFOR i:=iLong DOWNTO iPos DO

aiAprobados[i+1]:=aiAprobados[i];aiAprobados[i+1]:=aiAprobados[i];aiAprobados[iPos]:=iAlumno;iLong:= iLong +1;END

ELSEBEGINWrite ('No se puede insertar elemento: ');WriteLn ('El array esta lleno');END


END;

FUNCTION fncMenu: Char;;VAR

cOpt: Char;BEGINBEGIN

WriteLn('1. Mostrar el array');WriteLn('2. Añadir un elemento al array');WriteLn('3 Borrar un elemento del array');WriteLn('3. Borrar un elemento del array');WriteLn('0. Salir');WriteLn;Write('Escoge una opcion: ');ReadLn(cOpt);fncMenu:= cOpt;

END;


BEGIN {Programa Principal}iLong:=iMIN-1;g ;REPEAT

cOpcion:= fncMenu;CASE cOpcion OF

'1' M t A ( iA b d iL )'1': MostrarArray(aiAprobados, iLong);'2': BEGIN

Write('Introduce el alumno a insertar: ');ReadLn(iAlumno);( )iPos:=BuscarPosInsertar(aiAprobados, iLong, iAlumno);InsertarElemento(iAlumno, iPos, aiAprobados, iLong);END;

'3' BEGIN'3': BEGINWrite('Introduce el alumno a borrar: ');ReadLn(iAlumno);iPos:=BuscarPosBorrar(aiAprobados, iLong, iAlumno);p , g,IF iPos<> iNO_ENCONTRADO THEN

BorrarElemento(iPos, aiAprobados, iLong)ELSE

WriteLn('Elemento no encontrado No se pudo borrar');WriteLn('Elemento no encontrado. No se pudo borrar');END;

'0':END;


UNTIL cOpcion=0;END.


R d l[ARRAY OF]Rango de valoresdel índice Tipo Base

,

..Límite inferior Límite superiorp


Sintaxis: Acceso a los elementos de un array

Arrays unidimensionales





elemento

,


,

Ejemplo 1: j pBuscaminas

a11 a12 a1N…a21 a22 a2N…

aM1aM2 aMN

… …

aM1aM2 aMN…

TYPE taboArray= ARRAY[1..16,1..16]

OF Boolean;OF Boolean;VARaboTablero: taiArray;


Ejemplo 2: j pFotografía Digitalizada

a11 a12 a1N…a21 a22 a2Na21 a22 a2N…

aM1aM2 aMN…

… …

TYPE {Byte => 256 Niveles de gris}tabyFoto= ARRAY[1..640, 1..320] OF Byte;


y [ , ] y ;VARabyFoto: tabyFoto;

Almacenamiento en memoriaMatriz[1,1] CONST

INF_1=1;SUP 1=4;Matriz[1,2]

Matriz[1,3]

SUP_1=4;INF_2=1;SUP_2=3;

TYPE[ , ]

Matriz[2,1]

taiNumeros = ARRAY[INF_1..SUP_1, INF_2..SUP_2] OF Integer;

VARMatriz: taiNumeros;Matriz: taiNumeros;

BEGIN...Matriz[2,3]:= iDato;

Matriz[2,2]

M t i [2 3]

…

END.

Loc(Matriz[J K]) = Base(Matriz)+W*(SUP 2*(J-INF 1) +(K-INF 2))

Matriz[2,3]


Loc(Matriz[J,K]) = Base(Matriz)+W*(SUP_2*(J-INF_1) +(K-INF_2))

Arrays bidimensionalesArrays bidimensionales vs. Arrays de arrays

Array bidimensional (matriz)Definición conceptualmente más claraDefinición conceptualmente más claraSólo permite el acceso a los elementos individualmente

Array de arrays Permite el acceso a los elementos individualmentePermite el acceso a los elementos individualmentePermite el acceso a una fila completa

Selección en base a la naturaleza de la información manipulada


información manipulada

CONSTiNUM_FILA= 4;iNUM_COL= 3;

TYPE taiTipoMatriz 1 = ARRAY[1..iNUM FILA, 1..iNUM COL] OF Integer;taiTipoMatriz_1 ARRAY[1..iNUM_FILA, 1..iNUM_COL] OF Integer;

taiTipoFila = ARRAY[1..iNUM_COL] OF Integer;taaiTipoMatriz_2 = ARRAY[1..iNUM_FILA] OF taiTipoFila;

VARaiMatriz_1: taiTipoMatriz_1;aaiMatriz_2: taaiTipoMatriz_2;

BEGINGaiMatriz_1[1, 2]:= 23;aaiMatriz_2[1, 2]:= 23;

iM t i 1[1][2] 23aiMatriz_1[1][2]:= 23;aaiMatriz_2[1][2]:= 23;

{Las siguientes sentencias producen un Error de tipo}{ g p p }aiMatriz_1:= aaiMatriz_2;aiMatriz_1:= aaiMatriz_2;

END.


Ejemplo1: O i t i

PROGRAM Matrices;

Operaciones con matricesCONSTiMAX_FILAS=5;iMAX_COLUMNAS=5;

TYPETYPEtaiMatriz = ARRAY[1..iMAX_FILAS, 1..iMAX_COLUMNAS] OF Integer;

VARaiMatriz_A, aiMatriz_B, aiMatriz_C: taiMatriz;byFilas_A, byColumnas_A, byFilas_B, byColumnas_B: Byte;

PROCEDURE LeerDimensiones(VAR byFilas, byColumnas: Byte);BEGINBEGINREPEAT

Write(‘Introduce numero de filas: ‘);ReadLn(byFilas);

UNTIL (0< byFilas) AND (byFilas <= iMAX_FILAS); REPEAT

Write(‘Introduce numero de columnas: ‘);ReadLn(byColumnas);


ReadLn(byColumnas);UNTIL (0< byColumnas) AND (byColumnas <= iMAX_COLUMNAS);

END;

PROCEDURE LeerMatriz(VAR aiMatriz: taiMatriz; byFilas, byColumnas:Byte);

VARVARi, j: Byte;

BEGINFOR i:=1 TO byFilas DO

BEGINWriteLn(‘Introduciendo fila ‘, i, ‘:’);FOR j:=1 TO byColumnas DO

BEGINGWrite(‘Elemento [‘, i, ‘,’, j, ‘]: ‘);ReadLn(aiMatriz[i, j]);END

ENDENDEND;


PROCEDURE MostrarMatriz (CONST aiMatriz: taiMatriz; byFilas, byColumnas:Byte);

VARi, j: Byte;

BEGINFOR i:=1 TO byFilas DOFOR i:=1 TO byFilas DO

BEGINFOR j:=1 TO byColumnas DO

Write(aiMatriz[i, j]:8);WriteLnEND

WriteLn;END;END;

PROCEDURE SumarMatrices (CONST aiMatriz_A, aiMatriz_B: taiMatriz; VAR aiMatriz_C: taiMatriz;

byFilas, byColumnas:Byte);VAR

i, j: Byte;BEGINBEGIN

FOR i:=1 TO byFilas DOFOR j:=1 TO byColumnas DO

aiMatriz_C[i,j]:= aiMatriz_A[i,j]+aiMatriz_B[i,j];


END;

Ejemplo 2: j pBuscaminas

a11 a12 a1N…a21 a22 a2N…

aM1aM2 aMN

… …

aM1aM2 aMN…

TYPE taboArray= ARRAY[1..16,1..16]

OF Boolean;OF Boolean;VARaboTablero: taiArray;


FUNCTION fniMinasAlrededor(iPosX, iPosY, iFilas, iColumnas: Integer;CONST aboTablero: taboArray): Integer; y) g

VARi, j, iMinas: Integer;

BEGINiMi 0iMinas:=0;FOR i:=iPosX-1 TO iPosX+1 DO

FOR j:= iPosY-1 TO iPosY+1 DO{No se cuenta la casilla seleccionada}{ }IF (i<> iPosX) AND (j<> iPosY) THEN

{La casilla seleccionada debe estar dentro de límites}IF (i>=1) AND (i<=iColumnas) AND (j>=1) AND (j<=iFilas) THEN

{Si hay una mina en esa posición se incrementa iMinas}{Si hay una mina en esa posición se incrementa iMinas}IF aboTablero[i,j] THENiMinas:= iMinas +1;

fniMinasAlrededor:= iMinas;END;


Arrays paralelosDNI Nombre E. Civil

Pepito25265757 ‘S’Indice=3

CONSTMAX=50;

TYPEtsNombre= STRING[40];

VARaliDNI ARRAY[1 MAX] OF LongIntaliDNI: ARRAY[1..MAX] OF LongInt;asNombre: ARRAY[1..MAX] OF tsNombre;acECivil: ARRAY[1..MAX] OF Char;iIndice iLong: Integer;


iIndice, iLong: Integer;

iRegistros


RegistrosInformación relacionadaDatos de diferente tipoDatos de diferente tipo

Ej I f ió dEj: Información de una personaDNI (LongInt)N b (St i [80])Nombre (String[80])Teléfono (String[9])Edad (Byte)

Registro ->Formulario Edad (Byte)

Estado civil (Char)


…

EjemploTYPEtsNombre = STRING [80];tsNombre STRING [80];tsTelefono = STRING [9];trgFicha = RECORD

liDNI: LongInt;72132198DNI

Perico …Nombre g ;sNombre: tsNombre;sTel: tsTelefono;byEdad: Byte;

Perico …Nombre651123321Telefono

23EdadcECivil: Char;

END;VAR

‘S’E. Civil

rgPersona, rgColega: trgFicha;


Almacenamiento en memoriaVAR

rgPersona: trgFicha;

rgPersona.liDNIg g ;

BEGINrgPersona.liDNI:= 72132198;rgPersona.sNombre:= ‘Perico...’

6

… rgPersona.sNombrergPersona.sTelefono:= ‘651123321’;rgPersona.byEdad:= 23;rgPersona.cECivil:= ‘S’;

…

9

…

23

...Write(‘DNI: ‘, rgPersona.liDNI);...

rgPersona.sTelefono

rgPersona byEdad23

‘S’

…

END.rgPersona.byEdadrgPersona.cECivil


Definiciones

Registro / Estructura / Record (PASCAL)g / / ( )

Registro vs CamposRegistro vs. CamposRegistro: Bloque de información

Ej Fi hEj: trgFicha

Campos: Componentes que forman el registroliDNI, sNombre, sTelefono, byEdad, cECivil…


Operaciones con Registros

Operaciones con los elementos individualesEj O i d l t it (R d W it )Ej: Operaciones de lectura y escritura (Read, Write)

Ej: Read(rgPersona.liDNI) Write(rgPersona.sNombre)( g )

NOTA: No está permitido hacer Read(rgPersona)

Operaciones con la estructura completa:Operaciones con la estructura completa:Asignación (:=)

Se copia en una variable del MISMO TIPO la estructura pcompletaEj: rgPersona:= rgColega; {Dos variables

del tipo trgFicha}


del tipo trgFicha}

SintaxisDefinición:

RECORD END:Identificador del campo Tipo

,

;Acceso a campos:

.VariableRegistro Identificador del campo


TYPEtsCadenas = STRING[30];trgPersonas = RECORD

sNombre,sDireccion: tsCadenas;sDireccion: tsCadenas;iEdad: Integer;

END;VARrgEmpleado, rgCliente: trgPersonas;

BEGINBEGINrgEmpleado.sNombre := rgCliente.sNombre;rgEmpleado.sDireccion := rgCliente.sDireccion;

E l d iEd d Cli t iEd drgEmpleado.iEdad := rgCliente.iEdad;{Asignación de una variable a otra variable}rgEmpleado:= rgCliente;{Operaciones con los elementos individuales}rgEmpleado.iEdad:= rgEmpleado.iEdad + 1;

END


END.

Estructuras jerárquicasrgCliente: trgPersonas

rgIdent: trgNombreCompletorgIdent: trgNombreCompleto

sNombre

asApellido: tasDosCadenas

asApellido[1]

asApellido[2]

sDireccion

iEdad


TYPEtsCadenas= String[30];tasDosCadenas= ARRAY [1..2] OF tsCadenas;trgNombreCompleto = RECORD

sNombre: tsCadenas;asApellido: tasDosCadenas;

END;trgPersonas = RECORD

rgIdent: trgNombreCompleto;sDireccion: tsCadenas;iEdad: Integer;

END;VAR

rgNombrePers: trgNombreCompleto;rgCliente: trgPersonas;

BEGINrgNombrePers.asApellido[1] := ‘Landa’;rgNombrePers.asApellido[1][1] := ‘M’;rgCliente.rgIdent.asApellido[1]:= ‘Perez’;rgCliente.rgIdent:= rgNombrePers;


g g g...

EjemploTYPEtrgFicha = RECORD

li

Ejemplo

liDNI: LongInt;sNombre: STRING[80];sTel: STRING[9];b Ed d B tbyEdad: Byte;cECivil: Char;

END;VARVARrgPersona, rgColega: trgFicha;

BEGINWrite(‘DNI’);Write( DNI );ReadLn(rgPersona.liDNI);rgPersona.sNombre:= ‘Perico...’rgPersona.byEdad:= rgPersona.byEdad +1;rgPersona.byEdad: rgPersona.byEdad +1;rgPersona.cECivil:= ‘S’;WriteLn(‘Edad: ‘, rgPersona.byEdad);...


Cláusula WITH

Permite simplificar la notación al acceder l d i ta los campos de un registro

Sintaxis:Sintaxis:

WITH DOIdentificador de SentenciaWITH DOvariable registro

,

Sentencia

,


TYPEt Fi h RECORDtrgFicha = RECORD

liDNI: LongInt;sNombre: STRING[80];sTel: STRING[9];sTel: STRING[9];byEdad: Byte;cECivil: Char;

END;END;VARrgPersona, rgColega: trgFicha;

BEGINBEGINWITH rgPersona DOBEGINWrite(‘DNI’);( );ReadLn(liDNI);sNombre:= ‘Perico...’byEdad:= byEdad +1;y ycECivil:= ‘S’;WriteLn(‘Edad: ‘, byEdad);

END;


TYPEtsCadenas= String[30];tasDosCadenas= ARRAY [1..2] OF tsCadenas;trgNombreCompleto = RECORD

sNombre: tsCadenas;asApellido: tasDosCadenas;

END;trgPersonas = RECORD

rgIdent: trgNombreCompleto;sDireccion: tsCadenas;iEdad: Integer;

END;PROCEDURE MostrarPersona (CONST rgPersona: trgPersonas) ;BEGIN

WITH rgPersona, rgIdent DOBEGIN

WriteLn(‘Apellidos y nombre: ‘, asApellido[1], ‘, ‘, asApellido[2], ‘, ‘, sNombre);

WriteLn(‘ Direccion : ‘, sDireccion);WriteLn(‘ Edad: ‘, iEdad);


( , )END;

END;

PROCEDURE LeerPersona (VAR rgPersona: trgPersonas) ;PROCEDURE LeerPersona (VAR rgPersona: trgPersonas) ;BEGIN

WITH rgPersona, rgIdent DOBEGIN

Write(‘ Nombre: ‘);ReadLn(sNombre);ReadLn(sNombre);Write(‘ Primer Apellido: ‘);ReadLn(asApellido[1]);

( )Write(‘ Segundo Apellido: ‘);ReadLn(asApellido[2]);Write(‘ Direccion: ‘);ReadLn(sDireccion);Write(‘ Edad: ‘);ReadLn(iEdad);ReadLn(iEdad);

END;END;


TYPEtrgNombre = RECORD

sNombre, sApellido: STRING[30];cInicial: Char;

END;END;trgPersonas = RECORD

rgNombre: trgNombre;cInicial: Char;

END;VARVARrgEmpleado: trgPersonas; sNombre: STRING[30];

BEGINBEGINWITH rgEmpleado, rgNombre DO

BEGINsNombre:= ‘Perico’;cInicial:= ‘M’;

END;


END;...

Resolución deResolución de ambigüedades con WITH

Una variable tapa a algún campo del registroregistro

Solución: El campo tiene mayor peso que la variablela variable.

Dos registros anidados tienen una variable con el mismo nombre.

Solución: La variable a asignar es la más interna.


Operaciones con registrosOperaciones con registros(Paso de parámetros)

Se pueden pasar registros por valor o por referencia (VAR) al igual que los tiposreferencia (VAR) al igual que los tipos básicos, cadenas y arrays

Por razones de eficiencia se recomienda usar el paso constante (CONST) para parámetros p ( ) p pde entrada

Las funciones NO pueden devolver resultados de tipo registro


p g

Arrays paralelosDNI Nombre E. Civil

Pepito25265757 ‘S’Indice=3

CONSTMAX=50;

TYPEtsNombre= STRING[40];

VARaliDNI ARRAY[1 MAX] OF LongIntaliDNI: ARRAY[1..MAX] OF LongInt;asNombre: ARRAY[1..MAX] OF tsNombre;acECivil: ARRAY[1..MAX] OF Char;iIndice iLong: Integer;


iIndice, iLong: Integer;

Array de registrosTYPEtsNombre = STRING [80];tsTelefono = STRING [9];trgFicha = RECORD

liDNI: LongInt;72132198DNIN b sNombre: tsNombre;

sTel: tsTelefono;byEdad: Byte;

MiguelitoNombre651123321Telefono

23EdadcECivil: Char;

END;targInfo = ARRAY[1..100] of trgFicha;VAR

23Edad‘S’E. Civil

VARrgPersona: trgFicha;argAlumnos: targInfo;


TYPEtsNombre STRING [80]tsNombre = STRING [80];tsTelefono = STRING [9];trgFicha = RECORD

liDNI: LongInt;liDNI: LongInt;sNombre: tsNombre;sTel: tsTelefono;byEdad: Byte;byEdad: Byte;cECivil: Char;

END;targInfo = ARRAY[1..100] of trgFicha;ta g o [ .. 00] o t g c a;VARrgPersona: trgFicha;argGrupo17, argGrupo4: targInfo;g p , g p g

BEGIN...argGrupo17:= argGrupo4; {Asignación array completo}...argGrupo17[25] := argGrupo4[35]; {Asignación un registro}...


argGrupo17[26].sNombre := ‘Mario’; {Asignación campo}argGrupo17[26].sNombre[5] := ‘a’; {Asignación letra}

Algoritmos sobre arraysAlgoritmos sobre arrays unidimensionales (de registros)

RECORRIDO de un arrayINSERCIÓN de un elemento en un array en unaINSERCIÓN de un elemento en un array en una posición determinadaBORRADO de un elemento de un array, conocida su posiciónBÚSQUEDA SECUENCIAL de un elemento en un arrayarrayBÚSQUEDA BINARIA de un elemento en un arrayarrayORDENACIÓN de los elementos de un array en base a algún criterio


Tratamiento secuencialTratamiento secuencial (Buscar las diferencias)

iAlumnosG17:= 64;FOR i:= 1 TO iAlumnosG17 DOWITH argGrupo17[i] DO

iAlumnosG4:= 24;WITH argGrupo4[i] DOFOR i:= 1 TO iAlumnosG4 DOWITH argGrupo17[i] DO

BEGINWriteLn(sNombre);WriteLn(sDNI);

FOR i:= 1 TO iAlumnosG4 DOBEGINWriteLn(sNombre);WriteLn(sDNI);WriteLn(sDNI);

WriteLn(sTel);WriteLn(byEdad);WriteLn(cECivil);

WriteLn(sDNI);WriteLn(sTel);WriteLn(byEdad);WriteLn(cECivil);( );

END;( );

END;


Inserción de un elementoInserción de un elemento en un array en una posición

{ rgElemento -> Elemento a añadiriPos -> Posición donde añadiriMIN iMAXiLong }

IF iLong < iMAX THENBEGIN A B D E F G

iMIN iMAXiLong

FOR iIndice:= iLong DOWNTO iPos DOargArray[iIndice+1]:=argArray[iIndice];

argArray[iIndice]:= rgElemento;1º5º 4º 3º 2ºCiLong:= iLong +1;END

ELSEALGORITMOWriteLn(‘El array está lleno’);1. Desplazar una posición

todos los elementos2. Insertar el elemento en el hueco


3. Aumentar en 1 la longitud lógica

Búsqueda binariaBúsqueda binaria de un elemento en un array

1. Recorrer el array mientras que no se encuentre el elemento buscado y no se haya llegado al final efectivo del array

iMIN iMAXiLong


1. Si no se encuentra el elemento se busca el elemento que está en el medio

A B C D E F

q

2. Si la búsqueda ha finalizado con éxito; el elemento buscado se encontrará en la

i ió i di d l i bl iliiIndice

posición indicada por la variable auxiliar iIndice.

NOTA E t l it ól d tiliNOTA: Este algoritmo sólo se puede utilizar cuando los elementos del array están ordenados


Array de registros

TYPEtsNombre = STRING [80];tsNombre = STRING [80];tsTelefono = STRING [9];trgFicha = RECORD

sNombre: tsNombre;

MiguelitoNombre651123321Telefono sNombre: tsNombre;

sTel: tsTelefono;byEdad: Byte;cECivil: Char;

651123321Telefono23Edad‘S’E. Civil cECivil: Char;

END;targInfo = ARRAY[1..100] of trgFicha;VARrgPersona: trgFicha;argArray: targInfo;


{BUSQUEDA BINARIA}{Elemento a buscar: sNombre}{ }boEncontrado:= FALSE;iIndice:= iMIN;iFinal:= iLong;g

REPEATiMitad:= (iPrincipio + iFinal) DIV 2;

IF argArray[iMitad].sNombre = sNombre THENboEncontrado:= TRUE

{Suponiendo array ORDENADO de forma ASCENDENTE}ELSE IF argArray[iMitad].sNombre > sNombre THEN

iFinal:= iMitad - 1ELSEELSE

iPrincipio:= iMitad + 1;UNTIL boEncontrado OR (iPrincipio > iFinal);

IF boEncontrado THENfniBusquedaBinaria:= iMitad

ELSE


ELSEfniBusquedaBinaria:= NO_ENCONTRADO;

Algoritmos de ordenación deAlgoritmos de ordenación de arrays

Existen diferentes algoritmosSelección inserción burbuja etcSelección, inserción, burbuja, etc

Cada uno tiene sus características:EficienciaEficienciaComplejidad de programación…

Acudir a la literatura para escoger el algoritmo más adecuado en cada casoEn caso de arrays de registros se debe especificar un campo con respecto al que ordenar.


Ejemplo:Ejemplo: Ordenación por selección

ValoresIniciales It. 7It. 6It. 5It. 4It. 3It. 2It. 1

67

18

12

67

18

12

67

18

55

67

44

55

67

44

55

67

94

55

67

94

55

94

67

55

8

7

6 12

94

42

12

94

42

55

94

42

55

94

42

55

94

42

55

44

42

55

44

42

55

44

42

6

5

4

6

55

44

44

55

6

44

12

6

18

12

6

18

12

6

18

12

6

18

12

6

18

12

6

3

2

1 44 6 6 6 6 6 6 61


{ORDENACIÓN respecto al campo sNombre}{Numero de iteración}FOR i iLIM INF TO iL 1 DOFOR i:= iLIM_INF TO iLong -1 DO

BEGINsNombreMinimo:=argArray[i].sNombre;iPosMin:=i;iPosMin:=i;{Busqueda del menor elemento}FOR j:= i + 1 TO iLong DO

BEGINBEGINIF argArray[j].sNombre < sNombreMinimo THEN

BEGINsNombreMinimo:= argArray[j].sNombre;sNombreMinimo: argArray[j].sNombre;iPosMin:= j;END;

END;;{Intercambio de los elementos}IF iPosMin <> i THEN

BEGINrgAlumno:=argArray[iPosMin];argArray[iPosMin]:= argArray[i];argArray[i]:= rgAlumno;


END;END;

Ejemplo:Ejemplo: Programa para ordenar un array

Menú con opciones:Añ di l ( l fi l d l )Añadir un nuevo alumno (al final del array)Mostrar el arrayO d lOrdenar el arraySalir

Los datos son de tipo registro con los campos:Nombre (STRING[40])Nota Test (Real)Nota Problema (Real)


Programa completoPROGRAM Ordenacion;USES Crt;CONST

g p

CONSTiLIM_INF= 1;iLIM_SUP= 20;

TYPETYPEtsCad = String[40];trgAlumno = RECORD

sNombre: tsCad;sNombre: tsCad;rNotaTest, rNotaProb: Real;

END;targNotas = ARRAY [iLIM INF..iLIM SUP] OF trgAlumno;targNotas ARRAY [iLIM_INF..iLIM_SUP] OF trgAlumno;

{Array con los nombres y las notas de todos los alumnos}VAR

argNotas: targNotas;iLong: Integer;cOpcion, cEspera: Char;


PROCEDURE PedirRegistro(VAR rgAlumno: trgAlumno);{Pide un registro por pantalla}BEGIN

WITH rgAlumno DOBEGINWriteLn;WriteLn;Write('Nombre: ');ReadLn(sNombre);Write('Nota Test: ');ReadLn(rNotaTest);Write('Nota Problema: ');ReadLn(rNotaProb);END;END;

END;PROCEDURE MostrarRegistro(CONST rgAlumno: trgAlumno);{Muestra un registro por pantalla}BEGIN

WITH rgAlumno DOBEGINWriteLn;WriteLn;WriteLn('Nombre: ', sNombre);WriteLn('Nota Test: ', rNotaTest:0:2);WriteLn('Nota Problema: ', rNotaProb:0:2);


END;END;

PROCEDURE Insertar(VAR argNotas: targNotas; VAR iLong: Integer);{Opción 1}VARVAR

rgAlumno: trgAlumno;BEGIN

PedirRegistro(rgAlumno);IF iLong < iLIM_SUP THEN

BEGINargNotas[iLong+1]:= rgAlumno;Inc(iLong);Inc(iLong);END;

END;

PROCEDURE MostrarArray(CONST argNotas: targNotas; iLong: Integer);{Opción 2}VAR

i: Integer;i: Integer;cCar: Char;

BEGINFOR i:= iLIM_INF TO iLong DO

BEGINMostrarRegistro(argNotas[i]);WriteLn('Pulsa INTRO para continuar');cCar:= ReadKey;


cCar: ReadKey;END;

END;

PROCEDURE OrdenarArray(VAR argNotas: targNotas; iLong: Integer);VAR

i j iPosMin: Integer;i, j, iPosMin: Integer;sNombreMinimo: tsCad;rgAlumno: trgAlumno;

BEGINFOR i:= iLIM_INF TO iLong -1 DO

BEGINsNombreMinimo:=argNotas[i].sNombre;iPosMin:=i;iPosMin:=i;FOR j:= i + 1 TO iLong DO

BEGINIF argNotas[j].sNombre < sNombreMinimo THEN

BEGINsNombreMinimo:= argNotas[j].sNombre;iPosMin:= j;END;END;

END;IF iPosMin <> i THEN

BEGINrgAlumno:=argNotas[iPosMin];argNotas[iPosMin]:= argNotas[i];argNotas[i]:= rgAlumno;END;


END;END;

END;

FUNCTION fncMenu: Char;FUNCTION fncMenu: Char;VARcOpcion: Char;

BEGINClrScr;WriteLn;WriteLn('**********MENU DE OPCIONES**********');WriteLn('1.- A¤adir un nuevo alumno');WriteLn('2.- Mostrar todos los alumnos');WriteLn('3.- Ordenar el array');WriteLn('0.- Salir');WriteLn;Write('Pulsa la tecla de opcion: ');REPEAT

cOpcion:= ReadKey;UNTIL ('0' <=cOpcion) AND (cOpcion <= '3');W it L ( O i )WriteLn(cOpcion);WriteLn;fncMenu:= cOpcion;

END;


END;

{Programa Principal}BEGIN

REPEATREPEATcOpcion:= fncMenu;CASE cOpcion OF

'1':Insertar(argNotas iLong);'1':Insertar(argNotas, iLong);'2':MostrarArray(argNotas, iLong);'3':OrdenarArray(argNotas, iLong);END;END;

{Permite visualizar el resultado de una opcion}IF cOpcion <> '0' THEN

BEGINBEGINWrite(' Pulsa INTRO para continuar');cEspera:= ReadKey;END;;

UNTIL cOpcion='0';END.


i hFicheros


Memoria principal (RAM)

PILA:Variables definidas en

Datos de Programa los programas (con VAR)

Códi bi i

Código en ejecución

Código binariocompilado (listo para ser ejecutado)

Subprogramas ti Sistema Operativo para gestionar

los recursos delordenador


Características de la Memoria RAM

Espacio de memoria limitado (en la actualidad en torno a 512 MBytes)y )

Los datos contenidos en la memoria RAM se pierden al desconectar el ordenador

N id d d d d t d f tNecesidad de guardar datos de forma permanente

⇒ Necesidad de utilizar algún sistema de⇒ Necesidad de utilizar algún sistema de almacenamiento secundario (p.e. Disquetes,PenDrives Discos Duros CD-ROMS etc )


PenDrives, Discos Duros, CD-ROMS, etc.)

Volcado de datos a memoria secundaria

PILA: Lectura de discoDatos de Programa

Lectura de disco

Código en ejecución

Escritura en disco

Sistema Operativo


Dispositivos de palmacenamiento secundario

10010100

11001011

…

10101110

Fichero1

10101110

…

11101010

Fi h 2…

00101010

…

Fichero2

01101011

… FicheroN


11101010

¿Qué es un fichero?

fi h ( h )Un fichero (o archivo) es una secuencia de datos que representa q puna unidad para el sistema operativo y reside en algún dispositivo dereside en algún dispositivo de memoria secundaria.


Ficheros vistos por el pSistema Operativo


Tipo de dato FICHEROTipo de dato FICHERO (Introducción)

Posibilidad de que existan varios ficheros en un i di itimismo dispositivo

Información contenida en el dispositivo vs. información para manipularlainformación para manipularlaManipulación de los ficheros desde el programaExisten diferentes tipos de ficheros:Existen diferentes tipos de ficheros:

Binarios: Guardan información en formato binarioCon TIPO: Todos los datos dentro del fichero son del mismo tipotipo.Sin TIPO: Pueden contener datos de diferentes tipos

Texto: Sólo guardan caracteres


Clases de FICHEROS Binarios: Información con el mismo patrón binario que en memoria principal

Ejemplo: Sea la variable iDato de tipo Integer que ocupa 2 bytes en memoriaEjemplo: Sea la variable iDato de tipo Integer que ocupa 2 bytes en memoria RAM. Se almacenará en fichero como:

Si iDato = 9 se almacena 00000000 00001001Si iDato = 32767 se almacena 01111111 11111111

Permiten accesos directos y secuencialesPermiten accesos directos y secuenciales

Texto: Ficheros que SÓLO guardan caracteresEjemplo: Sea la variable iDato de tipo Integer que ocupa 2 bytes en memoria RAM Se almacenará en fichero como:RAM. Se almacenará en fichero como:

Si iDato = 9 se almacena el carácter ‘9’: 00111001Si iDato = 32767 se almacenan los caracteres ‘3’, ‘2’, ‘7’, ‘6’ y ‘7’: 00110011 00110010 00110111 00110110 00110111

SÓLO permiten accesos secuenciales (empezando siempre por el primer elemento)

Su contenido se puede visualizar con cualquier editor de texto (p e el bloc de


Su contenido se puede visualizar con cualquier editor de texto (p.e. el bloc de Notas de Windows)

Definición de variablesDefinición de variables de tipo Fichero

BinariosC TiCon Tipo

FILE OF Tipo base

Sin TipoFILE

TextoTEXT


Ficheros binarios con tipo vs. parrays unidimensionales

Componentes de un Componentes de un mismo ARRAYS FICHEROS

Componentes de un mismo tipoAcceso aleatorio o d

ptipoAcceso secuencial o aleatorio

directoLongitud máxima predefinida

(con puntero de archivoLongitud máxima no

predefinidaReside en memoria principal (volátil)

predefinida. Tamaño máximo en función del espacio de almacenamiento disponiblep p ( ) almacenamiento disponibleReside en memoria auxiliar(no volátil)


(no volátil)

Operaciones de LecturaLectura de teclado:(Información leída de teclado que se escribe en la(Información leída de teclado que se escribe en la memoria principal)

Ej: Read (Dato)

Lectura de fichero:(Información leída de un fichero que se escribe en la(Información leída de un fichero que se escribe en la memoria principal)

Ej: Read (fbFichero, Dato)

Variable de tipo FICHERO


Operaciones de EscrituraEscritura en pantalla:(Vuelca datos de la memoria principal en la pantalla(Vuelca datos de la memoria principal en la pantalla del ordenador)

Ej: Write (Dato)

Escritura en fichero:(Vuelca datos de la memoria principal a algún(Vuelca datos de la memoria principal a algún dispositivo de almacenamiento secundario)

Ej: Write (fbFichero, Dato)

Variable de tipo FICHERO


Lectura y escritura

10010100

Memoria RAMWrite (iDato) 10010100

11001011

…

Write (iDato)

…

00000000

00001001iDato

00001001

…

…Read (iDato)

00101010

…


Lectura y escritura de disco

10010100

Memoria RAMWrite (fbiFichero iDato) 10010100

11001011

…

Write (fbiFichero, iDato)

…

00000000

00001001iDato

00001001

…

…

00101010

…Read (fbiFichero, iDato)


Ficheros físicos vs. Ficheros lógicos

Archivo físico:Estructura secuencial de datos almacenada en el dispositivo pde almacenamiento secundarioDatos contenidos en el fichero

Archivo lógico:Variable de memoria que permite y facilita el acceso al q p ydispositivo de almacenamiento secundario.Estructura de datos para manipular el fichero físicoContiene la siguiente información acerca del archivoContiene la siguiente información acerca del archivo físico (nombre, método de acceso, tamaño de los elementos...)


Información contenida en los ficheros lógicos

Archivo de tipo binario Handle: Puntero dentro de un fi h i di l i ió dHandle

Mode

fichero que indica la posición de un elemento a leer o escribirMode: Indica el modo en el queRecSize

Private

U D t

Mode: Indica el modo en el que se ha abierto el ficheroRecSize: Tamaño del tipo de dato

UserDataName

pque compone el ficheroName: Nombre del fichero en el Sistema OperativoSistema Operativo...


EjemploTYPE

tfbrArchTemperaturas = FILE OF Real;tsCadenas = String[30];tfbsArchNombres = FILE OF tsCadenas;

VAR{Archivos lógicos}fbrArchTemp1, fbrgArchTemp2 : tfbrArchTemperaturas;fbsArchCandidatos : tfbsArchNombres;{N b d l hi fí i }{Nombres de los archivos físicos}sNomArchTemp, sNomArchCand,

sNomArchEmplAlmacen: tsCadenas;BEGINBEGIN

...Read(fbrArchTemp, rTemp);


...

Operaciones con variables pde tipo fichero

No se puede hacer ninguna operación directamente:Asignación comparación lectura escrituraAsignación, comparación, lectura, escritura,…Todas las operaciones siguientes producen errores:

1 2fbrArchivo1 := fbrArchivo2;IF fbrArchivo1 = fbrArchivo2 THEN ...ReadLn(fbrArchivo1);WriteLn(fbrArchivo2);

Sólo se pueden operar con los ficheros a través deSólo se pueden operar con los ficheros a través de funciones y procedimientos predefinidos


Funciones y procedimientos y pbásicos (Assign)

Assign: Asocia un fichero físico con un fichero lógico. (Rellena la estructura correspondiente)( p )

VARsNombre1 sNombre2 sNombre3: STRING[80];sNombre1, sNombre2, sNombre3: STRING[80];fbrArchivo1, fbrArchivo2, fbrArchivo3: FILE OF Real;

BEGIN N b 1 ‘D t 1 d t’sNombre1:= ‘Datos1.dat’;

sNombre2:= ‘C:\Ejemplo\Datos2.dat’;ReadLn(sNombre3);Assign(fbrArchivo1, sNombre1);Assign(fbrArchivo2, sNombre2);Assign(fbrArchivo3, sNombre3);


Funciones y procedimientos y pbásicos (ReWrite y Reset)

ReWrite: Crea un nuevo archivo físico (Si ya existe un archivo con ese nombre se borra su contenido)

Reset: Abre un archivo físico ya existente. (Si no existe se produce un error en ejecución)VARfbrArchivo1, fbrArchivo2: FILE OF Real;

BEGIN Assign(fbrArchivo1, ‘Datos1.dat’);Assign(fbrArchivo2, ‘Datos2.dat’);ReWrite(fbrArchivo1);Reset(fbrArchivo2);Reset(fbrArchivo2);

NOTA: Ambos procedimientos abren el archivo de forma que se apunta al PRIMER elemento del fichero


q p

Funciones y procedimientos y pbásicos (Write y Read)

10010100

Memoria RAMWrite (fbiFichero iDato ) 10010100

11001011

…

Write (fbiFichero, iDato,...)

00000000

00001001iDato

…

00101010

…Read (fbiFichero, iDato,...)

NOTA: Cada vez que se hace una operación de lectura escritura, se incrementa el puntero del archivo para preparar la siguiente operación


p p p p g p

Funciones y procedimientos y pbásicos (Close)

Close: Cierra el archivo lógico. (Termina la asociación entre el fichero físico y lógico) Una vez cerrado, se puede volver a asignar l fi h ló i t fi h fí iel fichero lógico a otro fichero físico.

VARfbrArchivo1, fbrArchivo2: FILE OF Real;fbrArchivo1, fbrArchivo2: FILE OF Real;

BEGIN Assign(fbrArchivo1, ‘Datos1.dat’);ReWrite(fbrArchivo1);Write(fbrArchivo1, rDato);Close(fbrArchivo1);

NOTA: En realidad el programa no trata directamente con losNOTA: En realidad el programa no trata directamente con los ficheros sino que es el Sistema Operativo. Close obliga al sistema operativo a terminar las operaciones pendientes.


Ejemplo:Ejemplo: Escribir 10 números aleatorios en fichero

TYPEtfbiArchNumeros = FILE OF Integer;

VARfbiArchivo: tfbiArchNumeros;iDato, i: Integer;

BEGINAssign(fbiArchivo, 'Datos.dat'); {1. Asociar fichero}ReWrite(fbiArchivo); {2. Abrir fichero}Randomize;FOR i:=1 TO 10 DOBEGINiDato:= Random(10);W it (fbiA hi iD t ) {3 E ibi d t }Write(fbiArchivo, iDato); {3. Escribir datos}END;

Close(fbiArchivo); {4. Cerrar fichero}END


END.

Ejemplo:Ejemplo: Leer 10 números de un fichero


VARVARfbiArchivo: tfbiArchNumeros;iDato, i: Integer;

BEGINBEGINAssign(fbiArchivo, 'Datos.dat'); {1. Asociar fichero}Reset(fbiArchivo); {2. Abrir fichero}FOR i:=1 TO 10 DOFOR i:=1 TO 10 DOBEGINRead(fbiArchivo, iDato); {3.a Leer datos}WriteLn('Dato leido: ', iDato); {3.b Procesar datos}WriteLn( Dato leido: , iDato); {3.b Procesar datos}END;

Close(fbiArchivo); {4. Cerrar fichero}END.


Resumen:Resumen:Uso de ficheros en programas

1. Asociar un archivo lógico a un archivo físico Assign: Asocia el nombre de un fichero físico a un fichero lógicoAssign: Asocia el nombre de un fichero físico a un fichero lógico

2. Abrir el archivo, de acuerdo con la operación que se vaya a realizar sobre él

Rewrite: Crea un nuevo archivo físico (asociado al archivo lógico)Rewrite: Crea un nuevo archivo físico (asociado al archivo lógico)Reset: Abre un archivo existente.Abrir el archivo, de acuerdo con la operación que se vaya a realizar sobre él

3. Realizar las operaciones sobre el archivo Operaciones de lectura y escritura: Read y WriteOtras operaciones: Seek, Truncate,...

4. Cerrar el archivo Close: Cierra el archivo lógico y copia en el archivo físico cualquier dato que esté contenido en el buffer asociado al archivo.


Puntero de archivoPuntero de archivoLos elementos de un archivo están ordenados en secuencia sobreLos elementos de un archivo están ordenados en secuencia sobre algún medio físico.

Para leer o escribir algún elemento es necesario desplazar algún elemento mecánico (cabezal electromagnético etc ) sobre elelemento mecánico (cabezal electromagnético, etc.) sobre el soporte de los datos.

Se puede indicar la posición del elemento con el que operar por un número entero empezando en 0un número entero empezando en 0Operaciones de escritura y lectura sobre la posición indicada por el puntero

El puntero está incluido dentro de la estructura del archivo lógico

Puntero -> 2

Elemento1 Elemento2 Elemento3 Elemento4 Elemento5

Í


Índice0 1 2 3 4

Ejemplos:Ejemplos: (Fichero con 5 Elementos)

Si el puntero vale 2 (posición ocupada)Read => lee el elemento 2 y apunta al elemento 3Write => sobrescribe el elemento 2 y apunta al 3

Si el puntero vale 5 (la posición siguiente a la última)p ( p g )Read => Se produce un error en ejecuciónWrite => Se añade un nuevo elemento al archivo (habrá 5 elementos))

Si el puntero vale 8 (por detrás de la última posición)Read => Se produce un error en ejecuciónRead > Se produce un error en ejecuciónWrite => Se escribe en la posición 8 (novena posición) y el puntero indica a la posición 9. Las posiciones 5, 6 y almacenarán datos no válidos (basura)


( )

Función EOF

Antes de leer un elemento es conveniente comprobarAntes de leer un elemento es conveniente comprobar que NO se está al final de un fichero.

F ió END OF FILE (EOF)Función END OF FILE (EOF)FUNCTION EOF(Var_Archivo): Boolean;

Puntero -> 2


Índice0 1 2 3 4


Ejemplo:Ejemplo: Leer TODOS los números de un fichero


VARVARfbiArchivo: tfbiArchNumeros;iDato: Integer;

BEGINBEGINAssign(fbiArchivo, 'Datos.dat'); {1. Asociar fichero}Reset(fbiArchivo); {2. Abrir fichero}WHILE NOT EOF(fbiArchivo) DOWHILE NOT EOF(fbiArchivo) DOBEGINRead(fbiArchivo, iDato); {3.a Leer datos}WriteLn('Dato leido: ', iDato); {3.b Procesar datos}WriteLn( Dato leido: , iDato); {3.b Procesar datos}END;

Close(fbiArchivo); {4. Cerrar fichero}END.


Ejemplo Completo:Ejemplo Completo: Rellenar un fichero con registros

PROGRAM Creditos;;TYPE

tsCadCortas = STRING[10];tsCadLargas = STRING[30];gtrgCreditos = RECORD

sNombre: tsCadLargas;sNumCuenta: tsCadCortas;rSaldo: Real;

END;tfbrgFicheros = FILE OF trgCreditos;

VARsNomFich: tsCadLargas;


PROCEDURE LeerCredito(VAR rgCredito: trgCreditos);BEGINWITH rgCredito DOBEGINWrite(‘Nombre cliente: ‘);R dL ( N b )ReadLn(sNombre);Write(‘N. Cuenta: ‘);ReadLn(sNumCuenta);Write(‘Cantidad del credito: ‘);Write(‘Cantidad del credito: ‘);ReadLn(rSaldo);END

END;END;

PROCEDURE MostrarCredito(CONST rgCredito: trgCreditos);BEGINWITH rgCredito DOBEGINWrite(‘Nombre cliente: ‘, sNombre);

( )Write(‘N. Cuenta: ‘, sNumCuenta);Write(‘Cantidad del credito: ‘, rSaldo:0:2);END

END


END;

PROCEDURE CrearYAnyadir(sNomFich: tsCadLargas);{1. Crea un fichero nuevo de nombre ‘sNomFich’ o lo vacía siya existe un fichero con ese nombreya existe un fichero con ese nombre2. Añade un número indeterminado de créditos}

VARfbrgFich: tfbrgFicheros;fbrgFich: tfbrgFicheros;rgCredito: trgCreditos;cResp: Char;

BEGINBEGINAssign(fbrgFich, sNomFich); {1.Asignar}ReWrite(fbrgFich); {2.Abrir}Write(‘Desea añadir algún crédito: ‘);( g );ReadLn(cResp);WHILE Upcase(cResp) = ‘S’ DOBEGINLeerCredito(rgCredito);Write(fbrgFich, rgCredito); {3.Operaciones de escritura}Write(‘Añadir más créditos (s/n): ‘);ReadLn(cResp);END;

Close(fbrgFich); {4.Cerrar fichero}


END;

PROCEDURE MostrarFichero(sNomFich: tsCadLargas);{Muestra TODOS los créditos contenidos en un fichero ya existente (Si el fichero no existe se produce un ERROR)}existente. (Si el fichero no existe se produce un ERROR)}

VARfbrgFich: tfbrgFicheros;rgCredito: trgCreditos;rgCredito: trgCreditos;cEspera: Char;

BEGINWriteLn(‘DATOS CONTENIDOS EN: ‘, sNomFich);WriteLn( DATOS CONTENIDOS EN: , sNomFich);WriteLn;Assign(fbrgFich, sNomFich); {1.Asignar}Reset(fbrgFich); {2.Abrir fichero existente}( g ); { }WHILE NOT EOF(fbrgFich) DOBEGINRead(fbrgFich, rgCredito); {3a.Volcar datos a RAM}MostrarCredito(rgCredito); {3b.Operar con los datos}Write(‘Pulsa INTRO para mostrar el siguiente...’);cEspera:= ReadKey;END;

Close(fbrgFich); {4.Cerrar fichero}WriteLn(‘FIN DEL LISTADO’);


END;

Programa Principal

{Programa Principal}{Programa Principal}BEGIN

Write (‘Introduce el nombre del fichero donde d l édit ‘)guardar los créditos : ‘);

ReadLn( sNomFich);

CrearYAnyadir(sNomFich);

MostrarFichero(sNomFich);END.


Función IOResultRelacionada con las entradas y salidas de datos del programaSólo la usaremos para detectar si se ha producido algún error en l ió d fi halguna operación de ficheros

Función IOResultFUNCTION IOResult: Integer;

Algunos códigos de error devueltos:

Valor Devuelto Significado0 NO HAY ERROR2 Archivo no existe4 D i d hi bi t4 Demasiados archivos abiertos15 Unidad no existe


…

Control de erroresAssign(fbrgFich, sNomFich);Reset(fbrgFich);IF IOR lt <> 0 THENIF IOResult <> 0 THEN

ReWrite(fbrgFich);


Desactivación del control de errores

Assign(fbrgFich, sNomFich);{$I-}R t(fb Fi h)Reset(fbrgFich);{$I+}IF IOResult <> 0 THEN

ReWrite(fbrgFich);

El código anterior no funcionaba porque el control de d f á i

ReWrite(fbrgFich);

errores por defecto está activoPara resolver esta situación es necesario desactivar el control de errores y gestionar manualmente el errorcontrol de errores y gestionar manualmente el errorLa directiva {$I-} desactiva el control de erroresLa directiva {$I+} lo vuelve a activar


La directiva {$I+} lo vuelve a activar

Ejemplo:Ejemplo: Comprobación de la existencia de un fichero

FUNCTION fnboExisteFichero(sNombre: tsFichero): Boolean;VARfbFichero: tfbFichero;fbFichero: tfbFichero;boExisteFichero: Boolean;

BEGINboExisteFichero:= FALSE;boExisteFichero: FALSE;Assign(fbFichero, sNombre);{$I-}Reset(fbFichero);( );{$I+}IF IOResult =0 THEN

BEGINClose(fbFichero);boExisteFichero:= TRUE;END;


fnboFichero:= boExisteFichero;END;

Posicionamiento del puntero de archivo

Obtención del valor actual del puntero de archivoFUNCTION FilePos(Var_archivo): Integer

Cambiar la posición del puntero de archivoPROCEDURE Seek (Var archivo, iNuevaPos)( _ , )

Obtención del número de elementos contenidos en un archivoarchivo

FUNCTION FileSize(Var_archivo): Integer

Puntero -> 2


Í


Índice0 1 2 3 4

EjemplosVAR

EjemplosVARfbrFichero: FILE OF Real;iPos, iElem: Integer;rDato: Real;rDato: Real;

BEGINAssign(fbrFichero, ‘DATOS.DAT’);Reset(fbrFichero);( );{1. Obtener la posición del último elemento}iPos:= FileSize(fbrFichero)-1;{2. Añadir elementos al final de un archivo}Seek (fbrFichero, FileSize(fbrFichero));Write (fbrFichero, rDato);{3. Mover el puntero a la primera posición}Seek (fbrFichero, 0);{4. Mover el puntero a una posición determinada}Seek (fbrFichero, iPos);


{5. Obtener el nº total de elementos en el fichero}iElem:= FileSize(fbrFichero);

Algoritmos sobre ficherosDirectamente:

Recorrido secuencialBúsqueda secuencialAñadir elementos al final de un ficheroModificar el contenido de algún elementog

Utilizando arrays auxiliares:Inserción de algún elementoBorrado de uno o varios elementosOrdenación del contenido del ficheroNOTA: Hay que comprobar que el fichero cabe en el array. y q p q y

Utilizando ficheros auxiliares:Borrado de uno o varios elementos


Ejemplo:Ejemplo: Añadir un registro al final de un archivo

TYPEtrgDatos: RECORD

...END;

VARfb Fi h FILE OF t D tfbrgFichero: FILE OF trgDatos;rgNuevoRegistro: trgDatos;

BEGINAssign(fbrgFichero ‘DATOS DAT’);Assign(fbrgFichero, ‘DATOS.DAT’);Reset(fbrgFichero) {También podría usarse ReWrite}{Busca la última posición y deja apuntando el puntero}Seek(fbrgFichero FileSize(fbrgFichero));Seek(fbrgFichero, FileSize(fbrgFichero));LeerRegistro(rgNuevoRegistro);Write(fbrgFichero, rgNuevoRegistro);Close(fbrgFichero);


Close(fbrgFichero);END;

Ejemplo:Ejemplo: Búsqueda secuencial

Assign(fbrgFichero, ‘DATOS.DAT’);Reset(fbrgFichero);boEncontrado FALSEboEncontrado:= FALSE;WHILE NOT EOF(fbrgFichero) AND NOT boEncontrado DO

BEGINRead(fbrgFichero rgRegistro);Read(fbrgFichero, rgRegistro);IF rgRegistro.campo = valorBuscado THEN

boEncontrado:= TRUE;END;END;

Close(fbrgFichero);

IF boEncontrado THEN... {rgRegistro contiene los datos}

ELSEWriteLn(‘No se encontro ningún registro que coincida’);


Ejemplo:Ejemplo: Pasar las temperaturas de ºC a ºF

VARfbrTemps: FILE OF REAL;rGradCel, rGradFar: Real;

BEGINAssign(fbrTemps, ‘DATOS.DAT’);IF fnboExisteFichero(‘DATOS.DAT’) THEN

BEGINBEGINReset(fbrTemps);WHILE NOT EOF(fbrTemps) DO

BEGINBEGINRead(fbrTemps, rGradFar);rGradCel:= fnrFar2Celsius(rGradFar);Seek(fbrTemps FilePos(fbrTemps) -1);Seek(fbrTemps, FilePos(fbrTemps) 1);Write(fbrTemps, rGradCel);END

Close(fbrTemps);


Close(fbrTemps);END

END;

Funciones básicas:Funciones básicas: FICHERO cabe en ARRAY

FUNCTION fnboCabeFicheroEnMemoria (sNomFich: tsCadLargas): Boolean;

VARfbrgFich: tfbrgFich;boCabeEnArray: Boolean;

BEGINi (fb i h i h)Assign(fbrgFich, sNomFich);

Reset(fbrgFich);IF FileSize(fbrgFich) <= MAX_CREDITOS THEN

b C b E A TRUEboCabeEnArray:= TRUEELSE

boCabeEnArray:= FALSE;Close(fbrgFich);Close(fbrgFich);

fnboCabeFicheroEnMemoria:= boCabeEnArray;END;


END;

Funciones básicas:Funciones básicas: Volcar FICHERO a ARRAY

PROCEDURE VolcarFichero2Array(sNombreFichero: tsCadena;VAR argDatos: targDatos; VAR iLong: Integer);VAR argDatos: targDatos; VAR iLong: Integer);

VARfbrgFich: tfbrgFich;

BEGINAssign(fbrgFich, sNombreFichero);Reset(fbrgFich);iLong:= 0;WHILE NOT EOF(fbrgFich) DO

BEGINiLong:= iLong +1;Read(fbrgFich, argDatos[iLong]);END;

Close(fbrgFichero);


END;

Funciones básicas:Funciones básicas: Volcar ARRAY a FICHERO

PROCEDURE VolcarArray2Fichero(sNombreFichero: tsCadena;CONST argDatos: targDatos; iLong: Integer);

VARfbrgFich: tfbrgFich; i I ti: Integer;

BEGINAssign(fbrgFich, sNombreFichero);ReWrite(fbrgFich);ReWrite(fbrgFich);FOR i:=1 TO iLong DO

BEGINWrite(fbrgFich argDatos[i]);Write(fbrgFich, argDatos[i]);END;

Close(fbrgFichero);END;


END;

Algoritmos usandoAlgoritmos usando estructuras auxiliares (Borrado)

Borrado de uno o varios elementos de un archivo1. Copiar en la estructura auxiliar (array o fichero) los elementos

que se desean mantener2. Crear de nuevo el archivo3. Copiar todos los elementos de la estructura auxiliar en el3. Copiar todos los elementos de la estructura auxiliar en el

archivo

Fichero original

A B C E FA B C D E F

Fichero originalEstructura Auxiliar1

Elemento a borrar3

A B C E F


Algoritmos usando gestructuras auxiliares (Borrado)

PROCEDURE EliminarCredito(sNomFich: tsCadLargas; sNumeroCuenta: tsCadCortas); {Pág 197}

VARargLista: targListasCreditos;iNumCreditos: Integer;

BEGINIF fnboCabeFicheroEnMemoria(sNomFich) THENIF fnboCabeFicheroEnMemoria(sNomFich) THEN

BEGINVolcarParteFicheroLista(sNomFich, argLista,

iNumCreditos, sNumeroCuenta);VolcarListaFichero(argLista, iNumCreditos, sNomFich);END

ELSEBEGINBEGINWriteLn(‘Fichero muy grande’);WriteLn(‘ No se puede hacer esta operación sobre arrays’);WriteLn(‘ Habría que hacerla sobre otro fichero’);


END;END;

FUNCTION fnboCabeFicheroEnMemoriaFUNCTION fnboCabeFicheroEnMemoria (sNomFich: tsCadLargas): Boolean;

VARfb Fi h tfb Fi hfbrgFich: tfbrgFicheros;boCabeEnArray: Boolean;

BEGINAssign(fbrgFicheros, sNomFich);Reset(fbrgFicheros);IF FileSize(fbrgFich) <= MAX CREDITOS THENg _

boCabeEnArray:= TRUEELSE

boCabeEnArray:= FALSE;boCabeEnArray: FALSE;Close(fbrgFich);

fnboCabeFicheroEnMemoria:= boCabeEnArray;fnboCabeFicheroEnMemoria:= boCabeEnArray;END;


PROCEDURE VolcarParteFicheroLista( sNomFich: tsCadLargas;VAR argLista: targListasCreditos;

VAR iNumCreditos: Integer;sNumeroCuenta: tsCadCortas);

VARfbrgFich: tfbrgFicheros;rgCredito: trgCreditos;

BEGINi (fb i h i h)Assign(fbrgFich, sNomFich);

Reset (fbrgFich);iNumCreditos:= 0;WHILE NOT E f(fb Fi h) DOWHILE NOT Eof(fbrgFich) DOBEGINRead(fbrgFich, rgCredito);IF rgCredito sNumCuenta <> sNumeroCuenta THENIF rgCredito.sNumCuenta <> sNumeroCuenta THEN

BEGINiNumCreditos:= iNumCreditos +1;argLista[iNumCreditos]:= rgCreditoargLista[iNumCreditos]:= rgCreditoEND;

Close(fbrgFich);END;


END;

PROCEDURE VolcarListaFichero(VAR argLista:targListaCreditos;iNumCreditos: Integer;sNomFich: tsCadLargas);

VARfbrgFich: tfbrgFicheros;i: Integer;

BEGINBEGINAssign(fbrgFich, sNomFich);ReWrite (fbrgFich);FOR i:= 1 TO iNumCreditos DOFOR i:= 1 TO iNumCreditos DO

Write(fbrgFich, argLista[i]);Close(fbrgFich);

ENDEND;


Algoritmos usando estructurasAlgoritmos usando estructuras auxiliares (Inserción)

1. Copiar en la estructura auxiliar (array o fichero) los elementos anteriores a la posición donde se va a insertar el nuevo elemento

2. Copiar en la estructura auxiliar el nuevo elementop3. Copiar en la estructura auxiliar los elementos del archivo que quedan hasta

el final del archivo4. Crear de nuevo el archivo

A Si l ili ARRAY C i l l d l l hiA. Si la estructura auxiliar ARRAY => Copiar los elementos del array en el archivoB. Si la estructura auxiliar FICHERO => Renombrar el fichero

Fichero original

iPosInsert 4

A B CA B C E F G

Fichero original Estructura Auxiliar1

D3iPosInsert=4

4

A B C D NuevoElemento

23

A B C D E F GA B C D E F G


A B C D E F G

Algoritmos usando estructurasAlgoritmos usando estructuras auxiliares (Ordenación)

Ordenación del contenido del fichero1 Recorrer el archivo e ir añadiendo los elementos en1. Recorrer el archivo e ir añadiendo los elementos en

un array de forma ordenada2 Volcar todo el fichero en el array (desordenado) y2. Volcar todo el fichero en el array (desordenado) y

ordenar en el array


Algoritmos usando estructuras gauxiliares (Ordenación)

PROCEDURE AnyadirEnOrden(CONST rgCredito: trgCreditos;VAR argLista: targListasCreditos;VAR iNumCreditos: Integer); {Pág 198}VAR iNumCreditos: Integer); {Pág 198}

VARiPosicion: rgCredito: trgCreditos;g g ;

BEGINiPosicion:= iNumCreditos;WHILE (1 <= iPosicion) AND

(rgCredito.sNombre < argLista[iPosicion].sNombre) DOBEGINargLista[iPosicion + 1]:= argLista[iPosicion];iPosicion:= iPosicion – 1;END;

argLista[iPosicion + 1]:= rgCredito;


iNumCreditos:= iNumCreditos +1;END;

PROCEDURE VolcarOrdenadoFicheroLista( sNomFich: tsCadLargas;VAR argLista: targListasCreditos;

VAR iNumCreditos: Integer);VARfbrgFich: tfbrgFicheros;rgCredito: trgCreditos;

BEGINiNumCreditos:= 0;

A i (fb Fi h N Fi h)Assign(fbrgFich, sNomFich);Reset(fbrgFich);WHILE NOT Eof(fbrgFich) DOBEGINBEGINRead(fbrgFich, rgCredito);AnyadirEnOrden(rgCredito, argLista, iNumCreditos);END;END;

Close(fbrgFich);END;


PROCEDURE OrdenarSegunNombre(sNomFich: tsCadLargas);VARargLista: targListasCreditos;iNumCreditos: Integer;

BEGINIF fnboCabeFicheroEnMemoria(sNomFich) THENBEGINl d d i h i ( i h iVolcarOrdenadoFicheroLista(sNomFich, argLista,

iNumCreditos);VolcarListaFichero(argLista, iNumCreditos, sNomFich);W it LWriteLn;WriteLn(‘Finalizada la ordenación del fichero’);END

ELSEELSEBEGINWriteLn(‘Fichero muy grande’);WriteLn(‘ No se puede hacer esta operación sobre arrays’);WriteLn( No se puede hacer esta operación sobre arrays );END

END;


Algoritmos usando estructuras gauxiliares (Resumen)

Borrado de uno o varios elementos de un archivo1. Copiar en la estructura auxiliar (array o fichero) los elementos que se desean

mantener2. Crear de nuevo el archivo3. Copiar todos los elementos de la estructura auxiliar en el archivo

Inserción de algún elemento1 Copiar en la estructura auxiliar (array o fichero) los elementos anteriores a la1. Copiar en la estructura auxiliar (array o fichero) los elementos anteriores a la

posición donde se va a insertar el nuevo elemento2. Copiar en la estructura auxiliar el nuevo elemento3. Copiar en la estructura auxiliar los elementos del archivo que quedan hasta el

final del archivofinal del archivo4. Crear de nuevo el archivo

1. Si la estructura auxiliar es un ARRAY => Copiar los elementos del array en el archivo2. Si la estructura auxiliar es un FICHERO => Renombrar el fichero

Ordenación del contenido del fichero1. Recorrer el archivo e ir añadiendo los elementos en un array de forma

ordenada2. Volcar todo el fichero en el array (desordenado) y ordenar en el array


2. Volcar todo el fichero en el array (desordenado) y ordenar en el array

Otros procedimientos con pficheros

Elimina todos los elementos desde la posición del punteroPROCEDURE Truncate(Var_archivo)

NOTA: Conviene cerrar el fichero tras utilizar TruncateNOTA: Conviene cerrar el fichero tras utilizar Truncate

Borrar el archivo físico asociado a un fichero lógicoPROCEDURE Erase (Var archivo)PROCEDURE Erase (Var_archivo)

NOTA: Es conveniente que el archivo esté cerrado antes de usar Erase

Obtención del número de elementos contenidos en un archivoPROCEDURE Rename(Var_archivo, sNuevoNombreArchFisico)

NOTA: No debe usarse con archivos abiertos

Puntero > 2


Puntero -> 2

Í di0 1 2 3 4


Índice0 1 2 3 4

EjemplosVARfbrFichero: FILE OF Real;

EjemplosfbrFichero: FILE OF Real;iPos, iElem: Integer;

BEGINAssign(fbrFichero, ‘DATOS.DAT’);Assign(fbrFichero, DATOS.DAT );Reset(fbrFichero);{Posicionar el puntero en una posición}Seek (fbrFichero, iPos);( , ){Elimina los elementos a partir de la posición del puntero}Truncate (fbrFichero);Close(fbrFichero);

{Borra un fichero, previamente debe estar cerrado}Assign(fbrFichero, ‘FICHERO1.DAT’);Erase(fbrFichero); {FICHERO1.DAT ya no existe en el disco}

{Cambia el nombre de un fichero en el disco}i (fb i h 2 )


Assign(fbrFichero, ‘FICHERO2.DAT’);Rename(fbrFichero, ‘FICHERO3.DAT’);

Algoritmos usando FicherosAlgoritmos usando Ficheros auxiliares (Borrado)

1. Buscar la posición del elemento a borrar (BUSQUEDA SECUENCIAL)2. Pasar todos los datos a partir del elemento a borrar al fichero auxiliar (p.e.

‘AUX.DAT’))3. Truncar el fichero original (p.e. ‘DATOS.DAT’) hasta el elemento a borrar

(Posicionando previamente el puntero en el elemento a borrar)4. Añadir los datos del fichero ‘AUX.DAT’ al final del fichero ‘DATOS.DAT’

l f h l (‘ ’)5. Borrar el fichero auxiliar (‘AUX.DAT’)

DATOS.DAT AUX.DAT2

iPosBorrar=4

E F G

3

A B C D E F G

A B C E F G

4A B C E F G

5


A B C E F G

PROCEDURE VolcarParteFicheroAOtro( sNomFich: tsCadLargas;sNomFichTemp: tsCadCortas;p

sNumCuenta: tsCadCortas);VAR

fbrgFich, fbrgFichTemp: tfbrgFicheros;rgCredito: trgCreditos;rgCredito: trgCreditos;...

BEGINAssign(fbrgFichTemp, sNomFichTemp); g g p pRewrite(fbrgFichTemp);iPosicion:= fniBuscarCreditoCuenta(...); {1}...Assign(fbrFich sNomFich);Assign(fbrFich, sNomFich);Reset(fbrFich);Seek(fbrFich, iPosicion + 1); WHILE NOT Eof(fbrgFich) DO {2}

BEGIN Read(fbrgFich, rgCredito);Write(fbrgFichTemp,rgCredito);END;END;

Seek(fbrgFich, iPosicion);Truncate(fbrgFich); {3}Close(fbrgFich);


Close(fbrgFichTemp);END;

PROCEDURE AnyadirFicheroAOtro ( sNomFichOrig, y ( g,sNomFichDest: tsCadLargas);

VARfbrgFichOrig, fbrgFichDest: tfbrgFicheros;rgCredito: trgCreditos;rgCredito: trgCreditos;

BEGINAssign(fbrgFichOrig, sNomFichOrig); Reset(fbrgFichOrig);g g

Assign(fbrFichDest, sNomFichDest);Reset(fbrFichDest);

Seek(fbrgFichDest, FileSize(fbrgFichDest));

WHILE NOT EOF(fbrgFichOrig) DO {4}BEGIN Read(fbrgFichOrig, rgCredito);Write(fbrgFichDest,rgCredito);END;END;

Close(fbrgFichOrig); Close(fbrgFichDest);


END;

PROCEDURE BorrarFichero ( sNomFich tsCadLargas)PROCEDURE BorrarFichero ( sNomFich: tsCadLargas);VAR

fbrgFich: tfbrgFicheros;BEGIN

Assign(fbrgFich, sNomFich); {5}Close(fbrgFich);

END;

PROCEDURE EliminarCredito (sNomFich: tsCadLargas; sNumCuenta: tsCadCortas);

VARsNomFichTemp: tsCadLargas;

BEGINsNomFichTemp:= ‘AUX.DAT’;{1 2 3}{1, 2, 3}VolcarParteFicheroAOtro(sNomFich, sNomFichTemp, sNumeroCuenta);{4}AnyadirFicheroAOtro(sNomFichTemp, sNomFich);{5}BorrarFichero(sNomFichTemp);

END;


Ejemplo: Inserción usando j pficheros auxiliares

PROCEDURE InserReg(CONST rgReg: trgReg; sNomFich: tsCad);VAR

fbrgFich, fbrgFichAux: tfbFicheros;BEGINBEGIN

{ -1 NO ENCONTRADO}iPos:= fniBuscarPosicion(rgReg, sNomFich);

Assign(fbrgFich, sNomFich);Reset(fbrgFich);

Assign(fbrgFichAux ‘DATOS AUX’);Assign(fbrgFichAux, ‘DATOS.AUX’);ReWrite(fbrgFichAux);

Seek(fbrgFich, iPos); {Puntero en posición donde insertar}

WHILE NOT EOF(fbrgFich) DO {Volcar registros a Fichero auxiliar}BEGINRead(fbrgFich rgDato);


Read(fbrgFich, rgDato);Write(fbrgFichAux, rgDato);END;

Seek(fbrgFich, iPos);(fb i h) li i i l dTruncate(fbrgFich); {Eliminar registros ya volcados a DATOS.AUX}

Close(fbrgFich); {Cerrar archivos para actualizar cambios}Close(fbrgFichAux);Close(fbrgFichAux);

Assign(fbrgFich, sNomFich); {Reabrir archivos}Reset(fbrgFich);

i (fb i h ‘ t ’)Assign(fbrgFichAux, ‘Datos.aux’);Reset(fbrgFichAux);

Seek(fbrgFich, FileSize(fbrgFich)); {Insertar registro en la}( g , ( g )); { g }Write(fbrgFich, rgReg); {última posición }

WHILE NOT EOF(fbrgFichAux) DO {Volcar los datos del fichero}BEGIN { ili l fi h i i l}BEGIN {auxiliar al fich. original}Read(fbrgFichAux, rgDato);Write(fbrgFich, rgDato);END;;

Close(fbrgFich); {Cerrar archivos}Close(fbrgFichAux);

Isidro Calvo - DISA (UPV/EHU) 399Erase(fbrgFichAux); {Borrar el fichero auxiliar}

END;

i h j i iFicheros Ejercicios


Ejemplo: Programa 6 Pág 107PROGRAM fichb_6 ;USES

Crt ;

j p g g

CONSTiLIMITE = 60 ;

TYPEtsCadena = STRING [40] ;tsCadena = STRING [40] ;

trgPersona = RECORDsNombre, sApellido1, sApellido2, sDomicilio : tsCadena ;iAnyoNacimiento : IntegeriAnyoNacimiento : Integer END ;

tfbrgFicherosCenso = FILE OF trgPersona ;

VARsNomFichCenso, sNomFichMayores : tsCadena ;iAnyoActual : Integer ;


iAnyoActual : Integer ;cResp : Char ;

PROCEDURE MostrarDatosPersona (CONST rgPersona : trgPersona) ;VAR

cEspera : Char ;cEspera : Char ;BEGIN

WITH rgPersona DOBEGINWriteln (' Nombre : ' sNombre) ;Writeln ( Nombre : , sNombre) ;Writeln ('Apellido 1 : ', sApellido1) ;Writeln ('Apellido 2 : ', sApellido2) ;Writeln (' Domicilio : ', sDomicilio) ;Writeln ('A¤o de nacimiento : ' iAnyoNacimiento) ;Writeln ( A¤o de nacimiento : , iAnyoNacimiento) ;cEspera := readkey END

END ; { MostrarDatosPersonal () }

PROCEDURE MostrarDatosFichero (sNomFich : tsCadena) ;VAR

rgPersona : trgPersona ; fbrgFichCenso : tfbrgFicherosCenso ;BEGINBEGIN

Assign (fbrgFichCenso, sNomFich) ;Reset (fbrgFichCenso) ;WHILE NOT Eof (fbrgFichCenso) DO

BEGINBEGIN{Leer datos de una persona}Read (fbrgFichCenso, rgPersona) ;{ Mostrar la informaci¢n le¡da }MostrarDatosPersona (rgPersona)


MostrarDatosPersona (rgPersona)END ;

Close (fbrgFichCenso) END ;

PROCEDURE CrearFicheroMayores (sNomFichCenso, i h dsNomFichMayores : tsCadena ;

iAnyoActual : Integer) ;VAR

rgPersona : trgPersona ;rgPersona : trgPersona ;fbrgFichCenso, fbrgMayores : tfbrgFicherosCenso ;

BEGINAssign (fbrgFichCenso, sNomFichCenso) ;

t (fb i hC )Reset (fbrgFichCenso) ;

Assign (fbrgMayores, sNomFichMayores) ;Rewrite (fbrgMayores) ;( g y ) ;

WHILE NOT Eof (fbrgFichCenso) DOBEGINR d (fb Fi hC P )Read (fbrgFichCenso, rgPersona) ;

IF (iAnyoActual - rgPersona.iAnyoNacimiento) >= iLIMITE THENWrite (fbrgMayores, rgPersona)( g y , g )

END ;

Close (fbrgFichCenso) ; Cl (fb M )


Close (fbrgMayores) END ; { CrearFicheroMayores () }

FUNCTION fnrPorcentaje (sNomFichMayores sNomFichCensoFUNCTION fnrPorcentaje (sNomFichMayores, sNomFichCenso : tsCadena) : Real ;

VARfbrgFichCenso : tfbrgFicherosCenso ;fbrgMayores : tfbrgFicherosCenso ;

BEGINAssign (fbrgFichCenso, sNomFichCenso) ;Reset (fbrgFichCenso) ;Reset (fbrgFichCenso) ;

Assign (fbrgMayores, sNomFichMayores) ;Reset (fbrgMayores) ;

fnrPorcentaje := (Filesize (fbrgMayores) / Filesize (fbrgFichCenso)) * 100;

Close (fbrgFichCenso) ;Close (fbrgMayores)

END ; { fnrPorcentaje () }


BEGIN {******************* PROGRAMA PRINCIPAL ******************}Write ('Nombre del fichero del censo: ') ;readln (sNomFichCenso) ;

Writeln ;Write ('Nombre del fichero de los mayores de ' iLIMITE ' a¤os: ') ;Write ( Nombre del fichero de los mayores de , iLIMITE, a¤os: ) ;Readln (sNomFichMayores) ;

Writeln ;Write ('A¤o actual : ') ;Readln (iAnyoActual) ;

CrearFicheroMayores (sNomFichCenso sNomFichMayores iAnyoActual) ;CrearFicheroMayores (sNomFichCenso, sNomFichMayores, iAnyoActual) ;

Writeln ;Writeln ('Contenido del fichero del censo: ') ;MostrarDatosFichero (sNomFichCenso) ;

Writeln ;Writeln ('Contenido del fichero de los mayores de ' iLIMITEWriteln ( Contenido del fichero de los mayores de , iLIMITE,

' a¤os: ') ;MostrarDatosFichero (sNomFichMayores) ;Writeln ;


Writeln ('Porcentaje de mayores de ', iLIMITE, ' a¤os: ',fnrPorcentaje (sNomFichMayores, sNomFichCenso):0:2, '%') ;

END.

Ejemplo: Programa 9 Pág 108PROGRAM Ej9Pg108;TYPEtsNombres= STRING[40];

j p g g

tsNombres= STRING[40];tsNomFich= STRING[12];tfbsCreditos= FILE OF tsNombres;

VARsNomFichOfi1, sNomFichOfi2: tsNomFich;fbsOfi1, fbsOfi2: tfbsCreditos;sPersonaOfi1, sPersonaOfi2: tsNombres;boSeguir: Boolean;boSeguir: Boolean;

BEGIN

Write('Nombre del fichero de la oficina 1: ');ReadLn(sNomFichOfi1);

Write('Nombre del fichero de la oficina 2: ');Write('Nombre del fichero de la oficina 2: ');ReadLn(sNomFichOfi2);

Assign(fbsOfi1, sNomFichOfi1);


ReWrite(fbsOfi1);

WriteLn('************************************');WriteLn('Personas con dos creditos concedidos');WHILE NOT EOF(fbsOfi1) DO

BEGINBEGINRead(fbsOfi1, sPersonaOfi1);Seek(fbsOfi2, 0);boSeguir:= TRUE;g ;WHILE NOT EOF(fbsOfi2) AND boSeguir DO

BEGINRead(fbsOfi2, sPersonaOfi2);IF P Ofi1 P Ofi2 THENIF sPersonaOfi1 = sPersonaOfi2 THEN

BEGINWriteLn(sPersonaOfi1);boSeguir:= FALSE;gEND

ELSE IF sPersonaOfi2> sPersonaOfi1 THENboSeguir:= FALSE;

ENDEND;END;

WriteLn('************************************');Close(fbsOfi1);


( )Close(fbsOfi2);

END.

Rellenar ficherosAssign(fbsOfi1, sNomFichOfi1);ReWrite(fbsOfi1); Assign(fbsOfi2, sNomFichOfi2);

sPersonaOfi1:= '1';Write(fbsOfi1, sPersonaOfi1);sPersonaOfi1:= '2';

gReWrite(fbsOfi2);

sPersonaOfi2:= '2';Write(fbsOfi2 sPersonaOfi2);sPersonaOfi1:= '2';

Write(fbsOfi1, sPersonaOfi1);sPersonaOfi1:= '3';Write(fbsOfi1, sPersonaOfi1);

Write(fbsOfi2, sPersonaOfi2);sPersonaOfi2:= '3';Write(fbsOfi2, sPersonaOfi2);sPersonaOfi2:= '5';

sPersonaOfi1:= '7';Write(fbsOfi1, sPersonaOfi1);sPersonaOfi1:= '9';Write(fbsOfi1 sPersonaOfi1);

Write(fbsOfi2, sPersonaOfi2);sPersonaOfi2:= '6';Write(fbsOfi2, sPersonaOfi2);sPersonaOfi2:= '7';Write(fbsOfi1, sPersonaOfi1);

sPersonaOfi1:= '15';Write(fbsOfi1, sPersonaOfi1);sPersonaOfi1:= '17';

sPersonaOfi2:= '7';Write(fbsOfi2, sPersonaOfi2);sPersonaOfi2:= '8';Write(fbsOfi2, sPersonaOfi2);

Write(fbsOfi1, sPersonaOfi1);Close(fbsOfi1);

Assign(fbsOfi2 sNomFichOfi2);

sPersonaOfi2:= '9';

Write(fbsOfi2, sPersonaOfi2);Close(fbsOfi2);


Assign(fbsOfi2, sNomFichOfi2);ReWrite(fbsOfi2);

Close(fbsOfi2);

introduccion pascal

Documents