[ estndares de desarrollo ]

ESTNDARES DE
PSEUDOCDIGO ORIENTADO A
OBJETOS Y EVENTOS

oLoop
Pag. 1

oLoop 1.2
Lenguaje de Pseudocdigo Orientado a Objetos y a Eventos
Elaborado por
ngel Augusto Velsquez Nez
rea de Desarrollo de Software
Carrera de Ingeniera Informtica y de Sistemas
Universidad Nacional Mayor de San Marcos

Pag. 2

Contenido
Introduccin.................................................................................................................................. 1
Objetivos.................................................................................................................................. 1
Definicin del Lenguaje de Pseudocdigo....................................................................................2
Pseudocdigo orientado a objetos?......................................................................................2
Expresiones.................................................................................................................................. 3
Sintaxis de las expresiones..................................................................................................... 3
Expresiones simples................................................................................................................ 4
Operadores................................................................................................................................... 5
Sentencias.................................................................................................................................... 6
Sentencias simples.................................................................................................................. 6
Sentencias de asignacin de Valores......................................................................................6
Sentencias de mensaje........................................................................................................... 6
Sentencias de entrada/salida................................................................................................... 7
Sentencias compuestas........................................................................................................... 7
Sentencias de decisin o condicionales..................................................................................7
Iteraciones............................................................................................................................... 8
Clases y Objetos......................................................................................................................... 10
Declarar Clases..................................................................................................................... 10
Declaracin de Instancias de Clases (Objetos).....................................................................11
Declaracin de definicin de Mtodos...................................................................................11
Declaracin de propiedades.................................................................................................. 14
Bibliotecas de clases............................................................................................................. 15
Polimorfismo.......................................................................................................................... 15
Comentarios............................................................................................................................... 17
Jerarqua de Clases predefinidas............................................................................................... 18
La clases Componentes............................................................................................................. 19
Atributos comunes (CComponente)......................................................................................19
Visualizar y editar texto.......................................................................................................... 19
Permitir que el usuario haga elecciones simples...................................................................20
Controles especializados....................................................................................................... 23
Manejo de Listas................................................................................................................... 24
Fichas (CFicha)..................................................................................................................... 25
La clase CFormulario............................................................................................................. 26
La clase CAplicacin............................................................................................................. 26
Tratamiento de Eventos.............................................................................................................. 29
Implantar eventos estndar................................................................................................... 29
Excepciones............................................................................................................................... 31
Proteccin de Sentencias...................................................................................................... 31
Tratamiento de Excepciones................................................................................................. 31
Generacin manual de Excepciones.....................................................................................33
Excepciones predefinidas...................................................................................................... 33
Objetos Especiales..................................................................................................................... 35
Arreglos................................................................................................................................. 35
Apuntadores.......................................................................................................................... 36
Estructuras............................................................................................................................ 37
Enumeraciones...................................................................................................................... 37
Interfaces............................................................................................................................... 38
Archivos................................................................................................................................. 39
Ejemplos de uso de oLoop......................................................................................................... 40
Declaracin de Clases y Mtodos..........................................................................................40
Implantacin de Mtodos............................................................................................................ 41
Herencia y Extensin de Clases................................................................................................. 42
Bibliografa.................................................................................................................................. 46
Sugerencias para la escritura de Pseudocdigo.........................................................................47
Indentacin ........................................................................................................................... 47
Idioma de Trabajo.................................................................................................................. 47
Notacin de Identificadores................................................................................................... 47

Pag. 3

ndice de Tablas
Tabla .1. Precedencia de operadores.......................................................................................... 3
Tabla .2. Atributos comunes para los componentes en general.................................................19
Tabla .3. Atributos de CEtiqueta................................................................................................. 19
Tabla .4. Atributos de CEdicin..................................................................................................20
Tabla .5. Atributos de CCasilla................................................................................................... 21
Tabla .6. Atributos de CBotnRadio............................................................................................22
Tabla .7. Atributos de CBotnAccin..........................................................................................22
Tabla .8. Atributos de CBarraDesp.............................................................................................23
Tabla .9. Atributos de Cficha....................................................................................................... 25
Tabla .10. Eventos estndar comunes a las Clases componentes.............................................29
Tabla .11. Eventos de las Clases componentes estndar..........................................................30
Tabla .12. Eventos clave para las Clases componentes.............................................................30
Tabla .13. Clases derivadas de CExcepcin..............................................................................34
Tabla .14. Ejemplo de uso de Prefijos........................................................................................48

Pag. 4

ndice de Ilustraciones
Ilustracin .1. Sintaxis de factor................................................................................................... 3
Ilustracin .2. Sintaxis de valor constante sin signo.....................................................................3
Ilustracin .3. Sintaxis de trmino................................................................................................. 4
Ilustracin .4. Sintaxis de expresin simple..................................................................................4
Ilustracin .5. Sintaxis de expresin.............................................................................................. 4
Ilustracin .6. Sintaxis de factor de direccin...............................................................................5
Ilustracin .7. Sintaxis de sentencia.............................................................................................. 6
Ilustracin .8. Sintaxis de sentencia simple..................................................................................6
Ilustracin .9. Sintaxis de sentencia de asignacin......................................................................6
Ilustracin .10. Sintaxis de sentencia compuesta........................................................................7
Ilustracin .11. Sintaxis de sentencia condicional. .......................................................................7
Ilustracin .12. Sintaxis de sentencia Si.......................................................................................7
Ilustracin .13. Sintaxis de sentencia Caso.................................................................................8
Ilustracin .14. Sintaxis de sentencia repetitiva o iteracin...........................................................8
Ilustracin .15. Sintaxis de sentencia Mientras.............................................................................8
Ilustracin .16. Sintaxis de sentencia repetir................................................................................8
Ilustracin .17. Sintaxis de sentencia Para..................................................................................9
Ilustracin .18. Sintaxis de declaracin de Clase.......................................................................10
Ilustracin .19. Sintaxis de declaracin de Objeto......................................................................11
Ilustracin .20. Sintaxis de declaracin de definicin de Mtodo................................................11
Ilustracin .21. Sintaxis de Lista formal de Parmetros..............................................................12
Ilustracin .22. Sintaxis de Envo de Mensaje.............................................................................14
Ilustracin .23. Ejemplo de Etiqueta............................................................................................ 19
Ilustracin .24. Ejemplo de Caja de edicin................................................................................20
Ilustracin .25. Ejemplo de Casilla de verificacin......................................................................21
Ilustracin .26. Ejemplos de Botn de radio................................................................................21
Ilustracin .27. Ejemplos de Botn de accin.............................................................................22
Ilustracin .28. Ejemplo de Barra de desplazamiento.................................................................23
Ilustracin .29. Ejemplo de Barra de dial....................................................................................24
Ilustracin .30. Ejemplo de Control Arriba Abajo.........................................................................24
Ilustracin .31. Ejemplo de Lista desplegable.............................................................................24
Ilustracin .32. Ejemplo de Ficha................................................................................................ 25
Ilustracin .33. Ejemplo de un Formulario en blanco..................................................................26

Pag. 5

Introduccin
Objetivos
Este documento tiene por finalidad que establecer los estndares de programacin
y nomenclatura de objetos de programacin en pseudocdigo a utilizar en las
sesiones de clase y los proyectos de desarrollo de software.

Pag. 1

Definicin del Lenguaje de

Pseudocdigo
Pseudocdigo orientado a objetos?
El pseudocdigo se presta para un buen diseo descendente. En el mundo del
desarrollo orientado a objetos, diseo descendente significa describir cmo se
comportan los objetos y luego utilizar la descripcin para identificarlos ms
detalladamente o identificar objetos subordinados. En cada nivel de abstraccin, los
objetos se van detallando ms hasta que el diseo alcanza los objetos existentes (ya
sea en bibliotecas o predefinidos en el lenguaje mismo), o bien el comportamiento
descrito no implica la existencia de nuevos objetos.
El lenguaje de pseudocdigo que vamos a especificar contiene las herramientas que
permiten especificar el flujo del control de un algoritmo, la creacin y modificacin de la
informacin y la relacin entre los diferentes objetos que forman el universo de la
solucin. Para dar un enfoque ms claro optamos por subrayar las palabras reservadas
del lenguaje.

Pag. 2

Expresiones
Las expresiones estn compuestas por operadores y operandos. La mayora de
operadores son binarios, es decir utilizan dos operandos. Los dems son unarios y
necesitan slo un operando. Los operadores binarios utilizan la forma algebraica que
conocemos (por ejemplo, A + B). Los operadores unarios siempre preceden a sus
operandos (por ejemplo, -B).
En expresiones ms complejas, las reglas de precedencia de operadores aclaran el
orden en que se realizan las operaciones.
Operadores
@, No
*, /, div, mod, Y
+, -, O
=, <>, <, >, <=, >=

Precedencia
Categoras
primera (ms alta) operadores unarios
segunda
operadores de multiplicacin/divisin
tercera
operadores de suma/resta
cuarta (ltima)
operadores relacionales
Tabla .1. Precedencia de operadores.

Para la precedencia hay tres reglas bsicas:

Un operando entre dos operadores de precedencia diferente acta primero
con el operando de mayor precedencia.
Un operando entre dos operadores iguales acta primero con el de la
izquierda.
Las expresiones entre parntesis se evalan primero para ser tratadas como
un slo operando.
Las operaciones de igual precedencia se efectan normalmente de izquierda a derecha.
A nivel de pseudocdigo esto es bastante simple, pero en un lenguaje de programacin,
el compilador podra reordenar los operandos para optimizar el cdigo.

Sintaxis de las expresiones

Las reglas de precedencia se basan en la sintaxis de las expresiones, que se
componen de factores, trminos y expresiones simples.
La sintaxis de un factor es:
Factor --> Identificador | Constante | (Expresin) | no Factor |
LlamadaMtodo | FactorDireccin
Identificador --> ReferenciaArreglo |ReferenciaApuntador |
ReferenciaVariable
ReferenciaVariable --> Letra { Letra | Dgito | _ }
Constante --> Dgito { Dgito } | CadenaCaracteres

Ilustracin .1. Sintaxis de factor.

Una llamada a mtodo activa un mtodo y denota el valor que ste retorna. Esto lo
veremos en la seccin de llamada a mtodos.
Un valor constante sin signo tiene la siguiente sintaxis:
ConstanteSinSigno --> Constante | CadenaCaracteres
Ilustracin .2. Sintaxis de valor constante sin signo.

Un factor de direccin calcula la direccin de una variable o mtodo. Lo ampliaremos en

la seccin de apuntadores.
Aqu presentamos algunos ejemplos de factores:
Pag. 3

X
@X
15
(X + T + Z)
Seno(X/2)
No Fin

{referencia a una variable}

{apuntador a una variable}
{constante}
{subexpresin}
{llamada a un mtodo}
{negacin de un valor lgico o booleano}

Los trminos aplican los operadores de multiplicacin y divisin a los factores:

Trmino --> Factor [ OperadorFactor Factor]
OperadorFactor --> * | / | div | mod | y

Ilustracin .3. Sintaxis de trmino.

Aqu algunos ejemplos de trminos:
X * Z
Z / (1 - Z)
(X <= A) Y (X < Z)

Expresiones simples
Las expresiones simples aplican los operadores de suma/resta a los trminos:
ExpresinSimple --> [+ | -] Trmino [ OperadorTrmino Trmino]
OperadorTrmino --> + | - | O

Ilustracin .4. Sintaxis de expresin simple.

Como ejemplos de expresiones simples podemos mencionar:
X + Z
-X
Valor1 + Valor2
I * J + 1

Una expresin aplica los operadores relacionales a las expresiones simples:

Expresin --> ExpresinSimple [OperadorRelacional ExpresinSimple]
OperadorRelacional --> = | <> | < | > | <= | >=

Ilustracin .5. Sintaxis de expresin

Aqu algunos ejemplos de expresiones:
X = 1.5
Fin <> Error
(I < J) = (J < K)

Pag. 4

Operadores
A nivel de pseudocdigo, podemos dividir a los operadores en operadores numricos,
lgicos, de texto, apuntadores y relacionales.
Los operadores numricos son muy conocidos por nosotros (+, -, *, /, div, mod); de
stos, el operador + tambin se usa para concatenar textos (cadenas). Los operadores
numricos + y - tambin pueden ser operadores unarios. Los operadores + y - tambin
se aplican a variables o constantes que contienen valores de direcciones, obteniendo
como resultado otro valor de direccin.
El valor de I div J es el cociente de I / J redondeado. Ocurre un error en ambos tipos de
divisin si J es cero.
El operador mod retorna el resto de la divisin de sus operandos, es decir:
I mod J = I - (I div J) * J

El signo del resultado es el mismo que el de I. Ocurre un error si J es cero.

Los operadores No, Y , y O son operadores lgicos/booleanos. Cabe mencionar que los
lenguajes de programacin que soportan la manipulacin de operandos a nivel de bits,
consideran a estos operadores como lgicos adems de sus aplicaciones booleanas.
El operador @ se utiliza en un factor de direccin para calcular la direccin de una
variable. Este operador retorna la direccin de su operando, es decir construye un
apuntador hacia el operando (vea ms adelante apuntadores).
FactorDireccin --> @Identificador

Ilustracin .6. Sintaxis de factor de direccin.

Pag. 5

Sentencias
Las sentencias describen las acciones que puede ejecutar el algoritmo. Hay dos tipos
principales de sentencias: las sentencias simples y las sentencias compuestas.
Sentencia --> SentenciaSimple | SentenciaCompuesta

Ilustracin .7. Sintaxis de sentencia.

Sentencias simples
Una sentencia simple es aquella que no puede contener otras sentencias. Tenemos los
siguientes tipos: sentencias de entrada/salida, sentencias de asignacin de valores y
sentencias de mensaje.
SentenciaSimple --> SentenciaAsignacin | SentenciaEntradaSalida |
SentenciaRetorno | Mensaje | Retorno

Ilustracin .8. Sintaxis de sentencia simple.

Sentencias de asignacin de Valores

La sentencia de asignacin reemplaza el valor actual asociado a un identificador con un
nuevo valor especificado por una expresin o especifica una expresin cuyo valor lo
retorna un mtodo.
Identificador --> Expresin

Ilustracin .9. Sintaxis de sentencia de asignacin.

Algunos ejemplos de sentencias de asignacin:
X Z + U
Fin (I > J) y (I <= 100)
I Seno(X) * M

Sentencias de mensaje
Una sentencia de mensaje activa un mtodo especificado por un identificador de
mtodo, si la declaracin del mtodo contiene una lista de parmetros formales,
entonces la sentencia de mensaje debe tener una lista concordante de parmetros (en
la seccin de declaracin, a los parmetros se les conoce como parmetros formales,
al momento del paso de mensajes se les conoce como parmetros reales). Trataremos
este tipo de sentencias en la seccin de Mensajes.

Pag. 6

Sentencias de entrada/salida
Todo lenguaje de pseudocdigo debe permitir mecanismos que comuniquen nuestra
solucin con el usuario. La mayora de aplicaciones necesitan una interaccin con el
usuario de la misma. Nuestro lenguaje cuenta con dos primitvas bsicas para dicho fin.
La primitiva Leer permite recibir un valor del exterior y almacenarlo en la variable con el
nombre que se coloca en la seccin de interfaz. La primitiva Escribir nos proporciona un
mecanismo para emitir expresiones y resultados para que puedan ser apreciados por
nuestro usuario. La manera como se escriben es la siguiente:
leer ( Identificador )
escribir ( Identificador | Expresin )

Como veremos ms adelante, stos son mtodos de dominio pblico, por tanto entran
en la categora de mtodos de biblioteca.

Sentencias compuestas
Las sentencias compuestas son construcciones compuestas por otras sentencias que
se ejecutarn en secuencia, condicionalmente (sentencias condicionales), o
repetidamente (sentencias iterativas).
SentenciaCompuesta --> SentenciaCondicional |
SentenciaRepetitiva | Excepcin

Ilustracin .10. Sintaxis de sentencia compuesta.

Sentencias de decisin o condicionales

Las sentencias de decisin o condicionales seleccionan la ejecucin de una secuencia
de acciones.
SentenciaCondicional --> SentenciaSi | SentenciaCaso

Ilustracin .11. Sintaxis de sentencia condicional.

Decisin con hasta dos Alternativas (Sentencia Si)

La sintaxis de una sentencia de decisin con hasta dos alternativas es:
si ExpresinBooleana
entonces
Secuencia de n acciones
[ sino
Secuencia de m acciones ]
fsi

Ilustracin .12. Sintaxis de sentencia Si.

La expresin debe tomar un valor lgico de verdadero o falso. Si la expresin toma el
valor de verdadero la secuencia a continuacin de la clusula Entonces se ejecuta.
Si la expresin produce un valor de falso y est presente la parte de Sino, se ejecuta la
secuencia de acciones a continuacin de Sino; si la parte Sino no se encuentra
presente, no se ejecuta nada.

Pag. 7

Decisin Mltiple (Sentencia Caso)

La sentencia Caso est conformada por una expresin (el selector) y una relacin de
sentencias, cada una precedida por una constante por la palabra Otro. Las constantes
en Caso deben ser nicas.
caso Expresin vale
Alternativa1:
Secuencia de n acciones
Alternativa2 :
Secuencia de m acciones
...
[ otro:
Secuencia de x acciones ]
fcaso
Valor { , Valor } | Valor .. Valor

Ilustracin .13. Sintaxis de sentencia Caso.

La sentencia Caso ejecuta la secuencia de acciones precedida por la constante de valor
igual al del selector. Si no existe tal constante y est presente la parte Otro, la
secuencia de acciones que sigue a Otro se ejecuta. Si no hay parte Otro, no se ejecuta
nada.

Iteraciones
SentenciaRepetitivas --> SentenciaRepetir |
SentenciaMientras | SentenciaPara

Ilustracin .14. Sintaxis de sentencia repetitiva o iteracin.

Iteracin condicional de cero o ms ciclos

Una sentencia Mientras contiene una expresin que controla la ejecucin de una
secuencia de acciones.
Mientras ExpresinBooleana
hacer
Secuencia de n acciones
fmientras

Ilustracin .15. Sintaxis de sentencia Mientras.

La expresin que controla la repeticin debe tomar un valor de verdadero o falso. Esta
se evala antes que se ejecute la secuencia de acciones contenida. La secuencia de
acciones se ejecuta en forma repetida en tanto la expresin sea verdadero. Si la
expresin da falso al inicio, ya no se ejecuta la secuencia de acciones.

Iteracin condicional de uno o ms ciclos.

La sentencia Repetir contiene una expresin que controla la ejecucin repetida de una
secuencia de acciones dentro de esa sentencia Repetir.
Repetir
Secuencia de n acciones
hasta ExpresinBooleana
frepetir

Ilustracin .16. Sintaxis de sentencia repetir.

La expresin debe producir un resultado de verdadero falso. Las secuencia de
acciones entre las palabras Repetir y Hasta se ejecutan en secuencia hasta que, al final
de la secuencia , la expresin toma un valor de verdadero. La secuencia se ejecuta por

Pag. 8

lo menos una vez porque la expresin se evala despus de la ejecucin de cada

iteracin.

Iteracin con nmero definido de ciclos.

La sentencia Para hace que se ejecute una secuencia de acciones mientras que se
asigna una progresin de valores a un identificador de control.
Para VariableControl desde ValorInicial a ValorFinal
[inc {+ | -} ValorIncremento]
hacer
Secuencia de n acciones
fpara

Ilustracin .17. Sintaxis de sentencia Para.

La secuencia de acciones contenida en la sentencia Para se ejecuta una vez para cada
valor entre Val_Inic y Val_Fin en incrementos Valor_incremento. El identificador de
control siempre comienza en el valor Valor_Inic. Cuando la sentencia Para usa Desde,
el valor del identificador se incrementa o decrementa (segn el signo especificado) en
Valor_incremento si est presente o en su defecto se incrementa en uno, esto por cada
repeticin. Si el incremento es positivo y Val_Inic es mayor que Val_Fin entonces no se
ejecuta la secuencia de acciones. Si el incremento es negativo y Val_Inic es menor que
Val_Fin, la secuencia de acciones no se ejecuta.

Pag. 9

Clases y Objetos.
Una clase es, al igual que los nmeros, el texto y los booleanos, un tipo especial de
datos. En su caso consiste de un nmero fijo de componentes. Una clase puede estar
compuesta por atributos y mtodos.
Una instancia de una clase es conocida comnmente como objeto. Los objetos se
crean utilizando los constructores y se destruyen utilizando los destructores. Cada
objeto tiene su copia de los atributos declarados en la clase, pero todos comparten los
mismos mtodos.

Declarar Clases.
Las clases se declaran de la siguiente manera:
Clase IdentificadorClase
[viene-de IdentificadorClase { , IdentificadorClase }]
Atributos
IdentificadorAtributo { IdentificadorAtributo }
Mtodos
secuencia de m declaraciones de mtodos
fclase
IdentificadorMtodo [ ( ListaFormalParmetros ) ] [ --> ]
[ abstracto | sobreescribir |
sobrecargar | esttico | sincronizado ]
Constructor [ ( ListaFormalParmetros ) ]
Destructor
ListaFormalParmetros
}

--> [ @ ] Identificador {, [ @ ]Identificador

Ilustracin .18. Sintaxis de declaracin de Clase.

La declaracin de un atributo en una clase define un elemento de dato que existe en
cada instancia u objeto de la clase.
Un mtodo es una rutina que realiza una operacin sobre un objeto. Parte de la
llamada a un mtodo (mensaje) especifica el objeto sobre el que debe operar el
mtodo.
La declaracin de un mtodo dentro de una clase implica la implantacin posterior del
mtodo mediante una declaracin de definicin.
Dentro de la implantacin de un mtodo, el identificador Este representa un parmetro
implcito que referencia al objeto por el cual fue invocado el mtodo.
Los constructores y destructores son mtodos especiales que controlan la construccin
y destruccin de los objetos.
Un constructor define las acciones asociadas con la creacin de objetos. Cuando se
invoca ste retorna una referencia a una instancia inicializada de una clase.
Un destructor define las acciones asociadas con la destruccin de un objeto. Cuando se
invoca, el destructor libera los recursos asignados al objeto.
Una clase puede heredar componentes de otra clase. Si C2 hereda de C1, entonces C2
es un descendiente de C1 y C1 es un ancestro de C2. La herencia es transitiva; es
decir, si C3 hereda de C2 y C2 hereda de C1, entonces C3 tambin hereda de C1. El
dominio de una clase est conformado por ella y todos sus descendientes.
Pag. 10

Una clase descendiente contiene en forma implcita todos los componentes definidos
por sus clases ancestro. Una clase descendiente puede agregar nuevos componentes
a los ya heredados. Sin embargo, no puede eliminar la definicin de un componente
declarado en una clase ancestro.

Seleccionar atributos
La manera como podemos accesar a los atributos de una clase es similar a lo
anteriormente visto con las variables, excepto que necesitamos especificar a que clase
pertenece este atributo.
Identificador_de_Clase.Identificador_Atributo

Esta herramienta del lenguaje de pseudocdigo nos es til para accesar a los atributos
de una clase dentro de la definicin de un mtodo amigo de sta. Llamamos mtodo
amigo al mtodo que recibe como parte de su interfaz un identificador de otra clase del
cual se puede accesar directamente a los valores de los atributos de la clase. El
concepto de amigo se entiende como un grado de confianza entre clases, pues una
clase confa su intimidad (se supone que los atributos deben encapsularse para el
exterior) a otra esperando que la receptora no de un uso indebido a los valores de sus
atributos.
Dentro de los mtodos de una clase, el acceso a sus atributos propios y heredados no
necesita la especificacin del identificador de clase, pues la pertenencia est
sobreentendida.

Declaracin de Instancias de Clases (Objetos)

Las instancias de una clase se conocen como los objetos de la clase. Por medio de las
clases definimos en nuestro pseudocdigo la estructura y el comportamiento de los
objetos que pertenezcan a esa clase, es decir los ejemplares de la clase. Para poder
definir objetos en forma clara necesitamos establecer un identificador para el objeto y
especificar de qu clase es ejemplar.
Objeto IdentificadorObjeto ejemplar_de IdentificadorClase

Ilustracin .19. Sintaxis de declaracin de Objeto.

Hay que tomar en cuenta que con esta herramienta del lenguaje de pseudocdigo
estamos declarando ante el entorno que el uso de Ident_objeto denota el uso de un
objeto de la clase Ident_Clase, pero an no hemos asignado recursos ni inicializado los
valores para los atributos propios de su clase. Para esto contamos con los
constructores, de los cuales continuaremos hablando ms adelante.

Declaracin de definicin de Mtodos

Esta parte especifica cmo se implanta el propsito para el cual fue creado el mtodo.
Su estructura es similar a una rutina. Aqu utilizamos la palabra Mtodo seguida del
identificador y la interfaz (si existiera). El punto (.) nos indica una seleccin de la Clase
como entidad global y clarifica la pertenencia del mtodo a dicha Clase.
Mtodo IdentificadorClase.IdentificadorMtodo
[ ( ListaFormalParmetros ) ] [ --> ]
secuencia de n acciones
fmtodo

Ilustracin .20. Sintaxis de declaracin de definicin de Mtodo.

Pag. 11

Para los constructores y destructores, la declaracin es similar a la de los mtodos,

excepto que la palabra Constructor o Destructor se utiliza como identificador del
mtodo.
Dentro de un bloque de mtodo, la palabra reservada Heredado se puede utilizar para
acceder a identificadores de mtodos sobreescritos o extendidos. Por ejemplo, en la
implantacin del mtodo CEtiquetaConMarco.Dibujar, podemos utilizar heredado para
invocar la implantacin heredada del mtodo Dibujar. Cuando un identificador est
precedido por heredado, la bsqueda se inicia con el ancestro inmediato de la clase
que contiene el mtodo.
Veamos:
Clase CEtiquetaConMarco viene-de CEtiqueta
Mtodos
Dibujar
fclase
Mtodo CEtiquetaConMarco.Dibujar
heredado Dibujar
Color <-- clTextoVentana
Estilo <-- stSlido
fmtodo

Parmetros (Interfaz)
La declaracin de un mtodo especifica una lista formal de parmetros o interfaz. Cada
parmetro que se declara en una lista formal de parmetros es local al mtodo en que
se declara y se le puede hacer referencia utilizando su identificador en el bloque
asociado con el mtodo.
ListaFormalParmetros
[ @ ]Identificador }

--> [ @ ] Identificador {,

Ilustracin .21. Sintaxis de Lista formal de Parmetros.

A nivel de pseudocdigo, podemos distinguir dos tipos de parmetros, por valor y por
referencia. Los parmetros por valor slo requieren el identificador del parmetro,
mientras que los parmetros por referencia necesitan ser precedidos del operador @.
Un parmetro formal por valor acta como una variable local a la rutina, slo que
obtiene su valor inicial de su correspondiente parmetro real al momento de invocarse
al mtodo. Los cambios que se realicen al parmetro formal por valor no afectan el
valor del parmetro real.
El correspondiente parmetro real de un parmetro formal por valor en una sentencia
de mtodo debe ser una expresin y su tipo de valor debe concordar con el
determinado por el contexto de utilizacin del parmetro.
Un parmetro formal por referencia se utiliza cuando se debe pasar un valor desde el
mtodo a quin lo invoc. El parmetro formal por referencia representa la variable real
durante la invocacin al mtodo, por lo que cualquier cambio al valor del parmetro
formal por referencia se reflejan en el parmetro real.
Dentro del mtodo, cualquier referencia al parmetro formal por referencia accesa al
parmetro real mismo. El parmetro real debe coincidir en tipo de valor con el
parmetro formal por referencia.
Cabe recalcar que si bien en el lenguaje de pseudocdigo no se est considerando en
forma explcita la existencia de tipos de valores, sta queda determinada por el contexto
de utilizacin de las variables, al momento de asignacin de valores y aplicacin de
operadores.

Pag. 12

Constructores y destructores
Como hemos adelantado, los constructores y destructores son mtodos que controlan
la construccin y destruccin de objetos de una clase. Ellos se especifican como
componentes de la clase como un mtodo estndar, excepto que la palabra constructor
se utiliza como identificador del mtodo. Al igual que los mtodos, stos se pueden
heredar.
Los constructores se usan para crear e inicializar nuevos objetos. Por lo general, la
inicializacin se basa en los valores que se pasan como parmetros al constructor.
Normalmente la primera accin que realiza un constructor es invocar al constructor
heredado de su padre.
Los destructores se usan para retirar del entorno objetos. Cuando se invoca a un
destructor, se ejecutan las acciones definidas por el usuario para el destructor y luego
se libera los recursos asignados al objeto. Por lo general las acciones de un destructor
son destruir cualquier objeto contenido en l y liberar cualquier recurso solicitado por el
objeto. Tpicamente la ltima accin que realiza un destructor es llamar al destructor
heredado para deshacerse de los atributos heredados del objeto.
Clase CFigura viene-de CObjeto
Atributos
Largo
Ancho
Objeto Lpiz ejemplar-de Clpiz
Objeto Brocha ejemplar-de Cbrocha
Mtodos
Constructor(QueLargo, QueAncho)
Destructor
fClase
Mtodo CFigura.Constructor(QueLargo, QueAncho)
heredado Constructor
Ancho <-- QueLargo
Largo <-- QueAncho
Lpiz.Constructor
Brocha.Constructor
fmtodo
Mtodo CFigura.Destructor
Lpiz.Destructor
Brocha.Destructor
heredado Destructor
fmtodo

Acceso a los atributos

Para poder mantener la integridad de la informacin que maneja nuestra solucin
lgica, debemos disciplinarnos en el acceso a los atributos definidos en las clases.
Conforme utilice el enfoque orientado a objetos para realizar sus algoritmos,
coincidiremos en que la manera de evitar que el cliente de un objeto acceda
directamente a los valores de los atributos propios de su clase, es necesario definir
mtodos especiales cuya funcin sean obtener el valor del atributo o alterar ste valor.
A estos mtodos especiales los denominamos mtodos de lectura y mtodos de
escritura.
Continuando con la sana poltica de establecer convenciones, a partir de ahora
acordaremos que los identificadores de mtodos de lectura, es decir los que retornan el
valor de un atributo, estn conformados por la palabra Obtener seguida del nombre del
atributo; as mismo, los mtodos de escritura se denotarn por la palabra Colocar
seguida del nombre del atributo y tendrn como parmetro por lo menos el valor con el
que se desea alterar el atributo.
Clase CFigura viene-de CObjeto
Atributos
Largo
Ancho
Objeto Lpiz ejemplar-de Clpiz

Pag. 13

Objeto Brocha ejemplar-de Cbrocha

Mtodos
Constructor(QueLargo, QueAncho)
Destructor
ObtenerLargo -->
ObtenerAncho -->
ColocarLargo(NuevoLargo)
ColocarAncho(NuevoAncho)
fClase

Envo de Mensajes
Un mtodo se activa mediante el envo de un mensaje a un objeto consistente de un
identificador de mtodo seguido por una lista real de parmetros. Este tipo de llamada
se conoce como invocar un mtodo enviar un mensaje.
IdentificadorObjeto.
IdentificadorObjeto.IdentificadorMtodo [(
[(ListaRealParmetros)
ListaRealParmetros)]

Ilustracin .22. Sintaxis de Envo de Mensaje.

El identificador de objeto expresado arriba debe denotar una referencia a un objeto
existente. La instancia especificada al momento del envo del mensaje se convierte en
forma implcita en un parmetro real para el mtodo; corresponde con un parmetro
real llamado Este, que tiene el conocimiento de la clase a la que corresponde el
mtodo que se est invocando.
Cuando invocamos a mtodos de una clase dentro de la declaracin de definicin de
otro mtodo de la misma clase se omite la referencia al objeto, quedando slo el
identificador del mtodo y la lista real de parmetros.
Para el caso de los mtodos estticos, aquellos mtodos que se invocan directamente
de la clase, se utiliza el nombre de la clase seguido del identificador del mtodo y la lista
real de parmetros.
IdentificadorClase.
IdentificadorClase.IdentificadorMtodo [(
[(ListaRealParmetros)
ListaRealParmetros)]

El identificador de clase especificado debe hacer referencia a una clase existente y

debe separarse por un punto del identificador del mtodo del mensaje.

Declaracin de propiedades
Las propiedades son una caracterstica presente en muchos lenguajes de
programacin. Para declarar propiedades en oLoop se utiliza la siguiente sintaxis.
Propiedad IdentificadorPropiedad
[ obtener IdentificadorAtributo | IdentificadorMtodo ]
[ colocar IdentificadorAtributo | IdentificadorMtodo ]

Por ejemplo:
Clase CCliente
Atributos
Nombres
Apellidos
fechaltimaCompra
Mtodos
ObtenerNombres ->
ColocarNombres(pNombres)
ObtenerApellidos ->
ColocarApellidos(pApellidos)
ObtenerNombreCompleto ->
Propiedad NombreCompleto
obtener ObtenerNombreCompleto
Propiedad ltimaCompra

Pag. 14

obtener fechaltimaCompra
colocar fechaltimaCompra
fclase

Bibliotecas de clases
Las clases en una aplicacin pueden organizarse en bibliotecas. oLoop permite la
especificacin y uso de bibliotecas de clases en el pseudocdigo.

Especificacin de bibliotecas
Para especificar que una clase pertenece a un biblioteca determinada, basta con utilizar
la sentencia Biblioteca.
Biblioteca IdentificadorBiblioteca

Esta sentencia se coloca como primera lnea de la declaracin de clase, indicando que
la clase a declarar estar formando parte de la biblioteca indicada. Varias clases
pueden pertenecer a la misma biblioteca.
En la nomenclatura de identificadores de biblioteca, puede utilizarse el smbolo de punto
para delimitar los niveles de organizacin en el nombre de la biblioteca.
Por ejemplo:
Biblioteca com.empresa.aplicacioncompras.entidadesnegocio

Clase CCompra viene-de CEntidadNegocio

fclase

Uso de bibliotecas
Para indicar que una clase puede hacer uso de las clases pblicas en una biblioteca, se
utiliza la sentencias Usar.
Usar IdentificadorBiblioteca

La sentencia Usar se aplica para cada biblioteca cuyas clases e interfaces vaya a
utilizar la clase a declarar. Por ejemplo:
Biblioteca com.empresa.aplicacioncompras.cliente
Usar com.empresa.aplicacioncompras.entidadesnegocio
Usar com.empresa.utilidades
Clase CComprasAplicacion viene-de CAplicacion

fclase

Polimorfismo
Una de las caractersticas importantes del paradigma orientado a objetos es el
polimorfismo. El mismo nombre nos da una idea clara del concepto de polimorfismo,
pues poli significa mltiple y morfismo viene de formas, esto implica que un mismo
objeto puede tomar diversas formas. En oLoop, el polimorfismo se contempla en la
instancia de objetos y en la consulta de tipos.

Pag. 15

Durante la creacin de instancia de clases, puede aplicarse el polimorfismo, declarando

una clase como ejemplar de una clase genrica, e invocando al constructor de una
clase hija ms especfica al momento de crear la instancia. En la siguiente seccin
daremos un ejemplo de este tipo de instancia.

Consulta de tipo
oLoop implementa la consulta de tipo de un objeto por medio de la palabra reservada
es-instancia-de.
IdentificadorObjeto es-instancia-de IdentificadorClase

La combinacin de estos elementos constituye una expresin booleana que puede ser
verdadera o falsa. Por lo general se utiliza en combinacin con la sentencia
Si..entonces.
En el siguiente ejemplo, se asume la existencia de tres clases, una clase genrica
CEmpleado y dos clases descendientes denominadas CEmpleadoTiempoParcial y
CEmpleadoTiempoCompleto. La variable Empleado se declara como ejemplar de la
clase CEmpleado, pero al momento de crear la instancia, se utiliza el mtodo
constructor de la clase CEmpleadoTiempoCompleto. Posteriormente, se consulta en
una sentencia Si para saber si el objeto es una instancia del tipo
CEmpleadoTiempoCompleto.
Objeto Empleado ejemplar-de CEmpleado

Empleado CEmpleadoTiempoCompleto.constructor(cod, salario)

Si(Empleado es-instancia-de CEmpleadoTiempoCompleto) entonces

fsi

Casting de tipo
El trmino casting proviene de la palabra cast que significa en espaol molde, por lo
que una traduccin literal nos llevara a algo como hacer un molde. oLoop implementa
en su sintaxis la especificacin de casting de un objeto, anteponiendo al identificador de
objeto el nombre de la clase cuya forma se desea que asuma, encerrada entre
parntesis.
(IdentificadorClase) IdentificadorObjeto

Esto puede ser de utilidad en las operaciones de asignacin. En caso se desee invocar
a un mtodo que pertenece a la clase objeto del casting, se encierra la expresin de
casting entre parntesis y se invoca al mtodo deseado.
((IdentificadorClase) IdentificadorObjeto).IdentificadorMtodo

Continuando con el ejemplo expuesto lneas arriba, se enva un mensaje al objeto

Empleado para que invoque al mtodo obtenerSalario, mtodo accesor que pertenece a
la clase CEmpleadoTiempoCompleto y no a la clase CEmpleado.

salario ((CEmpleadoTiempoCompleto)Empleado).obtenerSalario

Pag. 16

Comentarios
Los comentarios son construcciones que no forman parte de la descripcin de la lgica,
pero son valiosos elementos para explicar y hacer ms claro nuestro algoritmo. Para
insertar un comentario, basta con escribir dos smbolos de divisin seguidos (//) y a
continuacin el texto que se desee colocar. Se considera comentario hasta el final de la
lnea.
// Este es un ejemplo de un comentario
// que ocupa varias lneas.

Pag. 17

Jerarqua de Clases predefinidas

La mayora de herramientas de la actualidad nos proporcionan una jerarqua de clases
predefinidas que podemos tomar como punto de partida para desarrollar nuestra
aplicacin y para crear nuestras propias clases. Nosotros no tenemos que consumir
tiempo en crear clases que cumplan estas funciones. Basta con crear instancias de sus
clases. Acorde con esto, nuestro lenguaje de pseudocdigo tambin pone a disposicin
del creador de aplicaciones un conjunto de clases que tienen los atributos y mtodos
bsicos para concebir nuestra solucin. Se ha tratado de no incluir los atributos o
mtodos que estn estrechamente relacionados con los aspectos visuales o fsicos,
dejando slo los que nos ayuden a definir el comportamiento de nuestro algoritmo.
La clase raz de nuestra jerarqua es CObjeto, la cual es una clase completamente
abstracta y que slo sirve de punto de partida del rbol. La clase que desciende sta es
CComponente, de la cual descienden todas las dems clases de nuestra jerarqua. Es
con ella que comenzamos nuestra descripcin.

Pag. 18

La clases Componentes
Atributos comunes (CComponente)
La lista de atributos vara entre componentes, pero algunos son comunes a todos:
Atributo
Activado
Visible

Funcin
Determina si el componente reaccionar ante las acciones del usuario.
Determina si el componente se mostrar sobre el formulario durante la
ejecucin.
Tabla .2. Atributos comunes para los componentes en general.
Clase CComponente viene-de CObjeto
Atributos
Activado
Visible

Mtodos

ObtenerActivado -->
ObtenerVisible -->
ColocarActivado
ColocarVisible
fclase

Existen, como veremos ms adelante, dos clases que definen dos niveles de
profundidad en la jerarqua, CControl y su hijo, CControlWindows. Las clases que
describiremos a continuacin son descendientes directas de CControlWindows.

Visualizar y editar texto

Posiblemente la tarea ms comn en un programa es mostrar y editar texto. Las
capacidades de texto se utilizan para obtener informacin del usuario y retornar
resultados al mismo. Para facilitarnos esta labor, contamos con tres componentes
bsicos para manejar texto: Etiquetas, Cajas de Edicin y Cajas de Memo.

El componente Etiqueta (CEtiqueta)

Informacin del Entorno

Ilustracin .23. Ejemplo de Etiqueta.

El componente etiqueta nos permite mostrar texto, pero no permite al usuario ingresar
informacin. El texto que muestra este componente est contenido en el atributo Ttulo
del componente.
Atributo
Ttulo

Funcin
Contiene el texto que muestra la Etiqueta
Tabla .3. Atributos de CEtiqueta.
Clase CCEtiqueta viene-de CControlWindows
Atributos

Pag. 19

Ttulo

Mtodos

ObtenerTtulo -->
ColocarTtulo
fclase

El componente Caja de Edicin (CEdicin)

Nombre

Ilustracin .24. Ejemplo de Caja de edicin.

Un componente relacionado con la Etiqueta es la caja de Edicin. Este componente le
permite visualizar informacin, pero a su vez permite al usuario ingresar informacin
que puede ser utilizada por nuestro programa. El texto de la Caja de Edicin est
contenido en el atributo Texto del componente. Como es de suponerse, el texto se
ingresa digitando, pero a manera de comentario, agrego que la Caja de Edicin soporta
las operaciones estndares de cortar, copiar y pegar. Aunque al momento de la
concepcin del algoritmo, suponemos la existencia de recursos ilimitados, debemos
tomar en cuenta que la mayora de herramientas permiten que se ingrese textos de
hasta 255 caracteres. Los atributos clave para un componente de este tipo son los
siguientes:
Atributo
Texto
Modificado
SoloLectura

Funcin
Contiene el texto que visualiza la caja de Edicin o que ingresa el
usuario.
Indica si el texto ha sido modificado por el usuario. Esta propiedad
puede verificarse para ver si se necesita algn procesamiento para
el texto.
Si est en Verdadero, prohibe al usuario la edicin del texto.
Tabla .4. Atributos de CEdicin.

Clase CCEdicin viene-de CControlWindows

Atributos
Texto
Modificado
SloLectura

Mtodos

ObtenerTexto -->
ColocarTexto
ObtenerModificado -->
ColocarModificado
ObtenerSloLectura -->
ColocarSloLectura
fclase

Permitir que el usuario haga elecciones simples

Tan til como la capacidad de ingresar texto, a menudo deseamos restringir lo que el
usuario ingrese a unas cuantas alternativas. Por ejemplo, si deseamos obtener el
estado civil de una persona, podramos colocar una Etiqueta como Es usted
casado(a)? y utilizar una Caja de Edicin para obtener la respuesta. Sin embargo, no
sabemos cmo nos puede responder el usuario. Puede ingresar S o No, o puede slo

Pag. 20

ingresar S o N. Y como usted y yo sabemos, siempre existe la posibilidad de un ingreso

errneo.
Las herramientas de la actualidad nos proporcionan componentes estndares para
manejar las alternativas simples. La primera es la Casilla de Verificacin que se utiliza
para proporcionar al usuario elecciones del tipo S o No. El otro componente es el Botn
de Radio, que se utiliza para brindar al usuario un conjunto muy limitado de alternativas.

La Casilla de Verificacin (Ccasilla)

Verificar ortografa
Activar guiones
Autocorreccin

Ilustracin .25. Ejemplo de Casilla de verificacin.

La Casilla de verificacin es muy fcil de configurar. Slo debe asignarse valor al
atributo Ttulo para visualizar lo que se desee que aparezca junto a la casilla. El Ttulo
debe ser una oracin o proposicin que tiene una respuesta obvia de S o No. Cuando
el usuario encuentra una Casilla de Verificacin, una marca de verificacin () indica
una respuesta de S o Verdadero. Si no hay marca alguna, la respuesta ser No o
Falso. El usuario puede cambiar el estado de la Casilla de Verificacin haciendo clic
sobre la Casilla o presionando la barra espaciadora mientras que este componente
tiene el foco. Para determinar qu respondi el usuario, tenemos que examinar el
atributo Verificada de la Casilla. Un uso muy frecuente de las Casillas de Verificacin
es para establecer las opciones de un programa. Si la Casilla est Verificada, la opcin
est activa.
Atributo
Ttulo
Verificada

Funcin
Determina el texto que aparece junto a la casilla.
Determina si el usuario activ la casilla de verificacin.
Tabla .5. Atributos de CCasilla.
Clase CCasilla viene-de CControlWindows
Atributos
Ttulo
Verificada

Mtodos

ObtenerTtulo -->
ColocarTtulo
ObtenerVerificada -->
ColocarVerificada
fclase

Botones de Radio (CbotnRadio)

Impresora local
Impresora de red
Un Archivo en disco...

Ilustracin .26. Ejemplos de Botn de radio.

Los Botones de Radio son otro medio para presentar al usuario un nmero limitado de
alternativas, donde cada Botn de Radio corresponde con una posibilidad. El trmino
Botn de Radio tiene su origen en la idea de las radios de los carros que tenan varios
botones que se presionaban para elegir una estacin. El botn permaneca hundido
Pag. 21

luego de presionarse. Uno elega otra estacin presionando un botn y el anterior se

levantaba. Los Botones de Radio en un programa funcionan de la misma manera. Slo
uno de los Botones puede estar presionado en un instante dado. La eleccin de un
Botn hace que todos los dems se deseleccionen. En la pantalla cada Botn de Radio
se presenta como un crculo. El Botn seleccionado tiene un punto negro en el interior,
mientras que todos los dems estn vacos.
Atributo
Ttulo
Verificada

Funcin
Determina el texto que aparece junto al Botn de Radio.
Determina si el usuario eligi esta alternativa.
Tabla .6. Atributos de CBotnRadio.

Configurar los Botones de Radio es tan simple com con las Casillas de Verificacin.
Basta con establecer el atributo Ttulo para que el usuario conozca la alternativa
representada por el Botn. Durante la ejecucin examinamos el atributo Verificada de
cada Botn para determinar cul fue seleccionada por el usuario.
Clase CBotnRadio viene-de CControlWindows
Atributos
Ttulo
Verificada

Mtodos

ObtenerTtulo -->
ColocarTtulo
ObtenerVerificada -->
ColocarVerificada
fclase

Botones para presionar (CBotnAccin)

< Back

Next >

OK

Cancel

Ilustracin .27. Ejemplos de Botn de accin.

Otro componente ampliamente utilizado es el componente Botn de Accin. Este
componente proporciona al usuario un medio para iniciar alguna accin en un
programa, como grabar un registro o realizar un clculo. El atributo clave para este
componente es Ttulo y es un texto que le dice al usuario qu accin se llevar a cabo
cuando presione el Botn de Accin.
Atributo
Ttulo
Cancelar
PorDefecto

Funcin
Contiene el texto que muestra el Botn de Accin
En Verdadero si se desea que que el Botn reaccione cuando el
usuario presione Esc.
En Verdadero si queremos que la tecla Enter haga que el Botn
reaccione, an si ste no tiene el foco.
Tabla .7. Atributos de CBotnAccin.

Clase CBotnAccin viene-de CControlWindows

Atributos
Ttulo
Cancelar
PorDefecto

Mtodos

ObtenerTtulo -->
ColocarTtulo
ObtenerCancelar -->
ColocarCancelar

Pag. 22

ObtenerPorDefecto
ColocarPorDefecto
fclase

Controles especializados
Los siguientes controles proporcionan alternativas para la captura de datos.
La Barra de Desplazamiento se utiliza para seleccionar valores en un rango
continuo.
La Barra de Dial es til para dar un mayor efecto de barra de
desplazamiento.
El Arriba Abajo ayuda a conectar un spinner con una caja de edicin.

Barras de Desplazamiento (CBarraDesp)

Ilustracin .28. Ejemplo de Barra de desplazamiento.

Esta es la barra de desplazamiento de Windows, que se utiliza para desplazar el
contenido de una ventana; formulario o control. En la tabla podemos apreciar sus
principales atributos.
Atributo
VariacinGrande
VariacinPequea

Mn/Mx
Posicin

Funcin
Determina cuanto se mueve cuando el usuario hace clic
sobre la barra a cualquiera de los lados.
Determina cuanto se mueve cuando el usuario hace clic
sobre las flechas a los extremos de la barra o utiliza las
flechas de desplazamiento en el teclado. Su valor por
defecto es 1.
Indican cuntas posiciones estn disponibles en la barra de
desplazamiento.
Informan de cunto se ha desplazado en la barra.
Tabla .8. Atributos de CBarraDesp.

Clase CBarraDesp viene-de CControlWindows

Atributos
VariacinGrande
VariacinPequea
Mn
Mx
Posicin

Mtodos

ObtenerVariacinGrande -->
ColocarVariacinGrande
ObtenerVariacinPequea -->
ColocarVaricinPequea
ObtenerMn -->
ColocarMn
ObtenerMx -->
ColocarMx
ObtenerPosicin -->
ColocarPosicin
fclase

Barra de Dial (Cdial)

Pag. 23

Ilustracin .29. Ejemplo de Barra de dial.

Este tipo de barra es conveniente cuando se desea establecer o ajustar valores
numricos sobre un rango continuo, como el volumen o el brillo. Dicho componente
consiste de una barra que define la extensin o rango de ajuste y un indicador que
muestra el valor actual del control y proporciona los medios para modificar el control.
El usuario mueve el indicador arrastrndolo a una ubicacin en particular o haciendo
clic sobre una zona especfica de la barra, lo que mueve el indicador directamente a
esa posicin. Sus propiedades son bsicamente similares a los de la barra de
desplazamiento.

Control Arriba Abajo (CarribaAbajo)

Longitud:

33.40

Ilustracin .30. Ejemplo de Control Arriba Abajo.

Los controles ArribaAbajo son cajas de texto que aceptan un conjunto limitado y
ordenado de valores discretos que varan en forma cclica.
Cuando el usuario hace clic sobre la caja de texto o los botones, el foco pasa a la caja
de texto del control. El usuario puede escribir un valor directamente en la caja de texto o
utilizar los botones para incrementar o decrementar el valor.
Uilice Asociar parta conectar el control con una caja de texto.
Uilice Mx y Mn para establecer los lmites sobre los que puede fluctuar el valor del
control.
El atributo Posicin almacena el valor conforme el control va incrementndose o
decrementndose. Este atributo se establecer con un valor por defecto.
Por defecto, este control se detiene en su valor mximo. Si deseamos que el control
regrese al valor mnimo cuando llega al mximo, coloque Circular en Verdadero.

Manejo de Listas
Estilo:

Normal

Ilustracin .31. Ejemplo de Lista desplegable.

Las listas se utilizan para presentar al usuario con una coleccin de elementos de los
que se puede seleccionar uno o ms de ellos. Acorde con las herramientas de hoy,
distinguimos varias clases predefinidas.
Una Caja de Lista se utiliza para mostrar un lista de textos de las que se puede
seleccionar uno o ms.
La Lista Combinada muestra un lista que se despliega, y es til para ahorrar espacio.
Las Vista en rbol muestra los elementos en forma jerrquica.

Pag. 24

Atributos comunes para los controles de Lista

Para agregar columnas adicionales a un control de lista, contamos con el atributo
Columnas, que almacena el nmero de columnas que se desee.
La propiedad Elementos es en realidad un conjunto de cadenas texto que se llenan con
valores.
El atributo Indice de Elemento indica cul de los elementos en la lista se ha
seleccionado.
Se puede permitir a los usuarios seleccionar ms de un elemento a la vez
estableciendo la propiedad Multieleccin en verdadero. Los usuarios pueden entonces
utilizar la tecla Ctrl para seleccionar elementos en posiciones discontinuas, o Shift para
seleccionar un rango de elementos.
El atributo Ordenada determina si la lista se ordenar el orden alfabtico.

Cajas de Lista (CCajaLista)

Una caja de lista muestra una relacin de la que los usuarios pueden seleccionar uno o
ms elementos. Las cajas de lista basan su comportamiento en los valores de los
tributos especificados en la seccin anterior.

Listas combinadas (CListaCombinada).

Una lista combinada es un control que combina una caja de texto con una lista. Los
usuarios pueden digitar texto o seleccionar un elemento de la lista, con lo que el valor
de Texto se actualiza.
Por defecto la lista desplegable muestra 8 elementos. Para incrementar o decrementar
dicho valor colquelo en el atributo CantidadDesplegada.

Fichas (CFicha)
Grabar

Compilador

Ilustracin .32. Ejemplo de Ficha.

Este componente es un conjunto de pginas que se utiliza para crear dilogos de varias
pginas. En la siguiente tabla se muestran sus propiedades.
Atributo
PginaActiva
Multilnea
NmeroDePginas
Pginas

Funcin
Especifica cul es la ficha seleccionada en ese
momento.
Es Verdadero si hay varias lneas de fichas.
Especifica el nmero de pginas.
Nos permite acceso a las fichas.
Tabla .9. Atributos de Cficha.

Pag. 25

La clase CFormulario
Formulario en Blanco

Ilustracin .33. Ejemplo de un Formulario en blanco.

La clase componente CFormulario es por lo general el centro de toda aplicacin. Sobre
un formulario colocamos otros elementos, y los podemos utilizar como simples
formularios, ventanas, cajas de dilogo o formularios de entrada de datos.
Para mostrar un formulario que no est activo en este momento en nuestra aplicacin,
utilizamos los mtodos Mostrar y MostrarModal (el trmino modal indica que no se
puede seleccionar otras reas de la aplicacin mientras est activo el formulario). El
atributo ControlActivo es una apuntador que tiene la direccin del control activo sobre el
formulario.
Puede utilizar el mtodo de tratamiento de evento AlCrear para establecer valores
iniciales para los atributos y hacer cualquier proceso que se desee ocurra antes que el
usuario comience a interactuar con el formulario.
Adems de estos atributos y mtodos, esta clase tiene todos los atributos y mtodos de
los controles de Windows pues es un descendiente de la clase CcontrolWindows.
Clase CFormulario viene-de CControlWindows
Atributos
Apuntador ControlActivo
ResultadoModal
Mtodos
Constructor
AlCrear
Mostrar
MostrarModal
Destructor
fclase

La clase CAplicacin
Todo algoritmo que representa una aplicacin utiliza una clase que desciende de
CAplicacin. Cuando ejecuta su aplicacin, se invoca al mtodo Principal. El mtodo
Terminar finaliza la ejecucin de la aplicacin. El atributo FormularioPrincipal es una
apuntador que debe tener el valor de la direccin del formulario que aparece como base
de la aplicacin.
Dado que los entornos actuales existe la propiedad de minimizar y restaurar la
aplicacin, hemos incluido estos mtodos para que puedan invocarse por
programacin. As mismo los puede extender para que realice otras acciones aparte.
Pag. 26

Podemos especificar cmo se manejarn las excepciones utilizando los mtodos

ManejarExcepcin, AlOcurrirExcepcin y MostrarExcepcin.
CAplicacin tiene varios mtodos de tratamiento de eventos que permiten especificar
cmo la aplicacin procesa la ocurrencia de eventos especiales. Para especificar qu
ocurre cuando la aplicacin se activa o inactiva utilizamos los mtodos AlActivar y
AlDesactivar. Cuando la aplicacin entra en estado de espera (conocido como idle)
podemos especificar que ocurra algo por medio del mtodo AlEsperar.
Adems de estos atributos y mtodos, el componente CAplicacin tiene tambin los
atributos y mtodos que se aplican a todos los componentes, pues es un descendiente
directo de CComponente.
Ejemplo.
Clase CAplicacin viene-de CComponente
Atributos
Arreglo aEntorno
nEntorno
Apuntador FormularioPrincipal
Ttulo
Mtodos
Constructor(aEntorno, nEntorno)
Principal
Terminar
Minimizar
Restaurar
ManejarExcepcin
AlOcurrirExcepcin
MostrarExcepcin
AlEsperar
AlActivar
AlDesactivar
Destructor
fclase

Observe que el mtodo constructor tiene dos parmetros: aEntorno y nEntorno. Estos
son respectivamente un arreglo de cadenas de texto y un nmero respectivamente.
Contienen los parmetros que nos enva el entorno del sistema y el nmero de
parmetros que estamos recibiendo.
El siguiente ejemplo es un uso muy sencillo de esta clase. El objetivo de esta aplicacin
es mostrar un mensaje en la pantalla.
Clase CMiAplicacin viene-de CAplicacin
Mtodos
Constructor(aEntorno, nEntorno)
Principal
fclase
Mtodo Constructor(aEntorno, nEntorno) de CMiAplicacin
Heredado Constructor(aEntorno, nEntorno)
Ttulo <-- Aplicacin de Ejemplo
FormularioPrincipal <-- Nulo
fmtodo
Mtodo Principal de CMiAplicacin
heredado Principal
MostrarMensaje(Pertenezco a la clase CMiAplicacin)
fmtodo

Observe que nosotros estamos creando un descendiente de la clase CAplicacin, pero

en ningn momento estamos creando una instancia de CMiAplicacin. Estos es debido
a que estamos utilizando el concepto de que el sistema es quien ejecuta nuestra
aplicacin, y por tanto la creacin de la instancia y la llamada a los mtodos Constructor

Pag. 27

y Principal depende del sistema, no del programador. En la implantacin no siempre

ocurre lo mismo. Algunas herramientas cuentan con un programa principal que necesita
que creemos la instancia de la aplicacin y llamemos a los mtodos Constructor y
Principal (o sus equivalentes).

Pag. 28

Tratamiento de Eventos
Los eventos son parte importante de las clases, aunque el desarrollador por lo general
no necesita mayor esfuerzo con ellos. Un evento es un enlace entre una ocurrencia en
el sistema (como una accin del usuario o un cambio en el foco) a la que una clase
podra necesitar responder y una seccin de cdigo que responde a esa ocurrencia. El
bloque de cdigo de respuesta es el gestor del evento, y mayormente lo escribe el
creador de la clase.
Al utilizar los eventos, los desarrolladores de aplicaciones pueden personalizar el
comportamiento de las clases sin tener que cambiar las clases en s. Como creadores
de clases, utilizamos los eventos para que los desarrolladores de aplicaciones
personalicen el comportamiento de nuestras clases.
Los eventos para la mayora de las acciones del usuario (como por ejemplo las
acciones del ratn) ya estn incorporadas en las clases predefinidas de nuestro
lenguaje, pero proporcionamos los mecanismos para definir nuevos eventos y
asociarlos con las clases.
En nuestro lenguaje de pseudocdigo, las clases predefinidas tiene incorporados
mtodos que responden a cietros eventos estndares. Por ejemplo la clase
CBotnAccin tiene un mtodo AlClic. La capa de administracin de eventos es el
conjunto de mecanismos que toda herramienta de desarrollo orientada a objetos y
eventos tiene y que debemos suponer como existente. El lenguaje de pseudocdigo
proporciona los mecanismos para la escritura del cdigo que responde a los eventos,
pero es durante la ejecucin que se va transfiriendo el control a los mtodos
correspondientes, y esta labor la realiza la capa de administracin de eventos, la cual
est fuera del contexto de nuestro lenguaje.

Implantar eventos estndar

Eventos estndar para todos los controles
Los eventos bsicos se definen en la clase CControl. Todos los controles, sean de
Windows, grficos o personalizados, heredan estos eventos. La siguiente tabla lista los
eventos disponibles para todos los controles:
Evento
Clic

Ocurre cuando
Mtodo asociado
El usuario presiona una vez el botn
AlClic
izquierdo del ratn.
DobleClic
El usuario presiona dos veces seguidas el
AlDobleClic
botn izquierdo del ratn.
ArrastrarSoltar
El usuario arrastra el objeto con el ratn.
AlArratrarSoltar
FinArrastrar
Finaliza la oparcin de arrastrar, es decir,
AlFinArrastrar
suelta el ratn.
MoverRatn
Se desplaza por la pantalla el puntero del
AlMoverRatn
ratn.
ArratrarSobre
El puntero del ratn est pasando sobre un AlArrastrarSobre
objeto.
UndirRatn
Presionar el botn del ratn.
AlUndirRatn
SoltarRatn
Levantar el dedo del botn del ratn.
AlSoltarRatn
Tabla .10. Eventos estndar comunes a las Clases componentes.
Todos los eventos estndar tienen sus correspondientes mtodos declarados en la
clase CControl, con el mismo nombre que el evento, pero precedidos por el prefijo Al.
Aqu expresamos de otra manera lo anteriormente dicho:
Pag. 29

Clase CControl viene-de CComponente

Mtodos
AlClic
AlDobleClic
AlArrastrarSoltar
AlMoverRatn
AlArrastrarSobre
AlUndirRatn
AlSoltarRatn
fclase

Eventos estndar para los controles estndar

Adems de los eventos comunes a todas las clases de componentes, los controles
estndar (de Windows) tiene los siguientes eventos:
Evento
Ocurre cuando
Mtodo asociado
Entrar
se pasa el foco al componente
AlEntrar
SoltarTecla
el usuario deja de presionar una tecla
AlSoltarTecla
UndirTecla
el usuario realiza presin sobre una tecla
AlUndirTecla
PresionarTecla la combinacin de las dos anteriores
AlPresionarTecla
Salir
perder el foco
AlSalir
Tabla .11. Eventos de las Clases componentes estndar.
Al igual que los eventos estndar de la seccin anterior, los eventos para los controles
de Windows (CControlWindows) tiene sus mtodos correspondientes.
Clase CControlWindows viene-de CControl
Mtodos
AlEntrar
AlSoltarTecla
AlUndirTecla
AlPresionarTecla
AlSalir
fclase

Eventos clave
Clase
CEdicin
CBotnAccin
CCasilla

Evento
Cambiar
Clic
Clic

Ocurre cuando
El usuario modifica el texto en la Caja.
El usuario hace clic sobre el Botn.
El usuario hace clic sobre la Casilla de
Verificacin.
CBotnRadio
Clic
El usuario hace clic sobre el Botn de radio
Tabla .12. Eventos clave para las Clases componentes.
De todos estos eventos clave, el nico que no est ya contemplado por las clases es el
evento Cambiar. Para este evento, el mtodo asociado en la clase CEdicin sera
AlCambiar.

Pag. 30

Excepciones
Una excepcin es por lo general una condicin de error u otro evento que interrumpe el
flujo normal de ejecucin en una aplicacin. Cuando se provoca una excepcin, sta
hace que el control se transfiera del punto actual de ejecucin a un gestor de
excepciones. El soporte de manejo de excepciones del lenguaje de pseudocdigo
proporciona una manera estructurada de separar la lgica normal del algoritmo de la
lgica de manejo de errores, facilitando as el mantenimiento y fortaleciendo la solucin.
Para representar las excepciones optamos por utilizar objetos. Las ventajas principales
son:
Las excepciones se pueden agrupar en jerarquas utilizando la herencia.
Se pueden introducir nuevas excepciones sin afectar el cdigo existente.
Un objeto de excepcin puede llevar informacin (como un mensaje de error
o un cdigo de error) desde el punto donde se provoc hasta el punto donde
se maneja.

Las excepciones se manejan con las sentencias ProtegerExcepcin.

Proteccin de Sentencias
Las excepciones se manejan usando la sentencia ProtegerExcepcin.
Proteger
lista de sentencias protegidas
Excepcin
Bloque de excepciones
Sino
Bloque a ejecutar cuando no coincide con las listadas
fproteger

Una sentencia ProtegerExcepcin ejecuta las sentencias en la lista de sentencias en

orden secuencial. Si las sentencias se ejecutan sin que se provoquen excepciones, el
bloque de excepciones se ignora, y el control se pasa a la sentencia que sigue a la
palabra reservada fproteger que finaliza la sentencia ProtegerExcepcin.

Tratamiento de Excepciones
Cuando identificador-clase-excepcin
Hacer
Secuencia de acciones para tratar la excepcin
fcuando

El bloque de excepciones en la seccin Excepcinfproteger define los manejadores

de excepciones para la lista de sentencias protegidas. Un manejador de excepciones
slo se puede invocar por una sentencia Provocar ejecutada en el la lista de sentencias
protegidas o por un mtodo invocado en la lista de sentencias protegidas.
Cuando se provoca una excepcin, el control se transfiere al manejador ms prximo
que puede tratar las excepciones de esa clase. La bsqueda de un manejador de
excepcin se inicia con la sentencia ProtegerExcepcin
ingresada ms
recientemente y de la que an no hemos salido. Si esa sentencia ProtegerExcepcin
no puede tratar la excepcin, se examina la siguiente sentencia ProtegerExcepcin a
la que se ha ingresado recientemente. La propagacin de la excepcin contina hasta
que se encuentra el manejador adecuado, o hasta que no hay ms sentencias
ProtegerExcepcin. En el ltimo caso se emite un mensaje de error y el algoritmo
finaliza.
Pag. 31

Para determinar si el bloque de excepcin de una sentencia ProtegerExcepcin

puede manejar una excepcin en especial, los manejadores Cuandofcuando se
examinan en orden de aparicin. El primer manejador de excepciones que lista la clase
excepcin o la clase base de la excepcin se considera una coincidencia. Si un bloque
de excepcin contiene una parte Sino y si ninguno de los manejadores de excepciones
Cuandofcuando concuerda con la excepcin, la parte Sino se considera una
coincidencia. Un bloque de excepciones que contiene slo una lista de sentencias se
considera una coincidencia para cualquier excepcin.
Luego de la ejecucin de un manejador de excepciones, el objeto se destruye
automticamente invocando al mtodo Destructor, y as el control se pasa a la
sentencia que sigue a la palabra clave fproteger la cual finaliza la sentencia Proteger
fproteger.
En el siguiente ejemplo, el primer Cuandofcuando maneja la excepcin de divisin
por cero y el segundo maneja la excepcin de sobreflujo.
Proteger

Excepcin
Cuando CDivisinPorCero
Hacer
ManejarDivisinPorCero
fcuando
Cuando CSobreflujo
Hacer
ManejarSobreflujo
fcuando
fproteger

Un manejador Cuandofcuando puede especificar opcionalmente especificar la

declaracin de un objeto excepcin en vez de slo el identificador de la clase. As
podemos utilizar esta instancia dentro de las sentencias del bloque Cuandofcuando.
Por ejemplo
Proteger

Excepcin
Cuando Objeto E ejemplar-de CExcepcin
Hacer
MostrarMensaje(ObtenerMensaje de E)
fcuando
fproteger

El mbito de un identificador de objeto que se declara en un manejador de excepcin

son las sentencias que estn dentro del Cuandofcuando.
Si la sentencia Protegerfproteger especifica una parte Sino, entonces cualquier
excepcin que no se trata en los manejadores Cuandofcuando ser tratada por la
parte Sino. Por ejemplo
Proteger

Excepcin
Cuando CDivisinPorCero
Hacer
ManejarDivisinPorCero
fcuando
Cuando CSobreflujo
Hacer
ManejarSobreflujo
fcuando
Sino
ManejarOtras
fproteger

Pag. 32

Un bloque de excepcin que no contiene manejadores Cuandofcuando, pero contiene

un grupo de sentencias, manejar todas las excepciones.
Proteger

Excepcin
ManejarExcepcin
fproteger

Aqu cualquier excepcin que ocurra como resultado de la ejecucin de las sentencias
de las sentencias entre Proteger y Excepcin sern manejadas por el mtodo
ManejarExcepcin.

Generacin manual de Excepciones

Una excepcin se provoca con la sentencia Provocar.
Provocar identificador-objeto-excepcin

El argumento de la sentencia Provocar debe ser un objeto. Cuando se provoca una

excepcin, la lgica de tratamiento de excepciones toma se apropia del objeto
excepcin. Una vez que la excepcin se maneja, el objeto excepcin se destruye
automticamente invocando a su destructor. Nosotros no debemos tratar de destruir
manualmente el objeto excepcin.
Mtodo IngresarNmero (Nmero, Mn, Mx) de Biblioteca
EErrorRango ejemplar-de CErrorRango
Leer(Nmero)
Si (Nmero < Mn) o (Nmero > Mx)
entonces
Provocar EErrorRango
// llama al constructor
fsi
fmtodo

Excepciones predefinidas
Para el lenguaje de pseudocdigo propuesto hemos definido ciertas clases de
excepcin, incluyendo una clase CExcepcin que sirve de raz para todas las clases de
excepcin. Debemos tomar en cuenta que al tratarse de un lenguaje para especificar
algoritmos, hay ciertas excepciones que no aparecern a este nivel (por ejemplo las de
acceso a direcciones de memoria invlida).
Clase CExcepcin viene-de CObjeto
Atributos
Mensaje
ContextoDeAyuda
Mtodos
Constructor(UnMensaje, UnContextoDeAyuda)
ObtenerMensaje -->
ObtenerContextoDeAyuda -->
fclase

La clase CExcepcin establece dos propiedades, Mensaje y ContextoDeAyuda, que

todo objeto de excepcin hereda. Esto significa que cualquier objeto de excepcin
cualquiera puede por lo menos proporcionar un mensaje descriptivo de la condicin de
excepcin y posiblemente un contexto de ayuda que haga referencia a una ayuda del
tpico.

Pag. 33

A continuacin se listan las excepciones que contempla el lenguaje de pesudocdigo y

las situaciones en que se pueden provocar. A menos que se especifique otra cosa, las
excepciones son descendientes directos de Cexcepcin.
Clase de Excepcin
CSinMemoria

Descripcin
Surge cuando no hay suficiente memoria para una
operacin en particular.
CErrorES
Surge cuando una operacin de entrada/salida genera un
error.
CErrorMatemtico
La clase padre de todas las excepciones de operaciones
matemticas.
CDivisinPorCero
Surge cuando se intenta una divisin que tiene por divisor
un valor de cero. Desciende de CErrorMatemtico.
CSobreflujo
Surge cuando una operacin produce un sobreflujo
(overflow). Est ms orientada a la implantacin, pero es
tan frecuente que cabe su inclusin. Desciende de
CErrorMatemtico.
CSobreflujoDePila
Aparece cuando la pila de nuestra aplicacin no puede
expandirse, o si el tamao de la pila alcanza su lmite
superior. Esta excepcin presupone un lmite en la pila,
una restriccin fsica, pero su frecuencia amerita incluirla.
Tabla .13. Clases derivadas de CExcepcin.

Pag. 34

Objetos Especiales
Arreglos
Los arreglos tienen un nmero fijo de componentes del mismo tipo de valor.

Declarar
Para declarar un arreglo en el pseudocdigo, necesitamos especificar un nombre o
identificador para el arreglo. As mismo tenemos que indicar el rango de valores para
cada una de las dimensiones del arreglo. Para indicar el rango de valores de uno de los
subndices, simplemente especificamos los lmites inferior y superior del rango y
colocamos entre ellos puntos suspensivos (). El nmero de elementos del arreglo es
el producto de los valores mximos de cada subndice.
nomb_de_arreglo [ Dimensin rango1, ..... , rangon ] Ejemplar-de
CArreglo

Por ejemplo:
aMatriz1 Dimensin 110, 120 Ejemplar-de Carreglo

Aqu definimos un arreglo llamado aMatriz1 cuyo nmero de elementos es 10*20. Noten
que estamos colocando el prefijo a en el nombre del arreglo, lo que indica que el
identificador corresponde a un arreglo.

Referencia
Podemos acceder a uno de los componentes proporcionando el identificador del arreglo
con el ndice correspondiente encerrado entre corchetes. Si no incluimos la referencia a
un componente en particular, el identificador del arreglo referencia a la totalidad de
ste.
nombre_de_arreglo [ndice] // Un elemento del arreglo
nombre_de_arreglo
// Todo el arreglo

En el siguiente ejemplo mostramos el uso de ambas posibilidades.

aAlumnoA Dimensin 120, 110 Ejemplar-de CArreglo
aAlumnoB Dimensin 110 Ejemplar-de CArreglo
aAlumnoC Dimensin 110 Ejemplar-de CArreglo

aAlumnoC <-- aAlumnoB

// referencia a todo el arreglo
aAlumnoA[5] <-- aAlumnoB // referencia global a una dimensin
aAlumnoA[3, 2] <-- Arturo Lpez// referencia a un componente

Iteracin sobre colecciones

Para el caso de las colecciones de elementos, se utiliza una variante de la sentencia
para, la cual especifica cmo se identificar al elemento actual en cada iteracin y a la
coleccin que se recorrer.
La sintaxis es la siguiente.
para cada IdentificadorElemento en IdentificadorColeccin
hacer
Secuencia de n acciones
fpara

Por ejemplo:
objeto arregloPersonas ejemplar-de CArregloPersonas
...

Pag. 35

para cada persona en arregloPersonas hacer

Escribir(persona.obtenerNombre)
fpara

Apuntadores
Los apuntadores son variables que almacenan un tipos especial de valor: direcciones
de memoria. En esas direcciones se guardan valores relevantes para nuestro algoritmo.

Reservar espacio
La operacin de reservar espacio para el apuntador podra compararse con la accin de
declarar al sistema que el identificador especificado se referir a un apuntador.
Reservar identificador_apuntador |
Reservar identificador_apuntador*Cantidad_Elementos

La sentencia Reservar asigna un bloque de memoria libre para el apuntador y almacena

la direccin de ese bloque en el apuntador. Cuando se desea reservar un arreglo de
bloques contiguos de memoria, se multiplica por la cantidad de bloques requeridos. La
palabra reservada nulo denota un valor que significa que nuestra variable apunta a
ninguna parte.
Reservar pCuenta
pCuenta <-- nulo

// Reserva espacio para el apuntador

// apunta a ninguna parte

Asignar valor
Los apuntadores pueden recibir direcciones como valores vlidos. Para obtener la
direccin de una variable basta con colocar el smbolo @ antes del identificador de la
variable y esto denotar su direccin de memoria. Otra manera de asignar valor es
colocar direcciones especficas ya sea en notacin decimal o hexadecimal (ambas muy
conocidas por nosotros), o en su defecto utilizando nulo.
identificador_apuntador <-- @ identificador
identificador_apuntador <-- expresin_de_direccin

Liberar espacio
La sentencia Liberar nos permite devolver al sistema el bloque de memoria que fuera
asignado al apuntador con la sentencia Reservar.
Liberar identificador_apuntador

Por ejemplo:
Liberar pCuenta

// Libera la memoria asignada a pCuenta

Acceder al valor apuntado

Para poder acceder al bloque de memoria apuntado, se utiliza el operador delante del
nombre del apuntador.
identificador_apuntador <-- valor

Por ejemplo:
pCuenta <-- '15307863'

Desplazamiento con apuntadores

En los casos de apuntadores a arreglos de bloques, para avanzar a un bloque
especfico del arreglo se utiliza la siguiente sintaxis, se incrementa el valor del
apuntador en la cantidad de posiciones que se desea desplazar.
identificador_apuntador <-- identificador_apuntador + n

Pag. 36

Por ejemplo:
pNumeros <-- pNumeros + 15 // Se desplaza 15 bloques

Estructuras
A fin de cubrir la existencia de tipos estructura existentes en algunos lenguajes (struct
en C++ o C#), oLoop permite la declaracin de estructuras, muy similares a las clases,
pero con la diferencia de que no poseen constructor ni son capaces de participar en
una jerarqua. Son bsicamente un tipo de valor compuesto para declaracin de
variables, ms que una clase que pueda aceptar creacin de instancias.
La sintaxis para declarar estructuras se presenta a continuacin.
Estructura IdentificadorEstructura
Atributos
IdentificadorAtributo { IdentificadorAtributo }
Mtodos
secuencia de m declaraciones de mtodos
festructura

Por ejemplo:
Estructura SFigura
Atributos
Largo
Ancho
Objeto Lpiz ejemplar-de CLpiz
Objeto Brocha ejemplar-de CBrocha
Mtodos
ObtenerLargo -->
ObtenerAncho -->
ColocarLargo(NuevoLargo)
ColocarAncho(NuevoAncho)
festructura

Para declarar variables de estructura, se utiliza la siguiente sintaxis.

identificador_variable ejemplar-de IdentificadorEstructura

Por ejemplo:
Estructura SInformacinPedido
Atributos
NmeroPedido
FechaPedido
festructura
...
informacinPedido ejemplar-de SInformacinPedido
informacinPedido.NmeroPedido <-- 450

Enumeraciones
En muchos lenguajes de programacin se implementa el concepto de enumeraciones o
tipos enumerados. En oLoop se puede declarar tipos para enumeraciones con la
siguiente sintaxis.
Enumeracin IdentificadorEnumeracin [ valor1 {, valor2,..,
valorN }]
Enumeracin EEstadoPedido [ PENDIENTE, APROBADO, RECHAZADO ]

Para declarar una variable de un tipo enumerado, se utiliza la siguiente sintaxis.

Pag. 37

identificador_variable ejemplar-de IdentificadorEnumeracin

Por ejemplo:
pedido ejemplar-de EEstadoPedido
pedido <-- EEstadoPedido.Pendiente

Interfaces
Para declarar interfaces en oLoop se utiliza la siguiente sintaxis.
Interfaz IdentificadorInterfaz
Atributos
IdentificadorAtributo { IdentificadorAtributo }
Mtodos
secuencia de m declaraciones de mtodos
finterfaz
IdentificadorMtodo [ ( ListaFormalParmetros ) ] [ --> ]
[ virtual | virtual abstracto | sobreescribir |
sobrecargar ]
ListaFormalParmetros
Identificador }

--> [ @ ] Identificador {, [ @ ]

Por ejemplo:
Interfaz IManejadorCliente
Mtodos
obtenerInstancia ->
registrarCliente(cliente) ->
fclase

Para declarar que una clase implementa una interfaz, se utiliza la siguiente sintaxis.
Clase IdentificadorClase implementa IdentificadorInterfaz
Atributos
IdentificadorAtributo { IdentificadorAtributo }
Mtodos
secuencia de m declaraciones de mtodos
fclase

Por ejemplo:
Clase CClienteNegocio implementa IManejadorCliente
Metodos
obtenerInstancia ->
registrarCliente(cliente) ->
fclase
Mtodo CClienteNegocio.obtenerInstancia ->
Objeto cliente ejemplar-de CClienteNegocio
cliente.constructor
retornar cliente
fmtodo
Mtodo CClienteNegocio.registrarCliente(cliente)
IAccesoDatos facade =
InfraestructuraFacade.obtenerInstancia
retornar facade.insertarCliente(
cliente.obtenerCodigo,
cliente.obtenerNombre,
cliente.obtenerUsuario,
cliente.obtenerContrasena,

Pag. 38

cliente.obtenerCorreo,
cliente.obtenerTelefono,
cliente.obtenerFax,
cliente.obtenerPais)
fmtodo

Archivos
oLoop permite el uso de archivos secuenciales o aleatorios. Para ello cuenta con la
clase predefinida CArchivo. Esta clase encapsula la funcionalidad genrica para el
manejo de archivos. La declaracin de la clase CArchivo se especifica a continuacin.
Clase CArchivo
Atributos
Nombre
Ruta
ModoAcceso

//
//
//
//
//

Nombre del archivo

Ruta de directorio del archivo
'Lectura' | 'Escritura' |
'Lectura-Escritura' | 'Adicin'
'Secuencial' | 'Aleatorio'

Tipo
Mtodos
Crear ->
Abrir ->
Cerrar ->
Leer ->
Leer(pPosicion) ->
Escribir(Objeto)
Escribir(Posicion, Objeto)
ObtenerNombre ->
ColocarNombre(NuevoNombre)
ObtenerRuta ->
ColocarRuta(NuevaRuta)
ObtenerModoAcceso ->
ColocarModoAcceso(NuevoModoAcceso)
ObtenerTipo ->
ColocarTipo(NuevoTipo)
FinDeArchivo ->
fclase

Pag. 39

Ejemplos de uso de oLoop

Declaracin de Clases y Mtodos
El siguiente ejemplo ilustra de manera sencilla la declaracin de una Clase. Definimos
una clase Punto, que entendemos por un pixel en la pantalla. Para definirlo
necesitamos sus coordenadas X e Y.
Clase CPunto
Atributos
X
Y
Mtodos
ObtenerX
ObtenerY
Constructor(NuevoX, NuevoY)
fclase

Pag. 40

Implantacin de Mtodos
Continuando con nuestro ejemplo del punto, demostramos como declarar las
definiciones de los mtodos de la clase arriba definida.
Mtodo CPunto.Constructor(NuevoX, NuevoY)
X <-- NuevoX
Y <-- NuevoY
fmtodo
Mtodo CPunto.ObtenerX
Retornar X
fmtodo
Mtodo CPunto.ObtenerX
Retornar Y
fmtodo

Pag. 41

Herencia y Extensin de Clases

En este ejemplo que presentamos a continuacin aplicaremos el mecanismo de la
herencia para extender la clase Cposicin.
Clase CPosicin
Atributos
X
Y
Mtodos
Constructor(NuevoX, NuevoY)
ObtenerX -->
ObtenerY -->
fclase
Clase CPunto viene-de CPosicin
Atributos
Visible
Mtodos
Constructor(NuevoX, NuevoY)
Mostrar
Ocultar
ObtenerVisible
MoverHacia(QueX, QueY)
fclase
// Mtodos de la Clase CPosicin
Mtodo CPosicin.Constructor(NuevoX, NuevoY)
X <-- NuevoX
Y <-- NuevoY
fmtodo
Mtodo CPosicin.ObtenerX
Retornar X
fmtodo
Mtodo CPosicin.ObtenerY
Retornar Y
fmtodo
// Mtodos de la Clase CPunto
Mtodo CPunto.Constructor(NuevoX, NuevoY)
Heredado Constructor(NuevoX, NuevoY)
Visible <-- Falso
fmtodo
Mtodo CPunto.ObtenerVisible
Retornar Visible
fmtodo
Mtodo CPunto.Mostrar
Visible <-- Verdadero
DibujarPixel(X, Y, ObtenerColorPrimerPlano)
// Dibuja un pixel en la pantalla (blanco sobre negro)
fmtodo
Mtodo CPunto.Ocultar
Visible <-- Falso
DibujarPixel(X, Y, ObtenerColorFondo)
// Dibuja un pixel en la pantalla (negro sobre negro)
fmtodo
Mtodo CPunto.MoverHacia(QueX, QueY)
Ocultar
// Oculta el punto
X <-- QueX
// Asigna las nuevas coordenadas

Pag. 42

Y <-- QueY
Mostrar
fmtodo

// Muestra el punto

// La clase CCrculo ser un hijo de CPunto.

Clase CCrculo viene-de CPunto
Atributos
Radio
Mtodos
Constructor(NuevoX, NuevoY, NuevoRadio)
Mostrar
Ocultar
Expandir
MoverHacia
Contraer
fclase
Mtodo CCrculo.Constructor(NuevoX, NuevoY, NuevoRadio)
Heredado Constructor(NuevoX, NuevoY)
Radio <-- NuevoRadio
fmtodo
Mtodo CCrculo.Mostrar
Visible <-- Verdadero
DibujarCrculo(X, Y, Radio, ObtenerColorPrimerPlano) //
Dibuja un crculo en la pantalla (blanco sobre negro)
fmtodo
Mtodo CCrculo.Ocultar
Visible <-- Falso
DibujarCrculo(X, Y, Radio, ObtenerColorFondo)
Dibuja un crculo en la pantalla (negro sobre negro)
fmtodo

//

Mtodo CPunto.MoverHacia(QueX, QueY)

Ocultar
X <-- QueX
Y <-- QueY
Mostrar
fmtodo
Mtodo CCrculo.Expandir(FactorExpansin)
Ocultar
Radio Radio + FactorExpansin
Mostrar
fmtodo
Mtodo CCrculo.Contraer(FactorContraccin)
Expandir(-FactorContraccin)
fmtodo
Mtodo CCrculo.MoverHacia(QueX, QueY)
Ocultar
X <-- QueX
Y <-- QueY
Mostrar
fmtodo

Este sencillo ejemplo nos muestra la simulacin de una pequea (muy pequea)
conversacin entre dos objetos de la Clase CPersona.
Clase CSegmento
Atributos
Lugar
nuSegmento
Mtodos
Constructor(NuevoSegmento, NuevoLugar)
ImprimirEncabezado
Accin
ImprimirCorte

Pag. 43

fclase
Mtodo CSegmento.Constructor(NuevoNmero, NuevoLugar)
Lugar <-- NuevoLugar
nuSegmento <-- NuevoSegmento
fmtodo
Mtodo CSegmento.ImprimirEncabezado
LneaTexto <-- Segmento # + nuSegmento +
+ Lugar
Escribir(LneaTexto)
fmtodo
Mtodo CSegmento.Accin
fmtodo
Mtodo CSegmento.ImprimirCorte
Escribir(------------------)
fmtodo
Clase CPersona
Atributos
nmPersona
// Nombre de persona
LneaEtiqueta
Mtodos
Constructor(NuevoNombre, NuevaLnea)
ColocarLneaEtiqueta(QueLnea)
ObtenerLneaEtiqueta -->
Decir(Lnea)
fclase
Mtodo CPersona.Constructor(NuevoNombre, NuevaLnea)
nmPersona <-- NuevoNombre
LneaEtiqueta <-- NuevaLnea
fmtodo
Mtodo CPersona.ObtenerLneaEtiqueta
Retornar LneaEtiqueta
fmtodo
Mtodo CPersona.ColocarLneaEtiqueta(QueLnea)
LneaEtiqueta <-- QueLnea
fmtodo
Mtodo CPersona.Decir(Lnea)
LneaTexto <-- nmPersona + : + Lnea +
Escribir(LneaTexto)
fmtodo
Clase CDilogo viene-de CSegmento
Atributos
Objeto PersonaA ejemplar-de CPersona
Objeto PersonaB ejemplar-de CPersona
Mtodos
Constructor(NuevoNmero, NuevaLnea,
nmActor1, nmActor2)
Accin
Saludos
Conversar
Despedirse
fclase
Mtodo CPersona.Constructor(NuevoNmero, NuevoLugar, nmActor1,
nmActor2)
Heredado Constructor(NuevoNmero, NuevoLugar)
PersonaA.Constructor(nmActor1, )
PersonaB.Constructor(nmActor2, )
fmtodo
Mtodo CDilogo.Accin

Pag. 44

Agradecimientos
Conversar
Despedirse
fmtodo
Mtodo CDilogo.Saludos
PersonaA.Decir(Hola)
PersonaB.Decir(Que tal)
PersonaA.ColocarLneaEtiqueta(Si que hace calor)
PersonaB.ColocarLneaEtiqueta(Y que lo digas)
fmtodo
Mtodo CDilogo.Conversar
PersonaA.Decir(PersonaA.ObtenerLneaEtiqueta)
PersonaB.Decir(PersonaB.ObtenerLneaEtiqueta)
fmtodo
Mtodo CDilogo.Despedirse
PersonaA.Decir(Chau)
PersonaB.Decir(Nos vemos)
fmtodo

Pag. 45

Bibliografa

VOSS, Greg (1994); Programacin Orientada a Objetos: Una Introduccin., McGraw

Hill, Mxico. Orig. Object-Oriented Programming: An Introduction.

BUDD, Timothy (1994); Introduccin a la Programacin Orientada a Objetos. Addison

Wesley Iberoamericana. Wilmington, Delaware.

GALLARDO OTERO, Manuel - PREZ CABREL, Teodomiro (1995); Estructura de

Datos: Un enfoque Algortmico. Lima. Universidad Nacional Mayor de San
Marcos - Facultad de Ciencias Matemticas, Escuela Acadmico Profesional de
Computacin.

HEKMATPOUR, Sharam (1992); C++ : Gua para Programadores en C. Mxico.

Prentice Hall Inc.

WEISKAMP, Keith - HEINY, Loren - FLAMING, Bryan (1993); Programacin Orientada

a Objetos con Turbo C++. Mxico. Editorial Limusa S.A. de C.V. Grupo Noriega
Editores.

RUBENKING, Neil (1995); Delphi Programming Problem Solver. IDG Books Worldwide
Inc. ISBN 1-56884-795-5.

Pag. 46

Sugerencias para la escritura de

Pseudocdigo
Indentacin
Para facilitar la comprensin, lectura y revisin del pseudo-cdigo, se cre el concepto
de indentacin en la escritura de los mismos. Esta consiste en el desplazamiento hacia
la derecha de un subconjunto de la secuencia de acciones. Aunque los bloques estn
denotados por palabras subrayadas, (Si..fsi, etc.). Es recomendable desplazar dos o
tres posiciones el bloque para facilitar la comprensin del flujo lgico.

Idioma de Trabajo
La nomenclatura de identificadores de variables, acciones, funciones, estructuras, etc.,
debe estar regida por un idioma nico para lograr la uniformidad en el pseudo-cdigo.
Esto produce una sensacin de armona y ayuda a la fcil comprensin del mismo.
Algunos autores utilizan el idioma ingls porque les brinda mayor versatilidad en la
nomenclatura (una expresin en espaol puede significar una sola palabra en ingls) o
armona con el lenguaje de programacin en que implementarn el pseudo-cdigo.
Otros prefieren el espaol por comodidad y para lograr una mayor claridad y
comprensin por parte del lector. Para elegir el idioma de nomenclatura debe tenerse
en cuenta la comodidad personal, el grado de difusin del pseudo-cdigo (en el caso de
trabajo en grupo o para presentarlo a terceros) y la fluidez que poseemos sobre un
idioma. Esta ltima nos permitir utilizar el trmino exacto que ayude a captar el
significado del valor, accin o funcin.

Notacin de Identificadores
Los identificadores son cadenas de texto que permiten hacer referencia a valores
determinados. Muchas veces, por falta de costumbre o por "rapidez", no aprovechamos
las propiedades informativas de los identificadores. El nombre de una variable nos
puede dar informacin sobre el significado del valor al que referencia (nombre de una
persona, contador, acumulador de totales, etc.), el tipo de valor (numrico, cadena de
caracteres, estructura, etc.) o la categora de valor (posibles estados civiles por
ejemplo).

Uso de maysculas y minsculas en Identificadores

El uso de maysculas y minsculas nos brinda un mayor rango de posibilidades en la
notacin y adems incrementa la legibilidad del identificador. Es mas claro escribir
ClaseDeDato
que
CLASEDEDATO,
u
ObtenerCodigoDeFactura
que
OBTENERCODIGODEFACTURA.

Notacin Hngara
Un tipo de notacin muy conocida en el ambiente informtico es el de la notacin
hngara, en el cual una letra denota el tipo de valor con que trabaja la variable, as:

Pag. 47

Prefijo
b
n
a
ch
c
p
S
m_

Descripcin
Valor booleano
Valor numrico
Arreglo o Matriz
Carcter
Cadena de caracteres
Apuntador
Estructura
Miembro de la Estructura
Tabla .14. Ejemplo de uso de Prefijos.

Ejemplo
bEsCasado
nEdad
aAlumnos
chRespuesta
cNombre
pNodo
SPersona
m_cNombre

Notacin de Constantes
Para la notacin de constantes, es decir identificadores asociados a valores que no
cambian en el tiempo, existen la notacin de prefijos, que consiste en la utilizacin de
uno o dos caracteres que se anteponen al identificador e indican el tipo de valor (con
respecto al significado) asociado. Por ejemplo:
Prefijo
ec
ev
cm

Descripcin
Ejemplo
Tipo de Estado Civil
ecSoltero, ecCasado, ...
Evento de interfaz
evRatn, evTeclado, ...
Comando de Aplicacin
cmSalir, cmAbrir, ...
Tabla .15. Ejemplos de Prefijos en Constantes.

La eficiencia de la notacin de prefijo depende la habilidad para encontrar siglas que

sinteticen el tipo de valor.

Pag. 48