RESUMEN PROGRAMACIÓN 1 SEGUNDO SEMESTRE
COMPUTADOR
LENGUAJES
PASCAL
SALIDA Y ENTRADA
SECUENCIA Y SELECCIÓN
ESTRUCTURAS DE CONTROL
ARREGLOS Y SUBRANGOS
REGISTROS, ORDINALES, ENUMERADOS Y CONJUNTOS
ARRAY CON TOPE Y REGISTROS VARIANTES
ESTRUCTURAS DE DATOS DINÁMICAS Y PUNTEROS.
1
2
2
3
6
7
13
18
23
25
1
COMPUTADOR
Componentes
●
Dispositivos de entrada
○
Teclado
○
Mouse
○
Pantalla
○
Táctil
○
Micrófono
❖ Dispositivos de salida
➢ Monitor Impresora
➢ Parlante Memoria: interna, externa.
➢ Unidad Central de Proceso (CPU)
Dentro del CPU
●
●
Unidad de control
○
Carga instrucciones en memoria (es un programa).
○
Ejecuta las instrucciones.
Unidad aritmética lógica
○
Ejecuta operaciones aritméticas y lógicas.
LENGUAJES
Lenguajes de alto nivel
●
Pascal
●
Python
●
JAVA
●
C
Compilador
●
El compilador traduce los lenguajes de alto nivel a lenguaje máquina.
●
(El computador no entiende los lenguajes de alto nivel).
Código fuente
●
Es aquel programa que contiene código lenguaje X (Pascal, Java, etc).
2
PASCAL
Sintaxis de los identificadores
identificador = {letra|dígito}
Identificadores
●
Un identificador es una secuencia de caracteres alfanuméricos.
●
El primero de los cuáles debe ser alfabético.
●
No pueden ser palabras reservadas.
○
Ej: program
Declaración de constantes
const
PI = 3.14
Observación
-maxint es válido para las declaraciones de constantes.
Declaración de variables
var
tipo de identificador (real, integer, etc).
Cuerpo
begin
instruccion { ';' instruccion }
end.
Tipos de instrucciones
●
Entrada
○
●
Asignación
○
●
ReadLn (instrucción que permite ingresar datos).
area := base * altura / 2
Salida
○
WriteLn
SALIDA Y ENTRADA
Entrada estándar
●
Secuencia de caracteres.
●
Las instrucciones de secuencia consumen caracteres de entrada.
3
●
Después se carga la información en memoria.
●
Los caracteres consumidos en la entrada desaparecen.
●
El final de la entrada se puede identificar por programa.
●
Enter indica el final de la línea.
Entrada como secuencia de líneas
●
Está organizada en líneas.
●
El fin de cada línea está marcado por una secuencia de caracteres especiales.
●
Los caracteres del final de la línea son dependientes del entorno.
Salida estándar
●
Secuencia de caracteres.
●
Dividida en líneas.
●
Asociada a la terminal donde se ejecuta el programa.
Asignación
●
Instrucción.
●
Permiten modificar el contenido de una variable.
●
Esto se hace mediante expresiones.
●
La variable y la expresión deben ser compatibles en cuanto a tipos.
Tipos
●
Toda variable tiene un tipo.
●
Demuestran características y propiedades de los valores usados en el programa.
●
Sucede también con los operadores, las funciones estándar y las definidas por el
user.
●
El chequeo de tipos se hace en tipo de compilación (Pascal).
Clasificación de tipos
●
Estructura
○
Elementales
■
○
Valores simples e indivisibles.
Estructurados
4
■
●
Los valores están compuestos por otros varios valores.
Otros:
○
Predefinidos o estándar.
○
Definidos por el user.
Expresión
●
Se construye mediante
○
Variables.
○
Constantes.
○
Funciones
○
Operadores.
■
Producto: *
■
Suma: +
■
Resta: -
■
División: div (para enteros) y / (para reales).
■
Módulo: mod.
Observación: Al realizarse una expresión que combina enteros y reales, se realiza una conversión
automática.
Funciones aritméticas estándar
●
sqr(x):retorna el cuadrado de x.
●
sqrt(x):retorna la raíz cuadrada de x.
●
trunc(x), round(x):es la conversión real a entero.
●
abs(x):retorna el valor absoluto de x.
Valores de tipo Real
●
Se puede escribir en forma de notación científica.
●
Los valores reales pueden o no tener punto decimal.
5
Valores de tipo boolean (True, false)
●
Constantes
○
●
(True, false)
Operadores
○
not (negación)
○
and
○
or (disyunción)
(Están en orden de precedencia)
Valores de tipo char
●
Caracteres simples.
●
Se representan con comillas simples. (‘’)
Para evaluar con el operador And: (E 1 and E2)
●
Se evalúa E1 , sea b1 su valor.
●
Se evalúa E2 , sea b2 su valor.
(conjunción)
6
●
Posteriormente se evalúa b1 and b2.
Observación : Es análogo para el or.
Booleanos por circuito corto
●
Para evaluar E1 and E2.
●
Se evalúa el valor de E1, siendo su valor igual a b1.
●
Si b1 es FALSE, se termina el proceso y el resultado es FALSE.
●
Si b1 es TRUE se evalúa el valor de E2. Siendo el valor b2 el valor de la afirmación
concluye en el valor de b2.
SECUENCIA Y SELECCIÓN
Instrucciones simples
●
Llamadas a procedimientos.
●
Asignaciones.
Instrucciones compuestas
●
Secuencia.
●
Selección.
●
Repetición (For, while, repeat).
Ejemplo: Determinar si un número es par o impar.
program ParImpar;
var
numero : integer;
begin
(* Ingresar numero *)
write('Ingrese numero: ');
readln(numero);
(*analizar el numero*)
if numero mod 2 = 0 then
writeln('El numero ingresado es par')
else
writeln('El numero ingresado es impar')
end.
7
La ejecución de if:
if expresión then
instrucción 1
else
instrucción 2
end
1. Se evalúa la expresión booleana; sea b su valor.
2. Si b es TRUE se ejecuta la instrucción 1.
3. Si b es FALSE se ejecuta la instrucción 2.
(si la instrucción es del tipo if - then, si b es falso no se ejecuta nada)
Anidamiento de las instrucciones compuestas
if i > 0 then
begin
i:= i+1;
writeln('Es positivo')
end
else (sin punto)
begin
i:= i*4;
writeln('Es negativo')
end
ESTRUCTURAS DE CONTROL
¿Qué es un centinela?
●
Sirve para marcar el fin de una secuencia/lista de datos de la entrada estándar.
Instrucción case
●
Permite seleccionar una instrucción de un conjunto de instrucciones.
●
Se escribe de la siguiente manera:
begin
readln(‘valor de la constante’)
case Expresión of
constante1, constante2 : Writeln(‘enunciado’)
.
.
.
end; (este end termina el case)
end.
8
Instrucción While
●
Es una repetición condicional.
●
Se escribe de la siguiente forma:
while Expresión do Instrucción
●
La expresión es de tipo boolean.
●
La instrucción es de cualquier tipo.
●
Ejecución:
○
Evalúa la condición del while, si resulta FALSE se termina el while.
○
Si es TRUE ejecuta la instrucción y vuelve al paso 1.
Instrucción Repeat
●
Es una expresión de tipo boolean.
●
No hay necesidad de delimitar las instrucciones mediante begins y ends.
●
Se escribe de la siguiente forma:
Repeat
Instrucción
Instrucción
.
.
.
Until Expresión
●
Se ejecuta el Repeat ( se repite por lo menos una vez).
●
Se evalúa la Expresión (until), si el valor de Expresión es FALSE se vuelve al
paso 1.
●
Si el valor de Expresión (until) es TRUE se termina el proceso.
Instrucción For
●
Instrucción controlada por una variable que toma valores en un rango
determinado.
●
La instrucción se escribe de la manera:
●
For variable To variable
writeln(‘escribir algo’)
o
Expresión
Cuando usar el For:
○
En una función numérica expresada por sumatoria o productoria.
○
Recorrer un rango de enteros (o de caracteres) completamente.
9
○
Repetir algo N-veces. (Donde N es una expresión entera).
Errores generales con acumuladores
●
Vida de un acumulador:
○
Inicialización: Se le da un valor inicial a una variable (v = valor).
○
Acumulación: Dentro de la repetición, sucede la actualización del valor del
acumulador en función al anterior (v = f(v)).
○
Utilización del resultado después de la iteración.
●
Incluir un control en donde diga que el primer valor es menor o igual al segundo.
●
Modificar el valor de la variable de control “para avanzar más rápido”.
●
Usar la variable de control una vez terminada la repetición.
●
Anidar innecesariamente un “ if ” dentro del cuerpo de la iteración.
SUBPROGRAMAS, PROCEDIMIENTOS Y FUNCIONES
Subprograma
●
Es un fragmento de código que se comporta de forma independiente dentro de un
programa.
●
Pueden ser invocados varias veces desde otras partes del programa.
●
Se comunican por el pasaje de parámetros.
●
Tienen sus propios espacios de nombres (identificadores locales).
●
Los identificadores locales pueden ser compartidos entre subprogramas y el
programa principal (identificadores globales).
●
Son herramientas de modularización.
Función
●
Subprograma.
●
Retorna valores tipo simples.
10
●
Funciones estándar: succ, ord, pred, sqrt, chr, trunc, etc.
●
Son declaradas después de la declaración de variables.
●
Se escribe de la siguiente manera:
function nombre(lista de parametros): Integer
const
...
type
...
begin
...
end;
● Los tipos de funciones deben ser simples (Integer, char, boolean)
●
La lista de parámetros se escribe de la forma:
function nombre(var a: real; c: char; var n: integer (LISTA DE PARÁMETROS) ):
Integer;
●
Hay dos tipos de parámetros:
○
Nominales o Formales: aparecen en el encabezado de la función.
○
Efectivos o verdaderos: aparecen en la invocación de la función.
○
Los dos parámetros deben ser respectivamente compatibles.
●
No hacer instrucciones de entrada y salida (read, write, etc).
●
No utilizar variables globales (variables usadas en el programa principal).
●
Definir funciones para cálculos intermedios independientes.
●
Definir funciones de semántica clara.
Procedimientos
●
No retornan valor en su nombre.
●
Se invoca como instrucción independiente.
●
Se escribe de la forma:
procedure procedure_Name(variable1: Tipo);
●
Podemos ver que se pueden categorizar los procedimientos:
○
Salida: No hacen entrada, solo despliegan resultados en la salida. No tiene
parámetros por referencia.
○
Entrada: Se ingresan datos de entrada y se cargan en variables. Solo
hacen salida para pedir que el usuario ingrese estos. Contiene datos de
referencia.
○
Internos: No realizan entrada-salida, solo devuelven valores de variables
modificadas del programa. Contiene parámetros por referencia y por
valor.
11
Pasaje de parámetros por valor
●
Parámetros no precedidos por var.
●
En el momento de invocación se realiza una copia de los parámetros nominales a
los parámetros efectivos.
●
Los parámetros efectivos pueden ser expresiones.
Pasaje de parámetros por referencia
●
Los parámetros efectivos deben ser variables.
●
Deben ser compatibles (ser del mismo tipo).
●
Todo cambio en el parámetro nominal se ve reflejado en el parámetro efectivo.
●
Lo anterior no sucede al revés. (No es recíproco)
●
Es recomendado no usarlo para funciones.
Alcance
●
Característica de un identificador.
●
Es una porción del programa donde el identificador es visible.
Localidad y globalidad de identificadores
●
Los identificadores definidos es un bloque son visibles en el bloque y todos los
sub-bloques que se contengan dentro de este.
●
Los parámetros nominales x e y, y la variable z son identificadores locales de p.
●
Los parámetros nominales x e y, y la variable z son identificadores globales de f
(por estar dentro de p).
●
Se puede hacer referencia a x, y, z dentro de las sentencias que se llevan a cabo
dentro de p y f.
●
No son visibles fuera de p.
●
El parámetro nominal a y la variable b son locales a f pero no se pueden
12
referenciar fuera de f (únicamente en las sentencias de f).
●
Si dos identificadores locales y globales comparten el mismo nombre, los
identificadores locales tienen prioridad en las sentencias que se llevan a cabo.
●
El parámetro nominal x de p es visible en p.
●
El parámetro nominal x de p no es visible en f.
●
Toda referencia a x que se haga dentro de f corresponde al parámetro nominal de
f y no a la variable global x.
Llamamiento a funciones y procedimientos
●
●
f es llamada desde:
○
Las sentencias de p (local a este).
○
Dentro de las propias sentencias de f (llamada recursiva).
○
Dentro de g (incluyendo a k).
g es llamada desde:
○
Las sentencias de p.
○
Dentro de g.
○
Las sentencias de k (por ser global a k).
13
●
La función g no puede ser llamada desde f por el orden de declaración.
●
El procedimiento k no puede ser llamado desde afuera de g por ser local a g.
ARREGLOS Y SUBRANGOS
●
Pascal permite al programador crear distintos tipos en el programa.
●
Se hace con la palabra reservada “type”.
●
Subrangos, enumerados, estructurados, etc pueden ser tipos de datos definidos
por el programador.
●
Declaración de tipos:
type
Nombre_Tipo = Tipo;
Subrangos de enteros
●
Se pueden acotar los valores en un rango especificado.
Subrangos de caracteres
●
Se basan en el orden predefinido en el tipo Char (en Pascal es la tabla ASCII).
●
Decimal <> Dígito.
14
Operaciones con subrangos
●
Cualquier variable, constante, expresión de tipo subrango se va a comportar como
el tipo base que lo contiene.
●
Si el valor de una variable de tipo subrango se pasa del rango de valores puesto
por el programador, ocurre un error en el tiempo de ejecución.
●
El compilador de Pascal debe ser configurado (flag -Cr) para realizar una
verificación de rangos.
Declaración de subrangos
type
identificador= C1..C2;
●
C1 y C2 deben ser del mismo tipo ordinal (Char, Integer, Boolean y enumerado).
Tipos estructurados
●
Arreglos (arrays).
●
Registros (records).
●
Conjuntos (set).
¿Para qué sirven los tipos estructurados?
●
Almacenar un conjunto de valores a un mismo nombre de valores.
●
Los valores se pueden acceder mediante un índice.
●
Están inspirados tal cual como en la matemática (a1 , a2 , … , an).
Declaración de los arreglos
type
nombre = array [tipo_indice] of tipo_base;
Arreglos
●
Secuencias homogéneas.
●
Tienen un tamaño fijo.
●
Su orden importa.
●
Pueden haber repetidos.
15
●
Ejemplo:
type
RangoArreglo = 1..9;
Arreglo = array [RangoArreglo] of integer;
var
A : Arreglo;
●
Si materializamos lo escrito:
●
Los índices deben ser del tipo ordinal.
●
Tipo_base debe ser de cualquier tipo de Pascal.
Tipos anónimos
●
Sirven para los tipos que aparecen una sola vez.
●
Se asignan sin nombres.
type
(* índice anónimo *)
arreglo = array [0..9] of real;
var
(* arreglo anónimo *)
arr : array ['A'..'Z'] of boolean;
Acceso a un arreglo
●
●
A cada celda se le puede acceder como una variable independiente.
16
Inicialización del arreglo
●
Se deben inicializar todas las celdas por separado.
(* celdas de 1 a 10 en cero *)
procedure ArregloEnCero(var A: arreglo);
var i: integer;
begin
for i:= 1 to 10 do
A[i]:= 0;
end;
(* celdas de 1 a 10 en pares 2, 4, 6, ... *)
procedure ArregloEnPares(var A: arreglo);
var i: integer;
begin
for i:= 1 to 10 do
A[i]:= 2 * i;
end;
(* celdas leídas desde la entrada *)
procedure Leer Arreglo(var A: arreglo);
var i: integer;
begin
for i:= 1 to 10 do
ReadLn(A[i]);
end;
Recorridas de arreglos
●
Es correcto usar la estructura “for” para recorrer todo el arreglo.
...
for i:= 1 to 10 do
suma:= suma + A[i];
SumarTodos := suma;
...
Búsqueda en arreglos
●
En este caso no se usa el “for”.
●
Es ineficiente usar “for” porque seguirá buscando una vez encontrada la celda que
cumpla con la condición buscada.
●
Es eficiente usar iteraciones condicionales (while).
●
La búsqueda debe detenerse cuando se halla el valor que cumpla la condición
puesta. (Por eso es ineficiente usar “for”).
●
Tener en cuenta que Pascal evalúa por circuito corto.
(ver ejemplos del repartido)
17
Arreglos multidimensionales
●
Son arreglos de arreglos.
●
Arreglos de índice múltiple.
●
Son/pueden ser matrices.
●
Se acceden mediante el identificador A[i,j] o A[i] [j].
●
Declaración de arreglos multidimensionales.
type
nombre = array [1..20, 1..15] of char;
datos = array ['0'..'9', 1..10] of integer;
tabla = array [-10..10, 1..15] of char;
REGISTROS, ORDINALES, ENUMERADOS Y CONJUNTOS
Registro
●
Colección heterogénea de datos.
●
A la misma vez es ordenada.
●
Son conocidos como tuplas.
●
Tienen tamaños fijos.
Record
●
Es la estructura más usada para la representación de entidades u objetos de la
realidad.
●
Es una tupla de datos de diferente tipo.
●
Cada uno se accede mediante un nombre de campo.
Declaración de registros
type
●
T= record
campo1 : tipo1;
campo2 : tipo2;
...
campoN : tipoN
end;
Donde campo-i es un identificador de campo.
●
Donde tipo-i es el tipo correspondiente.
18
Posibilidades para usar registros
Acceso a los componentes de los registros
●
“.campo” se utiliza como método de acceso a los componentes de un registro.
...
q.campo1:= tipo1;
q.campo2 := tipo2;
writeln(q.campo3)
...
Lectura y escritura de registros
●
No se le puede aplicar un read/ln a una variable de un tipo registro.
●
Para mostrar un registro se deben aplicar write/ln campo por campo.
Instrucción with
●
Simplifica la forma de acceder a los campos de un registro.
●
Se escribe de la siguiente manera:
...
with q do
begin
…
end
...
(ver ejemplos y utilidades en el repartido).
19
Asignación de variables tipo registro
●
Se puede asignar a otra del mismo tipo.
Estructuras complejas
●
Anidamiento en tipos estructurados:
Variables de tipo ordinal o escalares
●
●
Las variables de tipo ordinal son:
○
Integer.
○
Char.
○
Boolean.
○
Subrangos.
○
Enumerados.
pred () y succ () son funciones que se pueden aplicar para este tipo de
variables.
●
La variable Real no es ordinal.
Construcciones de pascal relacionadas con el tipo ordinal
●
For: El tipo de la variable que se cuenta debe ser de tipo ordinal.
●
Case: El tipo de expresión dentro de la instrucción debe ser ordinal.
●
Array: El tipo del índice del arreglo debe ser ordinal.
●
Set of: El tipo base de un conjunto (set) debe ser ordinal.
20
Enumerados
●
Son datos cuyos valores son enumerados.
●
Pueden ser ordenados o no ordenados.
●
Boolean es un enumerado predefinido.
●
Quedan definidos los operadores de comparación:
●
○
<
○
>
○
<>
○
<=
○
>=
Quedan definidas las funciones:
○
succ()
○
predd()
●
No se pueden realizar instrucciones de entrada (read/ln).
●
No se pueden realizar instrucciones de salida (write/ln).
(ver ejemplos en el repartido)
Declaración de tipos enumerados
type
identificador=(T1, … , Tn)
● Ti son identificadores cualesquiera.
Conversión entre enumerados y enteros
●
Enumerado a entero:
○
Se usa la función ord que le asigna un entero de acuerdo al orden de
enumeración.
○
Se usa el nombre del tipo como función.
Mes(0) --> enero
Conjuntos
●
Inspirados en el conjunto matemático.
●
No tienen orden.
●
No hay repetidos.
●
El tamaño es variable pero acotado.
●
Se usan para la representación de conjuntos simples.
●
Representa el conjunto potencia de un conjunto.
21
●
Se usan los operadores algebraicos adecuados.
○
Declaración del tipo conjunto
type
T= set of tipo_elempento
●
T es el identificador.
●
T es el nombre del tipo conjunto que se define.
●
tipo_elemento es un tipo ordinal. (Tipo base)
●
En FPC el cardinal del tipo base no puede superar los 256.
●
No admite elementos con cardinal negativo ej: (-10..10).
●
ej:
type
inset = set of Integer ;
● No funciona porque es demasiado grande.
Representación de conjuntos
●
Para:
type
conj = set of 0..9 ;
● Son correctos:
○
[2,4,6,8]
○
[]
○
[1,3]
○
[1..3, 4..9]
(ver ejemplos del repartido)
22
ARRAY CON TOPE Y REGISTROS VARIANTES
Array con tope
●
Estructura conceptual.
●
Se define en términos de tipo estructurado:
●
○
Registro.
○
Arreglos.
No hay significado para lo que está más allá del tope (para la lógica del
programa).
Declaración del array con tope
Type
ArrTope = record
elems : array [1..N] of T;
tope : 0..N
end ;
●
El campo tope, controla la cantidad de elementos en el arreglo (toma valores
entre 0 y N).
●
Los elementos válidos se almacenan al principio del arreglo.
●
Toman la posición de 1 al tope.
●
Si tope = 0 no hay elementos.
Conjuntos mediante arreglos con tope
Type
Conj = record
elems : array [1..N] of T;
tope : 0..N
end;
●
El arreglo almacena los valores del conjunto.
●
Los elementos están distribuidos en las celdas de 1 a N.
●
Tope apunta a la última posición ocupada del arreglo.
●
Se pueden representar conjuntos que van de 0 a N.
Operaciones con conjuntos cuando no son de tipo sets
●
Crear conjunto vacío:
procedure CrearConjuntoVacio(var S: Conj);
begin
S.tope := 0
end
23
●
Insertar un elemento:
●
procedure InsElem(e: T; var S: Conj);
begin
with S do
begin
tope := tope + 1
elems [tope] := e
end
end;
Eliminar un elemento:
procedure procedureName(e : T; var S: Conj);
var
i: Integer
begin
i:=1
while (i <= S.tope) and (S.elems[i] <> e) do
i := i+1;
if i <= S.tope then
begin
S.elems[i] := S.elems[S.tope];
S.tope := S.tope - 1
end
end;
Registros variantes
●
Sirven para:
○
Representar entidades que pertenecen a distintas categorías a la vez.
○
Según su categoría tienen distintos datos.
○
Hay un conjunto de datos que cumple con tener todos los elementos en
común con todas las categorías.
●
Teniendo las siguientes categorías:
○
○
○
○
Estudiante:
■
Año de ingreso.
■
Cantidad de materias.
Docente:
■
Carga horaria.
■
Grado.
Egresado:
■
Año de egreso.
■
Título.
Datos comunes a las categorías:
■
C.I.
■
Credencial.
24
Ejemplo:
type
TOrden = (docente,estudiante,egresado);
TUniversitario = record
cedula : TCedula;
credencial : TCredencial;
case orden : TOrden of
docente : (grado: 1..5;
carga: 0..40);
estudiante : (semestre: 1..15;
materias: integer);
egresado : (egreso: 1900..3000;
titulo: TTitulo);
end;
IMPORTANTE: Ver ejemplos en el repartido
ESTRUCTURAS DE DATOS DINÁMICAS Y PUNTEROS.
Estructura de datos dinámica
●
Cambia el tamaño en tiempo de ejecución.
●
Ninguno de los tipos vistos anteriormente permite construir estructuras de datos
dinámicas.
●
Se reserva el espacio de memoria cuando empieza la ejecución.
●
Se vuelve inmutable.
●
Array con tope, set, record (case) no son dinámicos.
Variable tipo puntero
●
Apunta o hace referencia a posiciones con datos en la memoria.
●
Este contiene o toma el valor de la posición/ubicación.
●
Este crea la ubicación de memoria (new), accede a datos de la ubicación
(ˆ desreferenciación) y también puede eliminar/destruir la ubicación de memoria.
●
El valor de la variable es dependiente del computador.
●
No se pueden aplicar Read/ln o Write/ln a variables punteros.
25
Declaración del tipo puntero
type
identificador = ˆIdentificador_tipo
●
Identificador_tipo
puede corresponder a cualquier tipo predefinido por el
programador o por Pascal.
●
El tipo al que pertenece Identificador_tipo puede ser de cualquier tipo de los
de Pascal.
Operaciones con puntero
●
Solo se permite la igualdad ( “ = ” ) entre variables puntero.
Declaración del procedimiento new
new (ptr)
●
ptr es una variable de tipo ˆT.
Ejecución del new:
●
Se crea espacio en memoria.
●
Este corresponde a la variable de tipo T.
●
El espacio que ocupa es dependiendo del tipo.
●
La dirección del espacio se guarda en la variable ptr.
●
Este proceso se llama asignación dinámica de memoria.
●
Estas acciones ocurren en tiempo de ejecución.
●
La variable de tipo T (creada) queda con un valor indefinido.
●
La misma no tiene nombre identificante.
●
Las variables de tipo puntero son inicializadas por la instrucción new.
●
También las variables pueden ser inicializadas por asignaciones a punteros ya
previamente inicializados.
●
SI NO SE INICIALIZAN LAS VARIABLES DA ERROR EN TIEMPO DE
EJECUCIÓN.
●
Para hacer uso de las variables usamos el operador “ ˆ ”.
●
Ej:
...
new (ptr_1)
new (ptr_2)
...
new (ptr_N)
● ptr_1ˆ es apuntada por ptr_1.
●
ptr_iˆ es apuntada por ptr_i.
26
Alias de variables
●
Son punteros que apuntan a la misma dirección.
(Ver ejemplos del repartido)
Punteros como parámetros por valor
type
pint = ^integer;
var p: pint;
procedure PP(q1,q2: pint);
begin
q1^:= q2^ * 2;
q2^:= q1^ + 2;
end;
begin
new(p);
p^:= 4;
PP(p,p);
writeln(p^);
end.
Variables tipo lista
●
Secuencia o sucesión finita de elementos.
●
Son representadas con:
○
Arrays. (No permite agregar y sacar valores)
○
Arrays con tope. (permite agregar y sacar valores)
○
Listas encadenadas (se hace mediante punteros, permite agregar y sacar
valores).
Listas encadenadas
●
Cada elemento de la lista es almacenado en una celda.
●
Cada celda contiene información del elemento.
●
También contiene un puntero que apunta hacia la siguiente celda.
●
Se accede a la lista conociendo el puntero del primer elemento.
Puntero nulo
●
Se representa con la constante nil.
●
Pertenece a todos los tipos ˆT.
●
No representa ninguna dirección de memoria.
●
Se puede asignar directamente a una variable puntero:
○
p:= nil
●
Se usa para representar la lista vacía.
●
Diferenciar el último elemento de una lista encadenada.
27
Declaración de la lista encadenada
type
lista = ^celda;
celda = record
elemento : T;
siguiente: lista
end;
(Pascal admite poner ^celda antes de haber puesto celda)
Instrucción dispose
●
Sirve para indicar al sistema que una celda de memoria no será más utilizada.
●
Ese espacio se puede recuperar y reutilizar.
●
Utilizado comúnmente para borrar elementos de estructuras de datos dinámicas.
Declaración de la instrucción dispose
dispose (ptr)
●
ptr es el puntero de la celda en cuestión.
Borrar lista
●
Para liberar el espacio ocupado por listas se debe liberar celda por celda.
●
dispose (l) borra solo el primer elemento de la lista.
(Ver ejemplos en el repartido)