1

Material de Estudio
Tema: ESTRUCTURAS DE DATOS ESTATICAS: VECTORES
Profesor : Braulio Barrios - Marzo de 2009

Normalmente, utilizamos VARIABLES para almacenar (en memoria RAM) la información que un programa
procesa. Por ejemplo: El CODIGO de un alumno, el NOMBRE, etc. y de acuerdo con esto podemos escribir un
algoritmo que LEA y muestre el código y nombre de un alumno, así:

ALUMNOS
ESCRIBA (“ ***** Captura de datos del Estudiante ***** ”)

ESCRIBA (“ Digite Código del Alumno “);Lea(CODIGO)

ESCRIBA (“ Digite Nombre del alumno “); Lea(NOMBRE)

ESCRIBA (“ ****** Ahora Mostraré un INFORME de datos leídos ***** ”)

ESCRIBA (“ Código : “, CODIGO)

ESCRIBA (“ Nombre : “, NOMBRE)

FIN ALGORITMO ALUMNOS

Observe bien el anterior algoritmo, fíjese que UNICAMENTE podemos introducir y mostrar la información de UN alumno a la vez.

Pero la realidad es otra, es decir, se requiere procesar la información de VARIOS alumnos, por ejemplo, en el
curso de estructuras de datos hay matriculados aproximadamente 15 estudiantes en cada grupo. Que pasaría si
quisiéramos introducir los CODIGOS y NOMBRES de TODOS los alumnos?. Podríamos pensar en re-escribir el
anterior algoritmo utilizando entonces un CICLO REPETITIVO (Remítase a la lección: “FUNDAMENTOS DE
ALGORITMOS Y PROGRAMACIÓN ESTRUCTURADA” ), por ejemplo, un ciclo PARA (Hacer Hasta) así:

ALUMNOS_VERSION2.0

ESCRIBA (“ **** Captura de datos del Estudiante ***** ”)

PARA I
1 Hasta 15 Haga

ESCRIBA (“ Digite Código del Alumno “); Lea(CODIGO)

ESCRIBA (“ Digite Nombre del alumno “); Lea(NOMBRE)

ESCRIBA ( “ **** Ahora Mostraré un INFORME de datos leídos **** ” )

ESCRIBA (“ Código : “, CODIGO)

ESCRIBA (“ Nombre : “, NOMBRE)

FPARA

FIN ALGORITMO ALUMNOS

Este algoritmo evidentemente procesa la información de los 15 alumnos pero tiene una falla, y es que al final del
proceso ( por fuera del ciclo PARA) no podríamos hacer un informe que incluya los CODIGOS y NOMBRES de
TODOS los alumnos cuya información se procesó, ya que cuando digitemos el CODIGO y el NOMBRE del segundo
alumno entonces esta nueva información SOBREESCRIBE a la primera, y al escribir la del tercer alumno se
SOBREESCRIBE la del segundo y así sucesivamente, es decir, se BORRA el CODIGO y el NOMBRE del anterior
estudiante; La razón: Dos datos NO pueden convivir simultáneamente en la misma posición de memoria, es decir,
NO podemos resolver el problema con el enfoque que hemos planteado. Entonces, la solución es: NO UTILIZAR
VARIABLES SIMPLES, sino una ESTRUCTURA DE DATOS para cada dato del alumno, esa ESTRUCTURA DE DATOS es un
VECTOR

Una estructura de datos es una organización de información dispuestos de manera lógica y coherente, de tal
manera que se facilite el acceso a los datos que contiene.

Según el dispositivo de almacenamiento, las Estructuras de Datos se clasifican en: ESTRUCTURAS EN MEMORIA
PRINCIPAL y ESTRUCTURAS EN DISCO DURO. Por su parte, las Estructuras en Memoria RAM pueden clasificarse
en dos grupos: ESTATICAS y DINAMICAS.

El término ESTATICA hace referencia a que una vez se halla definido el tamaño de la estructura de datos este NO
puede ser cambiado mientras se está ejecutando el programa (No se puede Ampliar Ni tampoco Reducir ).

VECTOR DE DATOS: Es una estructura estática que consiste en un conjunto de elementos que satisfacen lo
siguiente:

 DEBE DIMENSIONARSE PREVIAMENTE

 TODOS LOS ELEMENTOS SON DE IGUAL TIPO
 LOS ELEMENTOS SE ALMACENA EN POSICIONES CONSECUTIVAS DE MEMORIA RAM
 2

QUE ES DIMENSIONAR UN VECTOR ? es una acción que consiste en RESERVAR el tamaño que el vector ocupará
en memoria, es decir, cual es la cantidad MAXIMA de elementos que tendrá el vector. Esta cantidad MAXIMA de
elementos la deducimos según el problema que estemos resolviendo; por ejemplo: Si deseo almacenar los
CODIGOS de todos los alumnos de la clase y son aproximadamente 15 alumnos entonces lo aconsejable
es reservar en memoria (Dimensionar) espacio para un poco mas de esos elementos, digamos 20, es
decir, un poco por encima de la cantidad de alumnos que hay pero sin exceso. Para ello, simplemente
escribiremos en los algoritmos la siguiente sentencia:

Dimensionar CODIGOS[20] de Enteros Largos

Dimensionar NOMBRES[20] de Cadenas de caracteres [50] cada una

TODOS LOS ELEMENTOS SON DE IGUAL TIPO: Es algo obvio, puesto que cada TIPO de datos ocupa, como
hemos dicho en clase, cierto numero de bytes, entonces, NO ES POSIBLE mezclar distintos tipos de datos en un
vector: O todos son enteros cortos ó todos son caracteres, ó todos son enteros largos, ó todos son decimales, etc.

LOS ELEMENTOS SE ALMACENAN EN POSICIONES CONSECUTIVAS DE RAM: Puesto que el sistema hace la
reserva de memoria para el vector o la matriz como un solo bloque de bytes, entonces los elementos se guardan
en el vector o matriz uno a continuación de otro.

COMO SE DECLARA UN VECTOR EN LENGUAJE PASCAL ?

En PASCAL un vector se declara como una variable, de la siguiente manera:

Var
Vector : Array [1 .. Max] OF Tipo_dato ;

Donde Tipo_dato corresponde a uno de los definidos en PASCAL ( integer, char, string, double),
MAX es la cantidad máxima de datos que se almacenaran en el vector (Obligatoriamente debe ser EL
NOMBRE DE UNA CONSTANTE o en su defecto un VALOR).

Ejemplo: DECLARAR LOS VECTORES: NOMBRES Y CODIGOS

long CODIGOS [20];

char NOMBRES [20][80];

Observe que el vector NOMBRES se está declarando de tamaño 20 (máximo almacenará 20 nombres)
y va acompañado de un corchete y un tamaño de 80; esto significa que, a su vez, cada nombre tendrá
Máximo 80 caracteres.

Gráficamente podemos representar estos dos vectores como sigue:

CODIGOS NOMBRES
1 2000015 1 MATEO BARRIOS
2000
2
2000020 2 ANA LUISA GONZALEZ
3 2000032 3
LINA PAOLA OÑATE.
. .

. .

20 20
 3

ALGORITMO PARA INTRODUCIR DATOS A UN VECTOR:

Es necesario aclarar que el hecho de haber DIMENSIONADO un vector de un tamaño determinado NO

implica que de entrada deban introducirse esa cantidad de elementos al vector (El resto puede ser
AGREGADO mas adelante ó simplemente no ser utilizado ese espacio), por lo tanto, así hayamos
dimensionado nuestros dos vectores de tamaño 20 le pediremos al usuario de la aplicación que decida
cuantos datos realmente desea cargar y llamaremos NEL (Número de Elementos) a esta variable. Por
supuesto no se permitirá que esta variable EXCEDA a la Dimensión que hemos dado previamente a
nuestro vector. Utilizaremos entonces un ciclo repetitivo desde 1 hasta NEL y vamos pidiendo y leyendo
cada dato.

LLENAR_DATOS

ESCRIBA (“ ***** Captura de datos del Estudiante ***** ”)

ESCRIBA (“ Cuantos Alumnos ? “); Lea(NEL)
SI (NEL < 0) OR (NEL > 20 ) Ent
ESCRIBA (“ ERROR, RECTIFIQUE EL NUMERO DE ELEMENTOS A INTRODUCIR “)
SINO
PARA I
1 HASTA NEL Haga
ESCRIBA (“ Digite Código del Alumno “); Lea( CODIGO [I] )
ESCRIBA (“ Digite Nombre del alumno “); Lea( NOMBRE [I] )
FIN PARA
FIN SI

FIN LLENAR_DATOS

Podemos también utilizar otra estructura repetitiva y otro estilo de captura de información que NO
implique conocer de antemano cuantos elementos se introducirán al vector sino que vamos validando
uno a uno la cantidad de datos que se van introduciendo, con lo cual tendremos otra VERSION del
mismo algoritmo, como se ilustra a continuación.

LLENAR_DATOS(2.0)
NEL
0 ; Mas
’S’
MQ (Mas = ‘S’ ) and (NEL <= 20)
ESCRIBA (“ **** Captura de datos del Estudiante **** ” )
NEL
NEL + 1
ESCRIBA (“ Digite Código del Alumno “); Lea ( CODIGO [NEL] )
ESCRIBA (“ Digite Nombre del alumno “); Lea( NOMBRE [NEL] )
ESCRIBA (“ Desea seguir Introduciendo Información de Alumnos ? “ ); Lea(MAS)
FIN MQ
SI (NEL > 20) Ent
ESCRIBA (“ ERROR, Ya los vectores están llenos, no caben mas elementos …… “)
SINO
ESCRIBA (“ OK. Se capturaron los datos de los alumnos correctamente …. “ )
FIN SI

FIN LLENAR_DATOS2.0

Por supuesto, puedo utilizar la TERCERA estructura de control repetitiva de la Programación

Estructurada y obtener una versión 3.0 del mismo algoritmo, tal y como se ilustra a continuación

LLENAR_DATOS(3.0)
NEL
1 ;
REPITA (Mas = ‘S’ ) and (NEL <= 20)
ESCRIBA ( “ **** Captura de datos del Estudiante ***** ” )
ESCRIBA (“ Digite Código del Alumno “); Lea( CODIGO [NEL] )
ESCRIBA (“ Digite Nombre del alumno “); Lea( NOMBRE [NEL] )
NEL
NEL + 1

ESCRIBA (“ Desea seguir Introduciendo Información de Alumnos ? “); Lea(MAS)

HASTA ((Mas = ‘N’ ) OR (NEL >= 20) )
SI (NEL > 20) Ent
ESCRIBA (“ ERROR, Ya los vectores están llenos, no caben mas elementos “)
SINO
ESCRIBA(“ OK. Se capturaron los datos de los alumnos correctamente …. “)
FIN SI

FIN LLENAR_DATOS3.0
 4

Ahora bien, como hemos notado, por lo general las tareas sobre un vector requieren de un ciclo
repetitivo que vaya desde 1 hasta NEL para ir procesando los datos del vector. Así, por ejemplo, si nos
piden un INFORME de alumnos que incluya CODIGO y NOMBRE de estos, podemos recorrer los dos
vectores e ir escribiendo en pantalla los datos de cada posición de cada vector, así:

INFORME_DE_ALUMNOS

ESCRIBA(“****** DATOS DE LOS ESTUDIANTES * ***** ”)

PARA I
1 HASTA NEL Haga
ESCRIBA ( CODIGO [I] , NOMBRE [I] )
FIN PARA

FIN LLENAR_DATOS

ALGORITMO PARA AGREGAR DATOS A UN VECTOR:

Para AGREGAR un nuevo alumno a estos vectores se deben seguir normalmente estos pasos:

1. VERIFICAR SI HAY AUN ESPACIO EN EL VECTOR (QUE NEL NO SEA MAYOR QUE 20)
2. SI HAY ESPACIO ENTONCES LEER LOS DATOS DEL ALUMNO (CODIGO, NOMBRE, ETC)
Y ALMACENARLOS EN LA POSICIÓN NEL+1 DE CADA VECTOR Y LUEGO SUMAR 1 A NEL
PARA INDICAR QUE YA HAY UN ELEMENTO MAS EN LOS VECTORES
3. SI NO HAY ESPACIO ENTONCES MOSTRAR UN MENSAJE INDICANDO ESTO

Veamos la primera versión del algoritmo….

AGREGAR_DATOS
Mas
’S’
MQ (Mas = ‘S’ ) AND (NEL < 20)
ESCRIBA (“ **** Agrega datos del Estudiante **** ” )
SI NEL < 20 ENT
ESCRIBA (“ Digite Código del Alumno “); Lea ( CODIGO [NEL+1] )
ESCRIBA (“ Digite Nombre del alumno “); Lea( NOMBRE [NEL+1] )
NEL
NEL + 1
SINO
ESCRIBA (“ Los vectores están llenos, No se admiten mas alumnos …. “ );
FSI

ESCRIBA (“ Desea seguir Introduciendo Información de Alumnos ? “ ); Lea(MAS)

FIN MQ

FIN AGREGAR_DATOS

Veamos otra versión (2.0) de este mismo algoritmo.

AGREGAR_DATOS Ver 2.0

REPITA

ESCRIBA (“ **** Agrega datos del Estudiante **** ” )

SI NEL < 20 ENT
ESCRIBA (“ Digite Código del Alumno “); Lea ( CODIGO [NEL+1] )
ESCRIBA (“ Digite Nombre del alumno “); Lea( NOMBRE [NEL+1] )
NEL
NEL + 1
SINO
ESCRIBA (“ Los vectores están llenos, No se admiten mas alumnos …. “ );
FSI

ESCRIBA (“ Desea seguir Introduciendo Información de Alumnos ? “ ); Lea(MAS)

HASTA (MAS = ‘N’ AND NEL >= 20)

FIN AGREGAR_DATOS Ver 2.0

 5

ALGORITMO PARA CONSULTAR DATOS DE UN VECTOR:

Para CONSULTAR la información de un alumno de estos vectores se deben seguir normalmente estos
pasos:

1. PREGUNTAR AL USUARIO CUAL ES EL CODIGO DEL ALUMNO QUE DESEA CONSULTAR

2. BUSCAR ESTE CODIGO EN EL VECTOR CORRESPONDIENTE (Esto se hace comparando

El código digitado contra todos los elementos del vector de códigos y si encuentra coin-
cidencia con alguno entonces guarda en una variable POS la posición donde lo
encontró).

3. SI lo encontró entonces muestre toda la información del alumno

4. Si no lo encontró entonces Muestra un mensaje de error “ Ese alumno NO está matriculado”

CONSULTAR_DATOS

REPITA

ESCRIBA ( “ **** CONSULTA INFORMACION DE ESTUDIANTES **** ” )

ESCRIBA (“ CODIGO A CONSULTAR ?? ” ); LEA (CC)
Encontro
‘ N ’

PARA I
1 Hasta NEL haga

SI CC = CODIGOS [ I ] ENT

ESCRIBA ( “ Datos encontrados del Alumno ……..”)

ESCRIBA (“ Código del Alumno : “, CODIGO [ I ] )
ESCRIBA (“ Nombre del alumno : “, NOMBRE [ I ] )
Pos
I
Encontro
‘ S ’
FSI
FIN PARA

SI Encontro = ‘ N ’ Ent

ESCRIBA (“ NO está matriculado ese alumno …. “ );

FSI

ESCRIBA (“ Desea seguir Consultando Información de Alumnos ? “ ); Lea(MAS)

HASTA (MAS = ‘N’ )

FIN CONSULTAR_DATOS

Ahora, si NO deseamos recorrer completamente el vector sino que estamos interesados en que una vez
que lo encuentre lo muestre y termine la búsqueda (Por ejemplo, si estamos seguros de que el dato NO
se repite en el vector), entonces podemos escribir otra versión de este algoritmo que INTERRUMPA el
ciclo repetitivo en cuanto encuentre el elemento que se busca en el vector.

Este algoritmo se muestra en la siguiente página …..

 6

CONSULTAR_DATOS Ver 2.0

REPITA

ESCRIBA ( “ **** CONSULTA INFORMACION DE ESTUDIANTES **** ” )

ESCRIBA (“ CODIGO A CONSULTAR ?? ” ); LEA (CC)

Encontro
‘ N ’ ; I
1

MQ ( I <= NEL) AND ( Encontro = ‘ N ’ ) haga

SI CC = CODIGOS [ I ] ENT

ESCRIBA ( “ Datos encontrados del Alumno ……..” )

ESCRIBA (“ Código del Alumno : “, CODIGO [ I ] )
ESCRIBA (“ Nombre del alumno : “, NOMBRE [ I ] )
Pos
I
Encontro
‘ S ’

SINO
I
I +1
FSI

FIN MQ

SI Encontro = ‘ N ’ Ent

ESCRIBA (“ NO está matriculado ese alumno …. “ );

FSI

ESCRIBA (“ Desea seguir Consultando Información de Alumnos ? “ ); Lea(MAS)

HASTA (MAS = ‘N’ )

FIN CONSULTAR_DATOS Ver 2.0

ALGORITMO PARA BORRAR DATOS DE UN VECTOR:

Para BORRAR un alumno de estos vectores se deben seguir normalmente estos pasos:

3. PREGUNTAR AL USUARIO CUAL ES EL CODIGO DEL ALUMNO QUE DESEA BORRAR

4. BUSCAR ESTE CODIGO EN EL VECTOR CORRESPONDIENTE (Esto se hace comparando

El código digitado contra todos los elementos del vector de códigos y si encuentra coin-
cidencia con alguno entonces guarda en una variable POS la posición donde lo
encontró).

5. SI lo encontró entonces se ubica una posición debajo de aquella en la cual lo encontró

y a partir de allí comienza a copiar los elementos de cada vector encima del que le
antecede, hasta llegar a NEL y luego le RESTA 1 a NEL puesto que ahora habrá un dato
menos en cada vector.

4. Si no lo encontró entonces Muestra un mensaje de error “Ese alumno NO está matriculado”

Una versión de el algoritmo para “Borrar” elementos de un Vector se muestra en la siguiente

página …
 7

BORRAR DATOS (Ver 1.0)

Mas
‘S’
MQ (Mas = ‘ S ’ ) Haga

ESCRIBA ( “ **** BORRAR INFORMACION DE ESTUDIANTES **** ” )

ESCRIBA (“ CODIGO del alumno que desea Retirar de la lista ?? ” ); LEA ( CB )
Encontro
‘ N ’ ; I
1

MQ ( I <= NEL) AND ( Encontro = ‘ N ’ ) haga

SI CB = CODIGOS [ I ] Entonces

ESCRIBA ( “ Datos encontrados del Alumno ……..” )

ESCRIBA (“ Código del Alumno : “, CODIGO [ I ] )
ESCRIBA (“ Nombre del alumno : “, NOMBRE [ I ] )

Pos
I ; Encontro
‘ S ’
ESCRIBA ( “ Está seguro de Retirar este Alumno de la Clase ?? [ S/N ] ……..” ); LEA ( seguro)

SI Seguro = ‘ S ’ Entonces

SI POS = NEL ENT /* Se trata del que ocupa la última posición??? */

NEL
NEL – 1 /* Simplemente le resto 1 a NEL y Listo ……*/
SINO
PARA I
POS + 1 HASTA NEL HAGA

CODIGOS [ I -1 ]
CODIGOS [ I ]

FPARA
FSI

FSI
SINO
I
I +1
FSI

FIN MQ

SI Encontro = ‘ N ’ Ent

ESCRIBA (“ NO está matriculado ese alumno …. “ );

FSI

ESCRIBA (“ Desea seguir Borrando Información de Alumnos ? “ ); Lea(MAS)

FMQ

FIN BORRAR_DATOS (Versión 1.0)

A continuación, en la siguiente página le muestro OTRA versión de este algoritmo de borrado de

elementos de un vector con el fin de que usted lo estudie.

¿Qué diferencias encuentra respecto de la versión 1.0 de borrado?

¿Acepta usted el reto de codificar ambas versiones, ejecutarlas y comparar los resultados en
cuanto a eficiencia de ambos algoritmos?

Nota: Para comparar los programas resultantes de la codificación de ambos algoritmos debe
basarse en un mismo conjunto de datos, de lo contrario no sería correcto el análisis.
 8

BORRAR DATOS (Ver 2.0)

Mas
‘S’
MQ (Mas = ‘ S ’ ) Haga

ESCRIBA ( “ **** BORRAR INFORMACION DE ESTUDIANTES **** ” )

ESCRIBA (“ CODIGO del alumno que desea Retirar de la lista ?? ” ); LEA ( CB )
Encontro
‘ N ’ ; I
1

MQ ( I <= NEL) AND ( Encontro = ‘ N ’ ) haga

SI CB = CODIGOS [ I ] Entonces

ESCRIBA ( “ Datos encontrados del Alumno ……..” )

ESCRIBA (“ Código del Alumno : “, CODIGO [ I ] )
ESCRIBA (“ Nombre del alumno : “, NOMBRE [ I ] )

Pos
I ; Encontro
‘ S ’
SINO
I
I+1
FSI

FIN MQ

SI Encontro = ‘ N ’ Ent

ESCRIBA (“ NO está matriculado ese alumno …. “ );

SINO
ESCRIBA ( “ Está seguro de Retirar este Alumno de la Clase ?? [ S/N ] ……..” ); LEA ( seguro)

SI Seguro = ‘ S ’ Entonces

SI POS = NEL ENT /* Se trata del que ocupa la última posición??? */

NEL
NEL – 1 /* Simplemente le resto 1 a NEL y Listo ……*/
SINO
PARA I
POS + 1 HASTA NEL HAGA

CODIGOS [ I -1 ]
CODIGOS [ I ]

FPARA
FSI

FSI

FSI

ESCRIBA (“ Desea seguir Borrando Información de Alumnos ? “ ); Lea(MAS)

FMQ

FIN BORRAR_DATOS (Versión 2.0)

ALGORITMO PARA MODIFICAR DATOS DE UN VECTOR:

Para Actualizar (MODIFICAR) los datos de un alumno de estos vectores se deben seguir normalmente
estos pasos:

1. PREGUNTAR AL USUARIO CUAL ES EL CODIGO DEL ALUMNO CUYA INFORMACION DESEA

MODIFICAR.

2. BUSCAR ESTE CODIGO EN EL VECTOR CORRESPONDIENTE (Esto se hace comparando El

código digitado contra todos los elementos del vector de códigos y si encuentra coincidencia
con alguno entonces guarda en una variable POS la posición donde lo encontró.

3. SI lo encontró entonces escribe en pantalla la información Actual del alumno CODIGO y

NOMBRE y pide que se introduzca el NUEVO NOMBRE CORREGIDO (Estamos
suponiendo que lo que se desea modificar es el NOMBRE DEL ALUMNO)

4. Si no lo encontró entonces Muestra un mensaje de error “ Ese alumno NO está matriculado”

POR SUPUESTO QUE HAY MUCHAS MAS TAREAS QUE PODEMOS DESARROLLAR SOBRE
ESTE PAR DE VECTORES, pero vamos a dejarlo hasta aquí.
 9
Ahora REPASEMOS como es que se puede integrar e un solo programa varias
subrutinas y enlazarlas mediante un programa principal.

Si quisiéramos elaborar UN SOLO PROGRAMA para esta aplicación pensaríamos en una

solución como la siguiente:

SUBRUTINA LLENAR_DATOS

FIN LLENAR_DATOS

SUBRUTINA INFORME

FIN INFORME

SUBRUTINA CONSULTA_ALUMNO

FIN CONSULTA

SUBRUTINA AGREGAR_ALUMNO

FIN AGREGAR_ALUMNO

SUBRUTINA ACTUALIZAR_DATOS

FIN ACTUALIZAR

SUBRUTINA BORRAR_DATOS

FIN BORRAR_DATOS

Ahora hacemos el Algoritmo en Pseudocódigo correspondiente al PROGRAMA PRINCIPAL

que controlará a todas estas Subrutinas:

PROGRAMA PRINCIPAL
REPITA
ESCRIBA(“ #### GESTION INFORMACION DE ALUMNOS #### “)
ESCRIBA(“ MENU PRINCIPAL “)
ESCRIBA(“ 1.- CAPTURA DATOS DE ALUMNOS “)
ESCRIBA(“ 2.- INFORME DE ALUMNOS “)
ESCRIBA(“ 3.- AGREGAR DATOS DE ALUMNOS “)
ESCRIBA(“ 4.- CONSULTAR INFO. DE ALUMNOS “)
ESCRIBA(“ 5.- ACTUALIZAR DATOS DE ALUMNOS “)
ESCRIBA(“ 6.- BORRAR DATOS DE ALUMNOS “)
ESCRIBA(“ 7.- TERMINAR “)

ESCRIBA(“ DIGITE OPCIÓN >>>>>> “); LEA(OP)

DD OP Haga
1 : LLENAR_DATOS;
2 : INFORME;
3 : AGREGAR_ALUMNO;
4 : CONSULTAR_ALUMNO;
5 : ACTUALIZAR_DATOS;
6: BORRAR_DATOS;
FIN DD
HASTA (OP = 7)
FIN PROGRAMA_PRINCIPAL
 10

Ahora bien, lo anterior es la parte ALGORITMICA de la solución. En cuanto a la forma de

“INTEGRAR” varias subrutinas en un solo programa PASCAL lo explico a continuación:

Habíamos dicho que un programa pascal tenía la siguiente forma:

PROGRAM xxxxx;
USES
Wincrt;
CONST
VAR
BEGIN (* Inicio del Programa Principal *)

Aquí van las sentencias del programa …….;

END .

A partir de ahora, aplicando el enfoque de la PROGRAMACION MODULAR, nuestros programas

PASCAL tendrán OTRA estructura ya que tenemos varias subrutinas. En Lenguaje PASCAL
existen dos (2) maneras de codificar las subrutinas, a saber:

⇒ PROCEDIMIENTOS : Son módulos del programa que pueden tener su propio conjunto
de variables (e denominan variables LOCALES) y que tienen la particularidad de NO devolver
ningún resultado a quien los invoca. Para escribir esta clase de subrutinas utilizamos la
siguiente sintaxis:

PROCEDURE Nombre_de_procedimiento;
Var
Xxx;
Xxx;
Begin
Sentencia;
Sentencia;
.
.
End; (* fin del procedimiento *)

⇒ FUNCIONES : Son módulos del programa que pueden tener su propio conjunto de
variables (e denominan variables LOCALES) y que tienen la particularidad de devolver
resultados a quien los invoca. Para escribir esta clase de subrutinas utilizamos la siguiente
sintaxis:

FUNCTION nombre_de_función; tipo de dato que devuelve;

Var
Xxx;
Xxx:
Begin
Sentencias;
Sentencias;
End;

Pues bien, según lo anterior, utilizando PROCEDURES, la codificación del programa fuente en
PASCAL para implementar la solución algorítmica de la página 9 de este documento sería la
siguiente:
 11
PROGRAM xxxxx;
USES
Wincrt;
CONST
VAR
CODIGOS : ARRAY [1..20] OF Longint;
NOMBRES : ARRAY [1..20] OF String[60];
NEL : INTEGER;

(* … y todas la demás variables que usted requiera declarar GLOBALMENTE *)

(* A continuación escribimos la codificación en pascal de TODOS los Procedures …. *)

PROCEDURE LLENAR_DATOS;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del procedure LLENAR_DATOS *)

PROCEDURE INFORME;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del INFORME *)

PROCEDURE AGREGAR_ALUMNO;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del procedure AGREGAR_ALUMNO *)

PROCEDURE CONSULTAR_ALUMNO;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del procedure CONSULTAR_ALUMNO *)

PROCEDURE ACTUALIZAR_DATOS;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del procedure ACTUALIZAR_DATOS *)

PROCEDURE BORRAR_DATOS;
BEGIN
Sentencias;
Sentencias;
END; (* Fin del procedure BORRAR_DATOS *)

(* A continuación escribimos la codificación en pascal del Programa Principal …. *)

BEGIN (* Inicio del Programa Principal *)

Aquí van las sentencias del programa …….;

.
END (* FIN DEL PROGRAMA PRINCIPAL *)

Entonces, si en un programa PASCAL, el PROGRAMA PRINCIPAL debe ir en el sitio que se

acaba de indicar, y si ALGORITMICAMENTE lo que este programa principal contiene es un MENÚ
DE OPCIONES tal y como se indicó en la página No. 9, entonces veamos como se codifica en
PASCAL este programa principal según el algoritmo señalado.
 12

La sentencia PASCAL para codificar la Estructura DD (Dependiendo de ..) que se detalló en el

documento: “Fundamentos de Programación”, es la instrucción CASE.

BEGIN (*Inicio del Programa Principal *)

REPEAT
CLRSRC;
WRITELN(‘ #### GESTION INFORMACION DE ALUMNOS #### ‘)
WRITELN (‘ MENU PRINCIPAL ‘)
WRITELN (‘ 1.- CAPTURA DATOS DE ALUMNOS ‘)
WRITELN (‘ 2.- INFORME DE ALUMNOS ‘)
WRITELN (‘ 3.- AGREGAR DATOS DE ALUMNOS ‘)
WRITELN (‘ 4.- CONSULTAR INFO. DE ALUMNOS ‘)
WRITELN (‘ 5.- ACTUALIZAR DATOS DE ALUMNOS ‘)
WRITELN (‘ 6.- BORRAR DATOS DE ALUMNOS ‘)
WRITELN (‘ 7.- TERMINAR ‘)
WRITELN (‘ DIGITE OPCIÓN >>>>>> ‘); READLN (OP)

CASE OP OF
1 : LLENAR_DATOS;
2 : INFORME;
3 : AGREGAR_ALUMNO;
4 : CONSULTAR_ALUMNO;
5 : ACTUALIZAR_DATOS;
6 : BORRAR_DATOS
7 : BEGIN
CLRSCR; WRITELN (‘ fin del programa … Pulse ENTER ‘); READKEY;
END;
ELSE
BEGIN
CLRSCR; WRITELN (‘ ERROR en la opción, revise … Pulse ENTER ‘); READKEY;
END;
END; (* Fin del CASE, observe que el Case NO tiene BEGIN …. *)

UNTIL (OP = 7);

END .