Capitulo6 funcproced

LABORATORIO II - AÑO 2008
I N D I C E D E C O N T E N I D O S
CC AA PP II TT UU LL OO VV II
VI. FUNDAMENTOS DE PROGRAMACIÓN ..................................195
VI.1. Los lenguajes de programación............................................195
VI.2. Creación de programas ejecutables......................................196
VI.3. La Ayuda (Help)..................................................................197
VI.4. Modularización...................................................................198
VI.5. Subrutinas..........................................................................199
VI.5.i. Subrutinas mediante etiquetas .......................................199
VI.6. Procedimientos y Funciones................................................200
VI.6.i. Procedimientos Generales .............................................201
VI.6.ii. Llamar a Procedimientos Sub.........................................201
VI.6.iii. Salir del procedimiento Sub.........................................203
VI.6.iv. Procedimiento Function.................................................203
VI.6.iv.1. Valores devueltos........................................................205
VI.6.v. Llamar a procedimientos Function .................................206
VI.6.v.1. Función o Procedimiento recursivo .............................207
VI.7. Argumentos y parámetros ...................................................207
VI.7.i. Definir un parámetro para un procedimiento..................209
VI.7.ii. Pasar argumentos a un procedimiento............................211
VI.8. Pasar por valor o por referencia .........................................212
VI.8.i. Pasar argumentos por valor: ByVal ................................212
VI.8.ii. Pasar argumentos por referencia: ByRef........................213
VI.9. Ejercicios Resueltos............................................................214
VI.10. Módulos en Formularios ................................................217
VI.11. Agregar un módulo a un proyecto...................................218
VI.11.i. Iniciar un programa......................................................218
VI.12. Alcance del Código.........................................................219
VI.13. Ejercicio propuesto .......................................................220

CAPITULO VI: FUNDAMENTOS DE PROGRAMACIÓN Mg. Ing. Fátima Martínez
Página 194

PROGRAMADOR UNIVERSITARIO
LABORATORIO II - VISUAL BASIC
AÑO 2008
CAPITULO VI
Página 195
Mg. Ing. Fátima Martínez
VI. FUNDAMENTOS DE PROGRAMACIÓN
Según el sentido informático un programa (García de Jalón, J. y otros; 1999:24)
está constituido por algoritmos que son sentencias que operan sobre datos
contenidos en las variables. Estos datos y algoritmos están incluidos dentro
de funciones o procedimientos.
VI.1. Los lenguajes de programación
Los lenguajes de programación son herramientas que nos permiten crear programas
y software. Una computadora funciona bajo control de un programa.
Un lenguaje de programación es un lenguaje que puede ser utilizado para controlar
nel comportamiento de una máquina, particularmente una computadora. Consiste
en un conjunto de reglas sintácticas y semánticas que definen su estructura y el
significado de sus elementos, respectivamente (Wikipedia).
Los procesadores usados en las computadoras son capaces de entender y actuar
según lo indican programas escritos en un lenguaje llamado lenguaje de máquina.
Todo programa escrito en otro lenguaje puede ser ejecutado de dos maneras:
• Mediante un programa que va adaptando las instrucciones conforme son
encontradas. A este proceso se lo llama interpretar y a los programas que lo
hacen se los conoce como intérpretes.
• Traduciendo este programa al programa equivalente escrito en lenguaje de
máquina. A ese proceso se lo llama compilar y al traductor se lo conoce como
compilador.
Mientas se compila se verifican errores. Si hay un error se interrumpe. El
compilador revisa los errores de sintaxis al presionar [ENTER]; los errores
de semántica los detecta en el momento de ejecución.
Al usar un lenguaje compilado (como lo son los lenguajes del popular Visual Studio
de Microsoft), el programa desarrollado nunca se ejecuta mientras haya errores,
sino hasta que luego de haber compilado el programa, ya no aparecen errores en el
código.

Página 196
El compilador por excelencia es Microsoft Visual Basic que a su vez es un IDE para
el lenguaje, entorno de trabajo que integra funciones de: diseño, edición,
compilación y depuración de proyectos mediante la interfaz gráfica.
VI.2. Creación de programas ejecutables
Una vez finalizada la programación de una aplicación, se puede crear un programa
ejecutable para su distribución e instalación en distintas computadoras, inclusive en
las que no este instalado Visual Basic 6.0.
Cuando se crea un programa ejecutable se genera un archivo cuya extensión será
(.EXE). Para que este programa funcione solamente se necesita que el fichero
MSVBVM60.DLL esté instalado en el directorio de C:Windows System o
C:WinNT System32.
En el caso de proyectos más complejos en los que se utilicen muchos controles
pueden ser necesarios más ficheros, la mayoría de ellos con extensiones .ocx, .vbx o
.dll. Para saber en cada caso cuales son los ficheros necesarios, se puede consulta el
fichero .vbp que contiene la descripción completa del proyecto. Casi todos esos
ficheros se instalan automáticamente al instalar el compilador de Visual Basic 6.0
en el ordenador. (Rodríguez Bucarelly, C. M.; 2004:24)
Para crear un archivo ejecutable en Visual Basic, el proceso es sencillo:
1. En el menú Archivo, ejecute Generar <NombreProyecto>.exe…
2. Ingrese el nombre para el archivo ejecutable.
3. Para añadir información específica de versión:
En la ficha Generar del cuadro de diálogo Propiedades del Proyecto escriba los
números de versión y el texto de información de la versión, y luego haga clic en
[Aceptar].
Además del archivo ejecutable, se debe de proporcionar diversas DLL's y otros
archivos a los usuarios. Se debería crear un programa de instalación que instale la
aplicación en la computadora del usuario. (Matta González, D. A.; 2003:73)

AÑO 2008
CAPITULO VI
Página 197
VI.3. La Ayuda (Help)
Como la mayoría de las aplicaciones de Microsoft, Visual Basic 6.0 dispone de un
Help excelente a través de una interfaz de usuario similar a la de Internet Explorer.
Desde un control, una propiedad o un formulario, o una palabra clave seleccionada
en la ventana de código, se puede utilizar la Ayuda pulsando la tecla [F1]. Otra
manera es mediante las opciones del menú Ayuda.

Página 198
En caso de requerir ayuda sobre un determinado tipo de control, se puede acceder
también a todos y cada uno de sus propiedades, eventos y métodos con las opciones
Propiedades, Métodos y Eventos, respectivamente.
VI.4. Modularización
A medida que los programas se van desarrollando y aumentan de tamaño, se
convertirían rápidamente en sistemas poco manejables si no fuera por la
modularización (Tecuapacho Cosetl, I; 2006).
La modularización es un proceso que consiste en dividir un programa muy grande
en una serie de módulos mucho más pequeños y manejables.
A estos módulos se les suele denominar de distintas formas (subprogramas,
subrutinas, procedimientos, funciones, etc.) según los distintos lenguajes. Pero la
idea es siempre la misma: dividir un programa grande en un conjunto de
subprogramas o funciones más pequeñas que son llamadas por el programa
principal; éstas a su vez llaman a otras funciones más específicas y así
sucesivamente .
Entre otras, las principales ventajas que representa la división de un programa en
unidades más pequeñas o funciones son las siguientes:
1. Modularización. Cada función tiene una misión muy concreta, de modo que
nunca tiene un número de líneas excesivo y siempre se mantiene dentro de
un tamaño manejable. Puede ser desarrollada y comprobada por separado y
además, la misma función puede ser llamada muchas veces en el mismo
programa e incluso puede ser reutilizada por otros programas.
2. Ahorro de memoria y tiempo de desarrollo. En la medida en que una misma
función es utilizada muchas veces, el número total de líneas de código del
programa disminuye y también lo hace la probabilidad de introducir errores
en el programa.
3. Independencia de datos y ocultamiento de información. Una de las fuentes
más comunes de errores en los programas son los efectos colaterales o
alteraciones que se pueden producir entre distintas partes del programa. Es
muy frecuente que al hacer una modificación para añadir una funcionalidad
o corregir un error, se introduzcan nuevos errores en partes del programa
que antes funcionaban correctamente. Una función es capaz de mantener
una gran independencia con el resto del programa, manteniendo sus propios
datos y definiendo muy claramente la interfaz o comunicación con la función
que la ha llamado y con las funciones a las que llama, y no teniendo ninguna
posibilidad de acceso a la información que no le compete.

AÑO 2008
CAPITULO VI
Página 199
VI.5. Subrutinas
La técnica de modularización se usa mucho en programación. Suele llamarse a esta
técnica, diseño descendente, metodología del divide y vencerás o programación top-
down. Según la técnica en lugar de resolver una tarea compleja y tediosa se
resuelven otras más sencillas y a partir de ellas se llega a la solución. Para ello las
subrutinas son ideales.
Subrutina, porción del código dentro de un programa más grande que
ejecuta una determinada tarea. Se encarga de resolver un problema
específico. Tienen un nombre para identificarlas y luego poder llamarlas
para ser utilizadas.
Pueden ser una porción de código identificada por una etiqueta, un
procedimiento o una función.
Tienen un principio y un fin y según el alcance pueden ser de tipo
privadas o públicas.
VI.5.i. Subrutinas mediante etiquetas
La sentencia GoTo permite saltar la ejecución de un programa hacia una línea
específica que, por medio de una etiqueta, agrupa varias sentencias (Birnios, B. y
Birnios, M.; 2003: 249).
Ejemplo de
sentencia
GOTO
Numero = 1
If Numero = 1 then
GoTo rutina1
Else
GoTo rutina2
End if
Rutina1:
Dia = “Lunes”
Return
Runtina2:
Dia = “Otro día”
Return
En lugar de GoTo se usan ciclos, procedimientos y funciones.
Nota: conviene evitar el uso de la sentencia GoTo. Es una mala costumbre
que lleva a escribir un código desordenado, sin control. Su empleo se
justifica sólo para la captura y manejo de errores.

Página 200
VI.6. Procedimientos y Funciones
En Visual Basic 6.0 se distingue entre funciones y procedimientos Sub. La
diferencia fundamental entre un procedimiento Sub y una función es que ésta
última retorna un valor al programa que la invoca, por lo tanto puede ser utilizada
en una expresión, no así los procedimientos que no devuelven ningún valor. El valor
de retorno ocupa el lugar de la llamada a la función donde esta aparece
Un procedimiento Sub es un segmento de código independiente del resto, que una
vez llamado por el programa, ejecuta un número determinado de instrucciones, sin
necesidad de devolver ningún valor al mismo (puede dar resultados modificando los
argumentos), mientras que una función siempre tendrá un valor de retorno.
Estos bloques básicos son llamados en forma genérica con la palabra procedimiento.
Resultan muy útiles para condensar las tareas repetitivas o compartidas, como
cálculos utilizados frecuentemente, manipulación de texto y controles, y operaciones
con bases de datos.
Un procedimiento es una especificación de la serie de acciones, los actos o
las operaciones que tienen que ser ejecutados de manera semejante para
obtener siempre el mismo resultado en las mismas circunstancias.
Visual Basic (Matta González, D. A.; 2003: 63) trabaja con dos tipos de
procedimientos: los procedimientos de evento (explicitados en el capítulo anterior) y
los procedimientos generales.
En el siguiente ejemplo se muestra una subrutina creada automáticamente por
Visual Basic al programar en un formulario el evento Click:
Ejemplo de
Procedimiento
de Evento
Cuando en un formulario se inserta un botón de comando
llamado Command1 y desde la ventana de eventos se selecciona
el evento Click del mismo se crea la siguiente subrutina:
Private Sub Command1_Click()
…
End Sub
La palabra Sub le sigue el nombre de la rutina que la identifica, en este caso
Command1_Click(). Private identifica una subrutina o procedimiento de tipo
Privado, esto quiere decir que se la puede utilizar solo en el formulario o módulo
donde está declarada o escrita.
También se pueden crear Procedimientos y Subrutinas propios para ejecutar una
determinada tarea.

AÑO 2008
CAPITULO VI
Página 201
VI.6.i. Procedimientos Generales
Los procedimientos generales son procedimientos Sub o Function que son
creados para que lleven a cabo tareas específicas, estos deben ser invocados de
manera explícita.
Para crear un procedimiento general, se debe abrir la ventana de código y:
• Ejecutar del menú Herramientas → Agregar procedimiento…
• También, escribiendo el encabezado de procedimiento Sub o Function
seguido por el nombre del procedimiento, en una línea en blanco dentro
de la ventana de código y presionando [ENTER]
Una vez que se define un procedimiento general, se le debe llamar
específicamente desde la aplicación. Por el contrario, un procedimiento de evento
permanece inactivo hasta que se le llama para responder a eventos provocados
por el usuario o desencadenados por el sistema.
Para llamar a un procedimiento general puede especificarse cualquiera de las
siguientes maneras:
Sub ProcedimientoBorrar() Function ObtenerCoord()
Visual Basic responde completando la plantilla del nuevo procedimiento.
VI.6.ii.Llamar a Procedimientos Sub
Como se dijo anteriormente, los procedimientos Sub no retornan valores. Cada
vez que se llama al procedimiento se ejecutan las instrucciones que hay entre
Sub y End Sub.
Hay dos formas de llamar a un procedimiento Sub. Una de ellas es escribiendo el
nombre del procedimiento en el lugar donde queremos que se ejecute.
Ejemplo de
Procedimiento
General
Un procedimiento muy simple que tiene la función específica
de borrar el contenido de 3 controles Label:
Private Sub ProcedimientoBorrar()
label1 = ""
abel2 = ""
label3 = ""
End Sub
Nota: Si se tiene código duplicado en varios procedimientos de evento,
conviene colocar el código en un procedimiento general y luego invocar a
éste desde los procedimientos de evento.

Página 202
Ejemplo de
llamar a un
Procedimiento
Supongamos el ejemplo anterior en el que tenemos un formulario
con 3 controles Label (label1, label2 y label3). Si queremos llamar
a ese procedimiento que borrará el contenido de los Label al
hacer click en el Command1, lo haríamos así:
ProcedimientoBorrar
End Sub
Al presionar el Command1, VB detecta el nombre ProcedimientoBorrar, y
automáticamente salta al lugar donde se ha creado el procedimiento y
ejecuta las líneas de código que encuentre en ese procedimiento.
Otra manera para llamar a un procedimiento es emplear la instrucción
Call con el nombre del procedimiento, quiere decir llamar, pero en este
caso si se utiliza Call y el procedimiento contiene parámetros (se verá más
adelante), éstos deberán ser pasados entre paréntesis.
Ejemplo de
llamar a un
Procedimiento
con Call
Public Sub Seleccionar(Cuadro As TextBox)
Cuadro.SelStart = 0
Cuadro.SelLength = Len(Cuadro.Text)
End Sub
Si queremos llamar a éste procedimiento que seleccionará el
contenido de un TextBox al hacer click en el Command1, lo
haríamos así:
Call Seleccionar(objeto)
End Sub
Si se omite Call, se omiten también los paréntesis alrededor de la lista de
argumentos. En el ejemplo anterior sería: Seleccionar objeto
La principal ventaja de crear procedimientos de código es que evita
tener que escribir varias veces las mismas instrucciones en un
programa, el código se hace mucho mas funcional y entendible, se
pueden dividir un problema (una rutina), en varios procedimientos y
probarlos independientemente, y además la posibilidad de enviar
parámetros a los procedimientos.

AÑO 2008
CAPITULO VI
Página 203
VI.6.iii. Salir del procedimiento Sub
Todos los procedimientos terminan cuando aparece la palabra clave End Sub
Una vez que se ha terminado de ejecutar las instrucciones que estén dentro del
bloque del procedimiento, vuelve a la línea siguiente de donde fue llamado el
mismo, y ejecuta todas las líneas restantes de código. En el ejemplo anterior no
ejecutaría nada más por que no hay ninguna otra instrucción debajo de
Seleccionar.
Muchas veces resulta necesario salir antes de un procedimiento, por ejemplo al
cumplirse una condición. Para ello se puede utilizar la sentencia Exit Sub. Con
lo cual se logra que los procedimientos terminen en el mismo punto, pero no por
ello se debe abusar de su uso.
Ejemplo del
uso de EXIT
SUB
Sub Dividir (Operador As Integer, Operador2 As
Integer)
Dim Resultado As Integer
If Operador2 <= 0 then
Exit Sub
End if
Resultado = Operador1/Operador2
End Sub
VI.6.iv. Procedimiento Function
Un procedimiento Function consiste en una serie de instrucciones de Visual
Basic delimitadas por las instrucciones Function y End Function. El
procedimiento Function realiza una tarea y a continuación, devuelve el control
al código de llamada. Cuando devuelve el control, también devuelve un valor al
código de llamada.
Cada vez que se llama a un procedimiento, se ejecutan las instrucciones de éste,
desde la primera instrucción ejecutable tras la instrucción Function hasta la
primera instrucción End Function, Exit Function o Return que se encuentre.
Un procedimiento Function puede aceptar argumentos, como constantes,
variables o expresiones, que le pasa el código de llamada.
La sintaxis correspondiente a una función es la siguiente:
[Static] [Private] Function nombre ([parámetros]) [As tipo]
[sentencias]
[nombre = expresion]
[Exit Function]
[sentencias]
[nombre = expresion]

Página 204
End Function
Donde:
• nombre es el nombre de la función.
• Para especificar el tipo se utiliza la cláusula As Tipo (Integer, Long,
Single, Double, Currency, String o Variant). Será de un tipo u otro
dependiendo del dato que devuelva.
• Parámetros: son los argumentos que son pasados cuando se llama a la
función. Visual Basic asigna el valor de cada argumento en la llamada al
parámetro que ocupa su misma posición. Si no se indica un tipo
determinado los argumentos son Variant por defecto. Los argumentos
pueden ser pasados por referencia o por valor (se verá más adelante).
• El nombre de la función, su valor de retorno, actúa como una variable
dentro del cuerpo de la función. El valor de la variable expresión es
almacenado en el propio nombre de la función. Si no se efectúa esta
asignación, el resultado devuelto será 0 si la función es numérica, nulo
("") si la función es de caracteres, o Empty si la función es Variant.
• Exit Function permite salir de una función antes de que ésta finalice y
devolver así el control del programa a la sentencia inmediatamente a
continuación de la que efectuó la llamada a la función.
• End Function marca el final del código de la función, al igual que la Exit
Function, devuelve el control del programa a la sentencia siguiente a la
que efectuó la llamada, pero lógicamente una vez finalizada la función.
Ejemplo
de
Function
En este ejemplo, el procedimiento Function del tipo Integer recibe un
número y devuelve ese número al cuadrado.
Public Function Cuadrado(N As Integer) As Integer
Cuadrado = N * N
End Function
Al final de la declaración de la función Cuadrado y después de la lista de los
parámetros dice As Integer, esto es por que las funciones retornan o devuelven
un valor. En este caso la función es de tipo Integer o mejor dicho devolverá un
valor de tipo Integer y luego ese valor devuelto se lo puede utilizar en otra parte
del programa.
Las Funciones pueden retornar casi cualquier tipo de datos, como números,
cadenas, fechas, arreglos, vectores.

AÑO 2008
CAPITULO VI
Página 205
VI.6.iv.1. Valores devueltos
El valor que un procedimiento Function devuelve al código de llamada se
denomina valor devuelto. El procedimiento devuelve dicho valor de dos
maneras:
1. La función asigna un valor a su propio nombre de función en una o
más instrucciones del procedimiento. El control no vuelve al
programa de llamada hasta que se ejecuta una instrucción Exit
Function o End Function. Esto se ilustra en el siguiente ejemplo:
Ejemplo
de valor
devuelto
La siguiente función acepta un cadena de caracteres y un entero y
devuelve una cadena de caracteres:
Function QuéComer (DíaSemana As String, Hora As
Integer) As String
'Devuelve el menú del almuerzo basándose en el día
y la hora.
If DíaSemana = "Viernes" then
QuéComer = "Pescado"
Else
QuéComer = "Pollo"
End If
If Hora > 4 Then QuéComer = "Demasiado tarde"
End Function
2. Utiliza la instrucción Return para especificar el valor devuelto y
devuelve el control inmediatamente al programa de llamada. Esto
se ilustra en el siguiente ejemplo:
Ejemplo
de
Return
Function QuéComer (DíaSemana As String, Hora As
Integer) As String
'Devuelve el menú del almuerzo basándose en el día
y la hora.
If DíaSemana = "Viernes" then
Return "Pescado"
Else
Return "Pollo"
End If
If Hora > 4 Then Return "Demasiado tarde"
End Function
La ventaja de asignar el valor devuelto al nombre de la función es que el
control permanece en el procedimiento hasta que encuentra una
instrucción Exit Function o End Function, lo que permite asignar un

Página 206
valor previo y si es necesario, ajustarlo después.
VI.6.v. Llamar a procedimientos Function
La llamada a una función se hace de diversas formas. Normalmente se llama a
un procedimiento Function utilizando su nombre en una expresión de la misma
forma en que se llama a una función intrínseca de Visual Basic.
variable = nombre([argumentos])
Donde:
• argumentos son un lista de constantes, variables o expresiones separadas
por comas que se pasan a la función. En principio, el número de
argumentos debe ser igual al número de parámetros de la función. Los
tipos de los argumentos deben coincidir con los tipos de sus
correspondientes parámetros, de lo contrario puede haber fallos
importantes en la ejecución del programa. Esta regla no rige si los
argumentos se pasan por valor (concepto que se verá más adelante).
En cada llamada a una función hay que incluir los paréntesis, aunque ésta no
tenga argumentos.
Ejemplos:
Llamar una
Función
El siguiente ejemplo corresponde a una función que devuelve como
resultado la raíz cuadrada de un número N:
Function Raiz (N As Double) As Double
If N < 0 Then
Exit Function
Else
Raiz = Sqr(N)
End Function
La llamada a esta función se hace de la forma siguiente:
Cuadrada = Raiz(Num)
Las instrucciones siguientes llaman a la función Raiz:
Print 10 * Raiz(numero)
X = Raiz(numero)
If Raiz(numero) <= 1 Then Debug.Print "Fuera del
intervalo"
X = OtraFunción(10 * Raiz(A))
También es posible llamar a una función igual que se llama a un procedimiento
Sub.
Las instrucciones siguientes llaman a la función Cuadrado (ejemplo):

AÑO 2008
CAPITULO VI
Página 207
Ejemplos:
Llamar una
Función
• Si se desea guardar el valor devuelto, se usan paréntesis cuando
se invoque a la función:
Call Cuadrado(5) o Resultado = Cuadrado (5)
Si se omiten los paréntesis, se puede ignorar el valor devuelto y
no guardarlo en una variable. Esto puede ser útil si se quiere
ejecutar una función y no se desea el valor devuelto. Por ejemplo:
Cuadrado 5
A diferencia de C y C++ en Visual Basic 6.0 no es necesario devolver
explícitamente el valor de retorno, pues el nombre de la función ya
contiene el valor que se desea devolver. Tampoco es necesario
declarar las funciones antes de llamarlas.
Al finalizar cada función, se devuelve el control del programa a la
sentencia posterior a la que la invocó.
VI.6.v.1. Función o Procedimiento recursivo
Se dice que una función o que un procedimiento Sub es recursivo es si se
llaman a sí mismo.
Ejemplo: de
una
Función
recursiva
La siguiente función calcula el factorial de un número programada de
forma recursiva:
Function Factorial (N As Integer) As Long
If N = 0 Then
Factorial = 1 'Condición de final
Else
Factorial = N * Factorial (N - 1)
End If
End Function
Si la variable N que se le pasa a la función vale 0, se ha llegado al final
del proceso, y por tanto se le asigna el valor 1 al valor del factorial
(recordar que 0! = 1). Caso contrario, si es distinto de 0, la función se
llama a ella misma, pero variando el argumento a (N-1), hasta llegar al
punto en el que N -1 =0, finalizándose el proceso.
VI.7. Argumentos y parámetros
En cualquier programa siempre es necesario hacer cálculos, usar información,
procesarla y mostrarla. En la mayoría de los casos, se necesita un lugar temporal en
el cual guardar parte o toda esa información. Los lenguajes de programación
permiten guardar datos en la memoria, para más tarde usarlos (tomarlos,

Página 208
modificarlos y volverlos a guardar). Esas posiciones o lugares de la memoria donde
los programas pueden almacenar información son las variables.
En la mayoría de los casos, un procedimiento necesita cierta información sobre las
circunstancias en las que se le ha llamado. Un procedimiento que ejecuta tareas
repetidas o compartidas utiliza datos distintos en cada llamada. Estos datos se
componen de variables, constantes y expresiones que se transfieren al
procedimiento cada vez que se le llama. Para comunicar esta información al
procedimiento, el procedimiento define un parámetro, y el código de llamada
transfiere un argumento a dicho parámetro.
Un parámetro representa un valor que el procedimiento espera que se
transfiera cuando es llamado. La declaración del procedimiento define
sus parámetros.
Los parámetros se utilizan en los procedimientos para que el procedimiento no
ejecute siempre las mismas líneas de código y pueda variar, teniendo la posibilidad
de hacerlo más dinámicamente.
Cuando se define un procedimiento Function o Sub, se especifica una lista de
parámetros entre paréntesis que va inmediatamente después del nombre de
procedimiento. Para cada parámetro, se especifica un nombre, un tipo de datos y un
mecanismo para pasar argumentos (ByVal o ByRef). También se puede indicar que
un parámetro es opcional, lo que significa que el código de llamada no tiene que
transferirle un valor.
El nombre de cada parámetro actúa como una variable local dentro del
procedimiento. Esto significa que su período de duración es igual al del
procedimiento y su ámbito es el procedimiento completo.
El nombre del parámetro se utiliza del mismo modo que cualquier otra
variable.
Cuando se pasa una variable a un procedimiento, se llama argumento, representa el
valor que se transfiere a un parámetro del procedimiento. El código de llamada
proporciona los argumentos cuando llama al procedimiento.
Cuando se llama al procedimiento Function o Sub, se incluye una lista de
argumentos entre paréntesis que van inmediatamente después del nombre del
procedimiento. Cada argumento se corresponde con el parámetro situado en la
misma posición de la lista.
A diferencia de la definición de parámetros, los argumentos no tienen nombres.
Cada argumento es una expresión que puede contener cero o más
variables, constantes y literales. El tipo de datos de la expresión
evaluada normalmente debe coincidir con el tipo de datos definido para

AÑO 2008
CAPITULO VI
Página 209
el parámetro correspondiente, y en algún caso, debe poder convertirse
al tipo del parámetro.
VI.7.i. Definir un parámetro para un procedimiento
Los parámetros de un procedimiento se declaran igual que las variables,
especificando el nombre y el tipo de datos. Los parámetros de los procedimientos
tienen, de forma predeterminada, el tipo de dato Variant, con este tipo se puede
asignar a una variable cualquier tipo de dato, desde un número hasta una
cadena de caracteres. Sin embargo, puede declarar otros tipos de datos para los
parámetros.
También puede especificarse el mecanismo para pasar argumentos y si se trata
de un parámetro opcional.
Para definir un parámetro de procedimiento:
1. En la declaración del procedimiento, se agrega el nombre de parámetro a la lista
de parámetros del procedimiento, separándolo de otros parámetros mediante comas.
2. Se inserta una cláusula As después del nombre de parámetro para especificar el tipo
de datos.
3. Normalmente los parámetros se transfieren por valor, a menos que se desee que el
procedimiento pueda cambiar su valor en el código de llamada. Para ello se antepone
ByVal o ByRef al nombre del parámetro para especificar el mecanismo para pasar
argumentos (por valor o referencia).
4. Si el parámetro es opcional se antepone Optional al mecanismo para pasar
argumentos y detrás del tipo de datos del parámetro, se incluye un signo igual (=) y
un valor predeterminado.
En el ejemplo siguiente se define el esquema de un procedimiento Sub con tres
parámetros.
Ejemplo:
parámetros
Las declaraciones de parámetros están separadas, en la lista de
parámetros, mediante comas. El primer parámetro es un dato de tipo
String, el segundo un número entero y el tercero también un String.
Private Sub DatosPersonales(nombre As String, edad
As Integer, ciudad As String)
Label1 = nombre
Label2 = edad
Label3 = ciudad
End Sub
Ahora en el evento Click de un Command1 se llama al procedimiento
pasando los argumentos. El primer dato, como también el último, es
un string por ende debe ir entre comillas.
DatosPersonales “Luciano”, 25, “La Plata”

Página 210
End Sub
Al presionar el botón de comando se llamará al procedimiento DatosPersonales
que se había creado anteriormente y le pasará los valores de los argumentos en
el orden en que estén declarados los parámetros en el procedimiento. Esto quiere
decir que el primer parámetro con el valor "Luciano" se almacenará o asignará a
la variable nombre, el valor 25 se le asignará a la variable edad y el último valor
a la variable ciudad.
Después que las variables ya cargaron el valor se las puede utilizar dentro del
procedimiento, como en el ejemplo anterior que se le asigna a un control Label1
el contenido de la variable nombre, al Label2 el contenido de edad y al Label3 el
contenido de la variable ciudad.
Es muy importante respetar el orden en que pasamos los parámetros en un
procedimiento, por que por ejemplo en el caso anterior si hubiésemos pasado los
parámetros de esta forma:
DatosPersonales 25, “Luciano”, “La Plata”
El segundo parámetro "Luciano" se almacenaría en la variable edad que es de
tipo Integer y se produciría un error en tiempo de ejecución por no coincidir los
tipos de datos, ya que la variable espera un valor numérico de tipo Integer y se
le pasa una cadena de caracteres, un dato de tipo String.
Otro punto importante es que al crear un procedimiento que va a recibir 3
parámetros, cuando se lo llama, no se puede enviar 1 parámetro o 2.
Obligatoriamente hay que pasarle los 3 parámetros que se ha declarado en el
mismo. Un ejemplo que daría un error en tiempo de ejecución por no pasar
adecuadamente los parámetros sería:
DatosPersonales “Luciano”, 25
Esto daría un error de compilación por que el
procedimiento espera recibir 3 parámetros y le
estamos pasando o enviando 2 de ellos.
El mensaje de error que muestra VB sería el
siguiente:
Hay una sentencia llamada Optional que sí permite pasar parámetros de
forma opcional.
La sintaxis de los parámetros de una lista de parámetros es la siguiente:
[Optional] [ByVal | ByRef] nombreparametro As tipo_dato

AÑO 2008
CAPITULO VI
Página 211
Si el parámetro es opcional, debe proporcionar también un valor predeterminado
como parte de su declaración. La sintaxis para especificar un valor
predeterminado es la siguiente:
Optional [ByVal | ByRef] nombreparametro As tipo_dato = valor
Ejemplo de
Optional
Private Sub Con_Parametro_Opcional(Nombre As_
String, Optional Email As String)
MsgBox Nombre
MsgBox Nombre
End Function
Si se llama a la subrutina anterior y se omite el parámetro Email, no dará error,
por ejemplo: Call Con_Parametro_Opcional("Maria")
Los parámetros opcionales, si o si deben estar declarados al final de la
lista de parámetros.
Por ejemplo esto no se puede declarar:
Private sub una_Rutina ( Optional Email As String, Nombre as String )
VI.7.ii.Pasar argumentos a un procedimiento
Al llamar a un procedimiento, se agrega detrás del nombre de procedimiento
una lista de argumentos entre paréntesis. Se proporciona un argumento
correspondiente a cada parámetro necesario que el procedimiento define y
opcionalmente, se pueden proporcionar argumentos para los parámetros
Optional. Cuando no se proporciona un parámetro Optional en la llamada, se
debe incluir una coma para marcar su lugar en la lista de argumentos si se
indica algún argumento posterior.
Para pasar uno o varios argumentos a un procedimiento:
1. En la instrucción de llamada, se agrega paréntesis detrás del nombre de
procedimiento.
2. Se coloca una lista de argumentos entre los paréntesis. Hay que incluir un
argumento para cada parámetro necesario que el procedimiento define; se separan
los argumentos por comas. Cada argumento debe ser una expresión válida que
evalúa el tipo de datos convertible al tipo que el procedimiento define para el
parámetro correspondiente.
3. Si un parámetro está definido como Opcional, VB puede incluirlo en la lista de
argumentos u omitirlo. Si lo omite, el procedimiento utiliza el valor predeterminado
definido para ese parámetro.
4. Si omite un argumento para un parámetro Optional y hay otro parámetro después
de él en la lista de parámetros, se puede marcar el lugar del argumento omitido
mediante una coma adicional en la lista de argumentos.

Página 212
VI.8. Pasar por valor o por referencia
Los valores que se envían como argumento a los procedimientos se pueden pasar
por valor o por referencia.
• Por valor: se envía una copia de la variable, por lo tanto cualquier
cambio realizado en el procedimiento no afecta a la variable original.
Sólo tendrá efecto dentro del procedimiento o función. Una vez que
termine y finalice el mismo, la variable original pasará a valer el dato
que tenía, no se modifica.
• Por referencia: se envía un puntero a la variable original y cualquier
cambio dentro de la rutina afecta la variable original. El cambio
seguirá manteniéndose una vez que finalice la ejecución del
procedimiento o función.
Cuando interesa modificar el valor de un parámetro, por ejemplo para asignarle un
nuevo valor, se puede usar los parámetros por referencia. En Visual Basic se
indican con la instrucción ByRef. En cambio para indicarle que el parámetro es por
valor se usa la instrucción ByVal.
Cuando no se indica a un parámetro de una función o procedimiento ni
ByVal ni ByRef asume que la misma se está enviando como referencia.
VI.8.i. Pasar argumentos por valor: ByVal
Se utiliza la palabra clave ByVal para indicar un argumento pasado por valor.
Indica que un argumento se pasa de tal forma que el procedimiento o la
propiedad a la que se ha llamado no puede cambiar el valor de una variable
subyacente al argumento en el código que realiza la llamada.
Por ejemplo:
Sub Mostrar (ByVal Altura as Integer, Ancho as Integer)
En este ejemplo sólo Altura fue pasada por valor y Ancho por referencia,
cualquier cambio que se realice en esta variable, dentro del procedimiento,
permanecerá al regresar al procedimiento.
Ejemplo de
ByVal
pasaje por
Valor
Private Sub Command1_Click ()
Dim Un_valor As Long
Un_valor = 100
'Se le envía la variable por Valor (ByVal)
Call Sumar(Un_valor)
'Muestra el valor 100, no se modificó en la función
Sumar
MsgBox Un_valor

AÑO 2008
CAPITULO VI
Página 213
End Function
Sub Sumar(ByVal Valor As Long)
'Modifica la variable
Valor = Valor + 100
End Sub
En el ejemplo anterior hay una Sub llamada Sumar que recibe como parámetro
una variable enviada por valor con ByVal (una copia de la variable original ), al
presionar el Commmand1.
Al entrar en la Sub Sumar, el dato se modifica: Valor = Valor + 100. Cuando
finaliza el procedimiento Sumar y retorna a la línea siguiente de la llamada a la
Sub Sumar, muestra mediante un MsgBox el valor de la misma, en este caso es
100 y NO 200 que es el cambio que tuvo dentro del procedimiento Sumar.
Queda demostrado que al enviarla como ByVal, se envía una copia de la variable
original y cualquier cambio que se produzca, será solo en el ámbito del
procedimiento o función.
VI.8.ii.Pasar argumentos por referencia: ByRef
Pasar argumentos por referencia le da al procedimiento acceso al contenido real
de la variable en su ubicación de dirección de memoria. Se puede utilizar la
palabra clave ByRef para especificar que se pasa por referencia,
Indica que un argumento se pasa de tal forma que el procedimiento al que se ha
llamado puede cambiar el valor de una variable subyacente al argumento en el
código que realiza la llamada.
En realidad no hace falta usarlo ya que en VB la forma predeterminada de pasar
valores es por referencia.
Por ejemplo:
Sub Mostrar (ByRef Altura as Integer, Ancho as Integer)
En el ejemplo los dos parámetros se pasan por referencia, salvo que en el
primero se explicita con ByRef.
Ejemplo de
ByRef
pasaje por
Referencia
Private Sub Command1_Click ()
Dim Un_valor As Long
Un_valor = 100
'Se le envía la variable por Referencia (ByRef)
Call Sumar(Un_valor)
'Muestra el valor 200, se modificó en la función
Sumar
MsgBox Un_valor
End Function

Página 214
Sub Sumar(ByRef Valor As Long)
'Modifica la variable
Valor = Valor + 100
End Sub
VI.9. Ejercicios Resueltos
1. Ejercicio
Calcula el nuevo
precio agregando el
IVA
El código del evento Click de Ver Precio
Private Sub cmdVer_Click()
Dim precio As Double, nuevo_prec As Double
precio = CDbl(InputBox("Ingrese el precio para calcular con IVA", "Lista de
precios"))
nuevo_prec = IVA(precio) Llama a la función
MsgBox "El precio con IVA es " & Str(nuevo_prec), , "Calcula Precio"
End Sub
El código de la función IVA
Private Function IVA(x As Double) As Double
'x = x + 100 'se lo modifica, lo afecta porque es por referencia
IVA = x * 1.21
End Function
2. Ejercicio
Función que redondea
un número cantidad de
decimales ingresado.

AÑO 2008
CAPITULO VI
Página 215
El código de la Función Redondear
Option Explicit
Dim Numero As Double
Dim Decimales As Integer
Function RedondearNumero(ByVal Valor As Variant, ByVal Decimales As
Integer) As Double
Dim Numero1 As Double, Numero2 As Double, Numero3 As Double
Dim Numero4 As Double, Frac As Double, n As Byte
n = InStr(txtNum.Text, ".") 'posición en que se encuentra el punto decimal
n = Len(Mid(txtNum.Text, n + 1)) 'longitud de la cadena de los decimales
lblDec.Caption = Str(n)
'Si el dato de decimales es menor que el No. de decimales del número
If Decimales < n Then
Frac = 10 ^ Decimales
Numero1 = Valor * Frac
Numero2 = -1 * Fix(-Frac * Valor)
Numero3 = Numero1 - Numero2
If Numero3 >= 0.5 Then
Numero4 = -1 * Int(-(Numero1))
Else
Numero4 = -1 * Fix(-(Numero1))
End If
RedondearNumero = Numero4 / Frac 'devuelve en el nombre de la función
Else
RedondearNumero = Val(Valor) 'devuelve en el nombre de la función
End If
End Function
El código del evento Change de la caja de texto Decimales
Private Sub txtDec_Change()
If txtDec.Text = "" Then
txtRed = ""
Exit Sub
End If
If IsNumeric(txtDec.Text) Then
Decimales = txtDec.Text
txtRed = RedondearNumero(Numero, Decimales) 'llama a la función
Else
MsgBox "El número debe ser positivo", vbInformation
txtRed.SetFocus
End If
End Sub

Página 216
3. Ejercicio
Suma dos matrices
que son cargadas en
tiempo de ejecución
con números
generados al azar.
Cada matriz está
formada por un
arreglo de TextBox.
El código de la Función Aleatorio
Function Aleatorio() As Integer
Aleatorio = Int(Rnd * 100) + 1
End Function
El código del Procedimiento Suma
Private Sub Suma(objA As TextBox, objB As TextBox, objC As TextBox)
If IsNumeric(objA) Then
objC = Val(objA) + Val(objB)
Else
objC = "#######"
End If
End Sub
El código del Evento Click de los botones de Cargar
Private Sub cmdA_Click()
Dim i As Integer
For i = 0 To txtA.Count - 1
txtA(i).Text = Str(Aleatorio()) 'llama a la función Aleatorio
Next i
End Sub
Private Sub cmdB_Click()
Dim i As Integer
For i = 0 To txtB.Count - 1
txtB(i).Text = Str(Aleatorio()) 'llama a la función Aleatorio
Next i
End Sub
Private Sub Form_Load()
Dim i As Integer
Randomize
For i = 0 To txtA.Count - 1

AÑO 2008
CAPITULO VI
Página 217
txtA(i) = "0"
txtB(i) = "0"
Next i
End Sub
El código del Evento Change de las cajas de texto de las matrices
Private Sub txtA_Change(Index As Integer)
Suma txtA(Index), txtB(Index), txtC(Index) 'llama al procedimiento Suma
End Sub
Private Sub txtB_Change(Index As Integer)
Suma txtA(Index), txtB(Index), txtC(Index) 'llama al procedimiento Suma
End Sub
VI.10. Módulos en Formularios
El código en Visual Basic se almacena en módulos, son porciones de código que
generalmente almacenan declaraciones, procedimientos y funciones.
Las aplicaciones sencillas1 pueden consistir en un único formulario y todo el código
de la aplicación reside en ese módulo de formulario. A medida que las aplicaciones
van creciendo se agregará formularios adicionales. Si el código es común a varios
formularios y no se desea duplicar el código en ambos formularios, se crea un
módulo independiente que contenga un procedimiento que ejecuta ese código común.
Este módulo independiente debe ser un módulo estándar.
Un sistema es modular cuando fue construido y dividido en varios
módulos.
La gran ventaja de trabajar con módulos es que se puede construir una biblioteca
que contenga los procedimientos compartidos y funciones definidas por el usuario y
trasladarlas hacia otros proyectos con sólo copiar el archivo.
Los tres tipos de módulos:
• formulario son la base de la mayoría de las aplicaciones de Visual Basic
(extensión .frm);
Ä Si se declara el procedimiento en un módulo de formulario, puede
ser llamado con el siguiente código: Form1.MiProc
• estándar son contenedores de los procedimientos y declaraciones a los que
tienen acceso otros módulos de la aplicación. Pueden contener
declaraciones globales (disponibles para toda la aplicación) o a nivel de
módulo de variables, constantes, tipos, procedimientos externos y
procedimientos globales (extensión .bas);
1
Vea en la Ayuda de Visual Basic:“Módulo de código”.

Página 218
Ä Si se declara el procedimiento en un módulo estándar, puede ser
llamado con el siguiente código: MiProc
Ä Si se declara un procedimiento con el mismo nombre en dos módulos
estándar, se debe especificar el nombre del módulo como se muestra
en el siguiente código: Module1.MiProc
• clase son la base de la programación orientada a objetos en Visual Basic.
Se puede escribir código en módulos de clase para crear nuevos objetos.
Estos objetos nuevos pueden incluir propiedades y métodos
personalizados (extensión de nombre de archivo .cls).
VI.11. Agregar un módulo a un proyecto
Para agregar un módulo de código al proyecto, se ejecuta del menú Proyecto →
Agregar módulo. Aparece el
siguiente cuadro de diálogo:
VI.11.i. Iniciar un programa
Por defecto, Visual Basic asume que los programas inician su ejecución desde el
primer formulario creado. Sin embargo a veces es posible iniciar el proyecto
desde otros formularios o módulos.
Para especificar desde qué formulario comenzará a ejecutarse el programa se
establece desde el menú Proyecto → Propiedades en la ficha General el
nombre del formulario inicial.
Para incorporar un
módulo ya existente.
Para crear un
nuevo módulo.

AÑO 2008
CAPITULO VI
Página 219
VI.12. Alcance del Código
Los Procedimientos pueden ser declarados como Private (privados) o Public
(públicos).
• Los declarados como Private pueden ser llamados o invocados sólo por
otros procedimientos localizados en ese formulario, módulo o clase.
• Los declarados como Public en un formulario: pueden ser llamado desde
cualquier lugar de la aplicación especificando los nombres del formulario
y del procedimiento.
• Los declarados como Public en un módulo: están disponibles para toda la
aplicación, y pueden ser llamados especificando el nombre del
procedimiento.
De forma predeterminada, los procedimientos Sub son Public en todos los
módulos, lo que significa que se les puede llamar desde cualquier parte de la
aplicación.
El siguiente código declara un procedimiento Public:
Public Sub MiProc()
End Sub
Se selecciona el
nombre del
formulario inicial.

Página 220
4. Ejercicio
Calcula la División Entera Mediante
barras de desplazamiento horizontal
se determinan el dividendo y el
divisor.
El código de los Eventos en el formulario Form1
Private Sub Form_Load()
txtDivisor.Text = 0
txtDivide.Text = 0
End Sub
Private Sub hsbBarra1_Change()
txtDivide.Text = hsbBarra1.Value
Call Divide(txtDivide, txtDivisor)
End Sub
Private Sub hsbBarra2_Change()
txtDivisor.Text = hsbBarra2.Value
Call Divide(txtDivide, txtDivisor)
End Sub
El código del Procedimiento Divide en el Módulo
Public Sub Divide(div1 As TextBox, div2 As TextBox)
If Val(div2.Text) <> 0 Then
Form1.txtCociente = Val(div1) Val(div2)
Form1.txtResto = Val(div1) Mod Val(div2)
End If
End Sub
VI.13. Ejercicio propuesto
Ejercicio 1:
Crea una aplicación en la cual resuelvas el siguiente
sistema de ecuaciones:
a) Representa en el formulario las rectas correspondientes
a cada ecuación.
b) Presenta en el formulario los valores encontrados para X e Y que satisfagan el
sistema.
c) En el caso de que el sistema no tenga solución real presenta un mensaje.
a1 X + b1 Y = c1
a2 X + b2 Y = c2

AÑO 2008
CAPITULO VI
Página 221
Ejercicio 2:
Crea una aplicación en la cual ingreses las coordenadas de 3 puntos y puedas:
d) Determinar con los segmentos de rectas, dibujadas a partir de sus coordenadas,
un triángulo.
e) Determinarsi el triángulo es equilátero, isósceles o escaleno.
f) Presentar un mensaje con la respuesta.
Nota: Trabaja en cada ejercicio en forma modularizada creando tus propios procedimientos y
funciones en un Módulo estándar.

Página 222
BIBLIOGRAFÍA CONSULTADA Y RECURSOS EN LA WEB
Nombre Autor/Año Edición, Editorial / Dirección del Sitio
Programación
modular
http://teleformacion.edu.aytolacoruna.es/PASC
AL/document/modular.htm;(accedido
10/08/2007).
Visual Basic 6.
Programación
Orientada a Objetos
Rodríguez Bucarelly,
C. M.; 2004
http://www.lawebdelprogramador.com/cursos/en
lace.php?idp=2175&id=93&texto=visual+basic
(accedido 10/03/2007); p. 24
Funciones y
procedimientos
Tecuapacho Cosetl, I;
2006
http://www.wikilearning.com/curso_gratis/basic
_facil-funciones_y_procedimientos/9513-8
Fundamentos de
Programación en
Visual Basic
Matta González, D.
A.; 2003
http://www.cs.us.es/cursos/ai-2003/VB/VB.pdf;
(accedido 20/09/2007); p. 73
Aprenda Visual Basic
6.0 como si estuviera en
Primero
García de Jalón, J. y
otros; 1999
http://www.tecnun.es/asignaturas/Informat1/ayudainf
/aprendainf/VisualBasic6/vbasic60.pdf; (accedido
10/03/2007); p. 24
Lenguaje de
programación Wikipedia
http://es.wikipedia.org/wiki/Lenguaje_de_progra
maci%C3%B3n; (accedido 20/07/2008)
Diferencias entre
parámetros y
argumentos
http://msdn.microsoft.com/es-
es/library/9kewt1b3(VS.80).aspx; (accedido
27/10/2008)
Microsoft Visual Basic
6.0. Manual de
Referencia
Birnios, B. y Birnios,
M.; 2003
Manuales USERS; MP Ediciones; Buenos
Aires; Argentina; p. 249.

Capitulo6 funcproced

Más contenido relacionado

La actualidad más candente (19)

Destacado (6)

Similar a Capitulo6 funcproced (20)

Último (20)

Capitulo6 funcproced