Subprogramas 2018

Subprogramas
Computación I
Descripción breve
La idea de dividir un problema complejo en pequeños problemas o subproblemas se conoce como
“programación modular” y consiste en resolver de forma independiente los subproblemas
resultantes de la descomposición de un problema, donde cada una de las soluciones a los
subproblemas constituye un subprograma o procedimiento. Esto implica que existe un proceso
principal, denominado programa principal, que transferirá el control y la información a los
distintos subprogramas para que efectúen la tarea solicitada cuando sean llamados, los cuales
una vez que terminen de efectuar su tarea o instrucciones definidas para alcanzarla, transferirán
de nuevo el control a quien lo llamó; sea este el programa principal u otro subprograma o
procedimiento. Un subprograma es entonces un bloque de instrucciones o sentencias que llevan a
cabo una tarea bien específica o definida y que puede utilizarse en un programa varias veces sin
necesidad de reescribir el código. Como representa una sección de código que se ejecutará y
establecerá comunicación con quien lo invoca o llama, esta comunicación o intercambio de
información se realizará a través de variables, que se denominarán parámetros. En este
documento encontrará la definición de subprograma, tipos, creación y usos. Adicionalmente por
ser un elemento imprescindible la definición de parámetros, tipos, declaración y uso apropiado.
.
lpachecos@gmail.com
SUBPROGRAMAS
Contenido
Definiendo Subprogramas o Procedimientos ..................................................................... 1

Divide el problema y lo resolverás .................................................................................... 3
Ventajas de desarrollar Subprogramas ............................................................................. 4
Subprogramas o Procedimientos en Visual Basic .............................................................. 5
Definiendo que son Parámetros o Argumentos.................................................................. 5
Parámetros Formales ......................................................................................................... 6
Parámetros Actuales .......................................................................................................... 6
Más acerca de los Parámetros Formales ............................................................................... 7
Tipos de Parámetros Formales .......................................................................................... 9
Parámetros por Valor (ByVal) .............................................................................................. 9
Parámetros por Referencia (ByRef) ...................................................................................... 9
¿Cuándo usar parámetros por valor o por referencia? .......................................................... 10
Procedimientos Function ................................................................................................. 11
Sintaxis de Procedimientos Function .................................................................................. 11
Uso o llamada de un Procedimiento tipo Function ................................................................ 12
Procedimientos Sub ........................................................................................................ 13
Sintaxis de Procedimientos Sub ......................................................................................... 13
Uso o llamada de un Procedimiento Sub ............................................................................. 15
¿Cuándo usar un parámetro por valor ByVal o por referencia ByRef en un Procedimiento
Sub? ................................................................................................................................ 17
¿Cómo enfrentar un problema? ....................................................................................... 17
SUBPROGRAMAS
Definiendo Subprogramas o Procedimientos
A
menudo en la programación es muy común que un conjunto de instrucciones deba
repetirse varias veces dentro del mismo código, esto ocurre cuando el mismo proceso
tiene que realizarse varias veces con diferentes variables, de manera que deben escribirse
las mismas instrucciones varias veces solo cambiando las variables. Un ejemplo de lo
descrito anteriormente ocurre cuando se desea determinar el número de combinaciones posibles,
para lo que debe utilizarse la siguiente fórmula:
( )
Si se desea realizar un programa que permita determinar el número de combinaciones C, usando
dicha fórmula, el análisis implica:
¿Cómo lo hago? o ¿cuáles son

¿Qué tengo? o ¿cuáles son ¿Qué me piden? o
las fórmulas o expresiones,
los datos necesarios para ¿cuáles son las
restricciones y otros para
obtener C? incógnitas?
obtener las incógnitas?
MyN C
( )
ALGORITMO BASICO PARA RESOLVER EL PROBLEMA
1. Inicio
2. Leer M
3. Leer N
4. Calcular el Factorial de N en la variable Fn
5. Calcular el Factorial de M en la variable Fm
6. Calcular el Factorial de M-N en la variable Fm_n
7. Calcular C cómo Fn / (Fm * Fm_n)
8. Escribir C
IMPORTANTE
9. Fin
Como no existe ninguna función
predefinida en el lenguaje que
DEFINICIÓN DE FACTORIAL permita determinar el factorial,
éste deberá determinarse por
definición.
El factorial de n se define como el

producto de todos los números
enteros positivos desde 1 hasta n.
MATERIAL DE COMPUTACIÓN I 1
SUBPROGRAMAS
PROGRAMA EN VISUAL BASIC

Module Module1
Sub Main()
'Entradas o datos
Dim M, N As Integer
'Salidas, resultados o incognitas
Dim C As Single
'Variables de Proceso o necesarias para el calculo
Dim fm, fn, fm_n As Integer
'Lectura de los datos
Console.Write("Valor de M=")
M = Console.ReadLine
Console.Write("Valor de N=")
N = Console.ReadLine
'Calcular Factorial de M
fm = 1 'Acumulador Productoria
'Generación de los números naturales entre 1 y M
For i = 1 To M
Observe que el código
'Productoria de los números naturales entre 1 y M de los tres recuadros
fm = fm * i
Next es prácticamente el
mismo, sólo cambian
'Calcular Factorial de N
fn = 1 'Acumulador para la Productoria las variables: La que
'Generación de los números naturales entre 1 y N
For i = 1 To N representa el fin del
'Productoria de los números naturales entre 1 y N ciclo for (la cantidad
fn = fn * i
Next de números naturales a
generar) y el
'Calcular Factorial de M -N
Fm_n = 1 'Acumulador para la Productoria acumulador de los
'Generación de los números naturales entre 1 y M -N
For i = 1 To M - N
números generados
'Productoria de los números naturales entre 1 y M-N (productoria) que
Fm_n = fm_n * i
Next permite determinar el
'Calcular el número de Combinaciones posibles factorial
C = fm / (fm_n*fn)
'Imprimir combinaciones
Console.WriteLine("Combinaciones de {0} y {1} es de {2}", M, N, C)
Console.ReadKey()
End Sub
End Module
Para disminuir la cantidad de código se puede generalizar la tarea de calcular el factorial

escribiéndola como un subprograma, esto permitiría reutilizar el código sin necesidad de
escribirlo más de una vez en el programa, de tal manera que al llamar o usar el subprograma se
suministraría el valor
al cual se quiere CÓDIGO PARA CALCULAR EL FACTORIAL DE X
determinar el
f = 1 'Acumulador Productoria
factorial. 'Generación de los números naturales entre 1 y X
For i = 1 To X
f = f * i 'Productoria de los números naturales entre 1 y X
Next
SUBPROGRAMAS
El código para calcular el factorial de X, se transformará en una función para luego ser
PROGRAMA EN VISUAL BASIC USANDO SUBPROGRAMAS

Module Module1
'El código repetido se convierte en tarea, una función que dado X determina el factorial de X
Function factorial(ByVal x As Integer) As Integer
Dim f As Integer
'Calcular Factorial de X
'Generación de los números naturales entre 1 y X
For i = 1 To x
'Productoria de los números naturales entre 1 y X
Observe que el código para
f = f * i
Next determinar el factorial se
factorial = f 'Valor que se desea devuelva la función escribe de manera genérica
End Function como procedimiento o
'PROGRAMA PRINCIPAL subprograma tipo
Sub Main()
'Entradas o datos function, una pieza del
Dim M, N As Integer rompecabezas,
Dim C As Single
'Variables de Proceso o necesarias para el calculo
un subproblema.
Console.Write("Valor de N=") En el programa principal
ahora se emplea la función,
'Asignamos a fm el resultado de evaluar la función Factorial para el valor de M
fm = factorial(M) 'a fin de obtener M!
'Asignamos a fn el resultado de evaluar la función Factorial para el valor de N
fn = factorial(N) 'a fin de obtener N! al igual que las funciones
'Calcular Factorial de M –N predefinidas, asignando a
'Asignamos a fm_n el resultado de la función Factorial para el valor de M-N
fm_n = factorial(M - N) 'a fin de obtener (M – N)!
una variable el resultado,
'Calcular el número de Combinaciones posibles en este caso determinar el
C = fm /(fm_n * fn) factorial de la variable que
Console.WriteLine("Las combinaciones de {0} y {1} es {2}", M, N, C) representa lo requerido o a
Console.ReadKey() quien se quiere determinar
End Sub
el factorial
End Module
Divide el problema y lo resolverás
SUBPROGRAMAS
utilizada en el programa como las funciones predefinidas del lenguaje que ya se han utilizado.
La idea de dividir un problema complejo en pequeños problemas o subproblemas se conoce como

“programación modular” y consiste en resolver de forma independiente los subproblemas
resultantes de la descomposición del problema original, cada una de las soluciones a los
subproblemas constituye un subprograma o procedimiento. Trabajar de esta forma implica que
existe un proceso principal, denominado programa principal, que transferirá el control y la
información (datos necesarios) a los distintos subprogramas o procedimientos para que efectúen la
tarea solicitada cuando sean invocados o llamados, los cuales una vez que terminen de efectuar su
tarea, instrucciones definidas para alcanzarla,
transferirán de nuevo el control a quien lo Un subprograma es un bloque de
invocó o llamó; sea este el programa principal instrucciones o sentencias que llevan a
u otro subprograma o procedimiento. cabo una tarea bien específica o
Los subprogramas o procedimientos deberían

definida y que puede utilizarse en un
programa varias veces sin necesidad
de reescribir el código. Como
representa una sección de código que
se ejecutará y establecerá
comunicación con quien lo invoca o
llama, esta comunicación o intercambio
de información se realizará a través de
variables, que se denominarán
parámetros.
ser cortos y para desarrollarlos se seguirán todas las
reglas de programación, así mismo se podrán
emplear todas las estructuras y herramientas de programación habituales, centrándose en resolver
únicamente la tarea que se desea.
Ventajas de desarrollar Subprogramas

 Permiten eliminar líneas repetidas en el código. Sólo se escribirán
una vez, aunque se requiera realizar varias veces la misma tarea
para la solución del problema completo, pero se ejecutarán en el
programa cada vez que se necesite.
 Permite que los programas sean más legibles o fácilmente
comprensibles. Un programa dividido en varias partes más
pequeñas es más fácil de entender.
 Simplifican el desarrollo del programa. Los programas separados
en unidades lógicas o subproblemas son más fáciles de diseñar,
escribir y depurar.
 Se pueden volver a utilizar en otros proyectos o soluciones,
permitiendo el ahorro de tiempo. Los procedimientos o
SUBPROGRAMAS
subprogramas desarrollados pueden

incorporarse en un módulo estándar en otros
proyectos, permitiendo así poder usarlos como Subprogramas o
los que están predefinidos en el lenguaje. procedimientos son un conjunto
 Varios programadores pueden trabajar de instrucciones que permiten
simultáneamente, repartiéndose los distintos realizar una tarea de manera
subproblemas, ya que son módulos generalizada, que puede ser
independientes, que luego se engranan. utilizada, sin reescribir el código,
 Se podrá modificar un módulo o subproblema, varias veces en el programa o
sin afectar a los demás. subprograma que lo requiera;
establecen comunicación con quien
Subprogramas o lo llame o requiera a través de
variables especiales denominadas
Procedimientos en Visual Basic parámetros.
Visual Basic posee dos tipos de subprogramas o
procedimientos principales: Procedimientos Function
y Procedimientos Sub.
Los Procedimientos Function (Función) se utilizan
generalmente para cálculos, pueden recibir datos a
través de parámetros y siempre devuelven el
resultado a través del nombre de la función.
Los Procedimientos Sub, se utilizan para realizar una 1.- Los datos necesarios se pasan al
subprograma (Cada dato una
tarea, pueden recibir datos a través de parámetros y
variable o parámetro)
pueden devolver resultados a través de parámetros.
Definiendo que son

Parámetros o Argumentos
Una de las características importantes de los
subprogramas es la posibilidad de comunicarse con el
programa principal u otros subprogramas. Esta
comunicación se realiza a través de variables 2.- El subprograma efectúa la tarea,
denominadas parámetros, dicho de otra manera siguiendo las instrucciones definidas
cuando un programa llama o usa un subprograma, la
información se transmite entre ambos a través de
variables que se denominan parámetros,
constituyéndose en la manera de pasar información o
valores a variables, del programa principal al
subprograma y viceversa.
Un parámetro o argumento es una variable que 3.- El subprograma una vez ejecutada
representa un dato que se pasa al subprograma y que la tarea regresa el resultado generado
es necesario para ejecutar las instrucciones definidas al programa o subprograma que lo
en la tarea, o que se devuelve del subprograma por ser llamó o pidió su ejecución (Cada dato
lo que se desea determinar.
SUBPROGRAMAS
Un parámetro entonces, puede ser una variable

PROGRAMA EN VISUAL BASIC
cuyo valor debe ser proporcionado al subprograma
USANDO SUBPROGRAMAS
una vez invocado, o una variable cuyo valor debe ser IDENTIFICANDO PARÁMETROS
devuelto desde el subprograma porque se genera o
Module Module1
calcula mediante las instrucciones definidas para la
'El código repetido se convierte en tarea, una
tarea. 'función que dado X determina el factorial de X
Los parámetros según su uso se clasifican en
parámetros formales o parámetros actuales.
Function factorial(ByVal x As Integer)
As Integer
Parámetros Formales
'Variable local, acumulador para calcular x!
Dim f As Integer
Cuando se crea el procedimiento o subprograma en 'Calcular Factorial de X
la definición o cabecera, se incluyen la lista de f = 1 'Acumulador Productoria
'Generación de los números de 1 a X
parámetros o variables que permiten la For i = 1 To x
comunicación, datos de entrada (necesarios para 'Productoria de los números
f = f * i
efectuar las instrucciones) y datos de salida del Next
subprograma (resultantes de los cálculos o Parámetro
factorial = f 'Valor a devolver
instrucciones que se requieren para procesos Formal
End Function
posteriores), estos se denominan parámetros 'PROGRAMA PRINCIPAL
Sub Main()
formales o ficticios. Ellos sirven para guardar la
'Entradas o datos
información de los valores de las variables que Dim M, N As Integer
invocan o llaman al subprograma. Si lo vemos como 'Salidas, resultados o incognitas
Dim C As Single
una obra de teatro, cuando se escribe o crea, los 'Variables de Proceso
parámetros formales son los personajes de la obra. Dim fm, fn, fm_n As Integer
Para el subprograma definido para el cálculo del
factorial de X, se tiene que X, es el dato necesario M = Console.ReadLine
para poder efectuar la tarea o cálculo, siendo X el Console.Write("Valor de N=")
parámetro formal, la cabecera del subprograma es la
siguiente: 'Calcular Factorial de M
fm = factorial(M)
Function factorial(ByVal x As Integer) As Integer
Parámetros Actuales fn = factorial(N)
Los parámetros actuales, lo constituyen las variables 'Calcular Factorial de M –N

fm_n = factorial(M - N)
que se utilizan cuando se emplea o llama al
subprograma o procedimiento, las variables que
representan los datos en el momento; volviendo al 'Calcular número de Combinaciones posibles
tema de la obra de teatro, cuando se interpreta o C = fm /(fm_n * fn)
pone en escena la obra, se ejecuta, cada personaje Console.WriteLine("Las combinaciones de
es interpretado por un actor, el que toque en ese {0} y {1} es {2}", M, N, C) Parámetro
momento. Los parámetros actuales deben coincidir Console.ReadKey()
End Sub Actual
en número, orden y tipo con los parámetros formales
End Module
o ficticios definidos en la declaración o cabecera del Parámetro
subprograma. Para el ejemplo se usa o llama la Actual
función factorial en el programa principal tres
Parámetro
Actual
SUBPROGRAMAS
veces:
fm = factorial(M) 'a fin de obtener el Factorial de M
fn = factorial(N) 'a fin de obtener el factorial de N
'Calcular Factorial de M –N
fm_n = factorial(M - N) 'calcular factorial de (M – N)
Observe que en cada llamada sólo se coloca el nombre de la función y la variable a la que se desea
calcular el factorial, esa variable es el parámetro actual, o valor que se asignará a la variable X,
parámetro formal del subprograma para realizar las instrucciones del subprograma.
Más acerca de los Parámetros Formales

Existen diferentes formas de transmisión o paso de parámetros a subprogramas, por lo que pueden
ser clasificados de acuerdo a ello, como:
Entradas: Permiten únicamente la transmisión o paso de datos desde el programa o

subprograma que llama o solicita la ejecución del subprograma.
Salidas: Sólo devuelven resultados desde el subprograma al programa o

subprograma que llama o solicita la ejecución del subprograma.
Entradas/Salidas: Actúan en los dos sentidos, tanto recibiendo datos del programa principal o
subprograma que llama o solicita la ejecución del subprograma; como
devolviendo resultados desde el subprograma al programa o subprograma
que llama o solicita la ejecución del subprograma
Esta definición puede ser útil, pero no es suficiente para definir los parámetros formales, que
tendrá un procedimiento o subprograma, por lo que debemos identificar los principales tipos de
parámetros formales.
SUBPROGRAMAS
SUBPROGRAMAS
Tipos de Parámetros Formales

Visual Basic posee dos tipos de parámetros principales para la transmisión de datos entre un
subprograma y el programa o subprograma que lo utiliza o llama.
Parámetros por Valor (ByVal)

Para este tipo de parámetro, el parámetro formal recibe
como valor inicial una copia del parámetro actual y con
ellos se ejecutan las instrucciones descritas en el
subprograma, por lo tanto los cambios que se produzcan
en ellos por las instrucciones del subprograma no podrán
afectar a los parámetros actuales porque no se devolverá
la información al programa o subprograma llamador. Estos
se corresponden con los parámetros definidos como
entradas.
El parámetro actual, puede ser una variable, constante o

expresión, ya que sólo el valor resultante es el que se
asigna al parámetro formal.
Un parámetro por valor no puede modificar los valores del parámetro actual, por
lo que cualquier cambio del valor del parámetro formal durante la ejecución del
subprograma se destruye cuando termina de ejecutarse el subprograma,
permaneciendo el valor original.
Para indicar que un parámetro es por Valor la sintaxis es: Byval Identificador as Tipo
Parámetros por Referencia (ByRef)

En muchas ocasiones se requiere que los parámetros sirvan
como salida, es decir que devuelvan los resultados al programa
SUBPROGRAMAS
o subprograma que lo llama. Para este tipo de parámetro, el parámetro formal recibe la
dirección de memoria del parámetro actual. De esta forma una variable pasada como
parámetro actual es compartida; es decir, puede ser modificada directamente por el
subprograma. Los parámetros de este tipo corresponden con los de entrada/salida o
con los de salida si hablamos de un subprograma tipo Sub.
El parámetro actual, debe ser una variable, ya que recibirá el resultado del cálculo o de lo
que se genere en las instrucciones definidas en la tarea.
Un parámetro por referencia puede modificar los valores del parámetro actual,
por lo que cualquier cambio de los parámetros formales durante la ejecución del
subprograma se refleja en los parámetros actuales cuando termina de ejecutarse
el subprograma.
Para indicar que un parámetro es por Valor la sintaxis es: ByRef Identificador as Tipo
¿Cuándo usar parámetros por valor o por referencia?

Algunas reglas a seguir para utilizar uno u otro tipo de parámetro son:
SUBPROGRAMAS
 Si la información que se pasa al subprograma no tiene que ser devuelta fuera del
subprograma, el parámetro que representa puede ser un parámetro por valor.
 Si se tiene que devolver la información al subprograma o programa llamador, el
parámetro formal que representa la información debe ser un parámetro por
referencia.
 Si la información que se pasa al subprograma puede ser modificada y se debe
devolver el nuevo valor, el parámetro formal que representa la información debe
ser un parámetro por referencia.
Procedimientos Function
Un procedimiento function es un subprograma que recibe datos y devuelve un único
resultado a través del nombre de la función, el nombre de la función actúa como una
variable o dirección de memoria donde se almacenará el resultado a devolver por la
función.
Sintaxis de Procedimientos Function

La sintaxis básica de una función es la siguiente:
SINTAXIS
Function FunctionName( Parámetros o argumentos) as Type ‘Cabecera o encabezado
‘Declaración de Variables internas o auxiliares del calculo
Dim identificador as tipo
‘Instrucciones a ejecutar, cuerpo del subprograma
FunctionName = Valor a devolver ‘Puede sustituirse por Return Valor a devolverr

End Function
IMPORTANTE
 FunctionName es el nombre de la función que está creando, actuará como la variable
donde se devolverá el resultado.
 As Type permite especificar el tipo de resultado que devuelve la función, en otras palabras
especifica el tipo de dato se puede guardar o se guardará en FunctionName, que se
comporta como una variable.
 Parámetros o argumentos, lista de parámetros o datos que se pasarán a la función para
que efectúe los cálculos o instrucciones.
 FunctionName = Valor a devolver , asigna el valor a regresar al nombre de la función;
puede abreviarse escribiendo Return Valor a devolver, con esto se indica que devuelva
Valor a devolver al subprograma o programa que llama y cuál es ese valor, sin embargo,
debe cuidarse al utilizarla ya que cuando se ejecuta la instrucción Return, la función
termina su ejecución, así que si hay instrucciones después de ella no se ejecutarán.
SUBPROGRAMAS
EJEMPLO DE PROCEDIMIENTO TIPO Las funciones siempre devuelven el valor

FUNCTION EN VISUAL BASIC
al programa, subprograma o
Cálculo del Factorial de X procedimiento que lo llama o solicita su
ejecución en el nombre de la función.
Function factorial(ByVal x As Integer) Por esta razón la última instrucción en una
As Integer
función es generalmente de asignación
'Variable local, acumulador para calcular x!
que coloca el resultado a del cálculo final
Dim f As Integer
que de la función en la variable
FunctionName o nombre de la función.
El nombre de la función no debe aparecer
For i = 1 To x
'Productoria de los números del lado derecho de una instrucción de
f = f * i asignación en las instrucciones a ejecutar
Next dentro del subprograma o procedimiento.
factorial = f 'Valor a devolver
End Function Una función debería tener sólo
parámetros por valor
EJEMPLO DE FUNCIONE EN VISUAL BASIC
Cálculo de la distancia entre dos puntos

'Dadas las coordenadas de dos puntos determine la distancia entre ellos
Function distancia(ByVal x1 As single, ByVal y1 As single,
ByVal x2 As single, ByVal y2 As single)
As Single
'Valor que debe devolver la función
distancia = Math.sqrt((x2-x1)^2 - (y2-y1)^2)
End Function
Uso o llamada de un Procedimiento tipo Function

Para ejecutar, invocar, llamar o solicitar la
ejecución de una función se coloca el nombre Revise en la página 6
PROGRAMA EN VISUAL BASIC USANDO
de la función seguido de los parámetros SUBPROGRAMAS
actuales o argumentos del lado derecho de IDENTIFICANDO PARÁMETROS
una asignación o como parte de una
expresión o formula. 'Calcular Factorial de M
fm = factorial(M)
Los parámetros actuales o argumentos deben 'Calcular Factorial de N
fn = factorial(N)
estar entre paréntesis y si son varios, 'Calcular Factorial de M –N
separados por comas. fm_n = factorial(M - N)
SUBPROGRAMAS
Ejemplo de llamado para la Función que determina la Distancia entre dos puntos
'Determinar la distancia entre punto p2 de coordenadas x2 y y2

'y el punto p3 de coordenadas x3,y3, usando la función distancia
D13=distancia(x2,y2,x3,y3)
'Cuando se ejecute la función distancia los parámetros actuales
‘pasarán a los formales
'el valor de x2 o parámetro actual, lo tomará el parámetro formal X1
'valor de y2 o parámetro actual, lo tomará el parámetro formal y1
'el valor de x3 o parámetro actual, lo tomará el parámetro formal X2
'valor de y3 o parámetro actual, lo tomará el parámetro formal y2
Si observamos el problema de la página 6, vemos el llamado del subprograma factorial,

donde los parámetros actuales son para cada llamada respectivamente M, N y el resultado
de evaluar la expresión M-N.
Procedimientos Sub
Los procedimientos sub se usan generalmente para conseguir el suministro de
información o lectura de datos, mostrar o imprimir información o procesar y actualizar las
variables o parámetros recibidos. Pueden devolver ningún valor, uno o más valores, pero
lo que devuelve lo devuelve en variables o parámetros definidos en la cabecera del
procedimiento.
Sintaxis de Procedimientos Sub
SUBPROGRAMAS
EJEMPLO DE PROCEDIMIENTO TIPO SUB EN La sintaxis básica de un

VISUAL BASIC procedimiento sub es el
siguiente:
Cálculo del Factorial de X
'Desarrollaremos el subprograma de calcular el factorial de
'un Número como un Procedimiento Sub
Sub factorial(ByVal x As Integer 'Entrada o dato,
ByRef F As Integer 'Resultado o salida)
Observe que al cambiar el
'Variables internas del Subprograma procedimiento de Function a
Sub, se agrega un parámetro
f = 1 'Acumulador Productoria formal que corresponde con el
'Generación de los números naturales entre 1 y X dato que se desea regresar y
For i = 1 To M que el mismo se define como
'Productoria de los números naturales entre 1 y X ByRef o parámetro por
f = f * i referencia.
Next
End Sub
EJEMPLO DE PROCEDIMIENTO TIPO SUB EN VISUAL BASIC
Cálculo de la distancia entre dos puntos

'Dadas las coordenadas de dos puntos determine la distancia entre ellos
'Cómo un Procedimiento Sub
Sub distancia2(ByVal x1 As single, ByVal y1 As single,
ByVal x2 As single, ByVal y2 As single,
SINTAXIS
ByRef distancia As single)
Sub ProcedureName( Parámetros
'Valor que debe devolver o argumentos)
la función ‘Cabecera o encabezado
‘Declaración
distancia = Math.sqrt((x2-x1)^2 - (y2-y1)^2)calculo
de Variables internas o auxiliares del
Dim identificador as tipo
End Sub
‘Instrucciones a ejecutar, cuerpo del subprograma
End Sub
IMPORTANTE
 ProcedureName es el nombre del procedimiento Sub que está creando.

 Parámetros o argumentos, lista de parámetros o datos que se pasarán a la función
para que efectúe los cálculos o instrucciones.
Sí se modifican las variables o parámetros del procedimiento sub durante la ejecución de

las instrucciones del procedimiento sub, los valores actualizados no se pasarán al
programa o subprograma que pide su ejecución a menos que estos parámetros se
definan como parámetro por referencia, utilizando la palabra clave ByRef.
SUBPROGRAMAS
Uso o llamada de un Procedimiento Sub

Para ejecutar, invocar, llamar o solicitar la ejecución de un
procedimiento Sub se coloca el nombre del procedimiento
seguido de los parámetros actuales o argumentos cómo una
instrucción de código.
Los parámetros actuales o argumentos deben estar entre

paréntesis y si son varios, separados por comas.
IMPORTANTE
No se puede colocar el llamado a un

procedimiento Sub del lado derecho de
una instrucción de asignación, ni como
parte de una expresión o fórmula.
SUBPROGRAMAS
PROGRAMA EN VISUAL BASIC USANDO PROCEDIMIENTOS SUB

Calculando el número de combinaciones
Module Module1
'Dado M y N determine el número de combinaciones posibles
' empleando la formula que dice que C= M!/(N!*(M-N)!)
' consideramos aquí que M es mayor que N
Sub factorial(ByVal x As Integer, ByRef f As Integer)
'Variable local para este código no existe
For i = 1 To x
'Productoria de los números
f = f * i
Next
End Sub
'PROGRAMA PRINCIPAL
Sub Main()
'Entradas o datos
Dim M, N As Integer
Dim C As Single
'Variables de Proceso
'Lectura de los datos, no se están validando
Console.Write("Valor de N=")
factorial(M, fm)
factorial(N, fn)
'Calcular Factorial de M –N
factorial(M - N, fm_n)
'Calcular número de Combinaciones posibles

C = fm / (fm_n * fn)
Console.WriteLine("Las combinaciones de {0} y {1} es {2}", M, N, C)
Console.ReadKey()
End Sub
End Module Sí una heladeria ofrece los 4 sabores que se muestran¿Cúantas
combinaciones de helados de dos sabores se pueden hacer?
Las combinaciones posibles son: 1)Chocolate-Frutilla, 2)Chocolate-Vainilla,

3)Chocolate-Menta, 4)Frutilla-Vainilla, 5)Frutilla-Menta y 6)Vainilla-Menta
SUBPROGRAMAS
¿Cuándo usar un parámetro por

valor ByVal o por referencia ByRef
en un Procedimiento Sub?
 Utilice Byval cuando no quiera que el procedimiento
modifique una variable que está pasando al procedimiento
 Utilice ByRef cuando quiera que un procedimiento modifique una variable que está pasando
al procedimiento
 Utilice ByRef cuando la variable o parámetro se determine dentro del subprograma.
 Utilice ByRef cuando la variable o parámetro se lean dentro del subprograma.
 Cuando tenga dudas use ByVal, ya que no se modificará el contenido de la variable
¿Cómo enfrentar un problema?

 Analice el problema e identifique los datos necesarios, las incognitas o
salida deseada y los procesos que permitan efectuar dicha tarea.
 Establezca los procesos, tareas o subproblemas que se aplicarían en el
problema a resolver, separe cada subproblema y resuélvalo por separado.
 Diseñe la solución a cada subproblema considerando

exclusivamente la tarea solicitada, los datos que se
necesitan, si no pueden generarse, deben entrar al
subprograma y serán por tanto parámetros en primera
instancia por valor o ByVal. Lo que necesita calcular,
determinar o devolver será parámetro ByRef, a menos
SUBPROGRAMAS
que sea una función en cuyo caso se devolverá en el nombre de la función.

 Cuando diseñe un subprograma, sí alguna tarea a realizar en el mismo se
encuentra previamente creada en un subprograma, use el subprograma de
acuerdo al tipo, especificando los parámetros o variables que representan
los datos o información que se suministrará al subprograma y las variables
o parámetros donde devolverá los resultados en caso de ser un
procedimiento Sub.
 Si el subprograma a diseñar es de lectura o impresión, debería ser Procedimiento Sub.
 En los subprogramas de lectura, todo lo que se lea y se desee devolver debe ser parámetro
ByRef
 En los subprogramas de impresión, los valores de las variables generalmente no se alteran
por lo que deberán ser parámetros ByVal
 Diseñados los subprogramas solicitados, desarrolle el
programa principal, leyendo el problema a resolver,
identifique las entradas o datos y las salidas o resultados,
cada uno representará una variable, seleccione el nombre
apropiado.
 Establezca la estructura que le permitirá leer la información y
de manera general los pasos para resolver el problema, para
cada paso revise si tiene un subprograma que haga el cálculo
o tarea, de ser así use el subprograma apropiadamente,
especificando los parámetros o variables que representan los
datos o información que se suministrará al subprograma y las
variables o parámetros donde devolverá los resultados en
caso de ser un procedimiento Sub, al unir todas las partes del
rompecabezas tendrá la solución a su problema.
Recuerde el Programa principal es el que

indicará que tarea o subprograma se debe
ejecutar y con qué valores. Ud. es el que
dirige las acciones así que el éxito de la
tarea es suya

Subprogramas 2018

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Subprogramas 2018

Загружено:

Авторское право:

Доступные форматы

Subprogramas

Definiendo Subprogramas o Procedimientos ..................................................................... 1

Definiendo Subprogramas o Procedimientos

¿Cómo lo hago? o ¿cuáles son

El factorial de n se define como el

PROGRAMA EN VISUAL BASIC

Para disminuir la cantidad de código se puede generalizar la tarea de calcular el factorial

PROGRAMA EN VISUAL BASIC USANDO SUBPROGRAMAS

Divide el problema y lo resolverás

La idea de dividir un problema complejo en pequeños problemas o subproblemas se conoce como

Los subprogramas o procedimientos deberían

Ventajas de desarrollar Subprogramas

subprogramas desarrollados pueden

Definiendo que son

Un parámetro entonces, puede ser una variable

Los parámetros actuales, lo constituyen las variables 'Calcular Factorial de M –N

Más acerca de los Parámetros Formales

Entradas: Permiten únicamente la transmisión o paso de datos desde el programa o

Salidas: Sólo devuelven resultados desde el subprograma al programa o

Tipos de Parámetros Formales

Parámetros por Valor (ByVal)

El parámetro actual, puede ser una variable, constante o

Parámetros por Referencia (ByRef)

que se genere en las instrucciones definidas en la tarea.

¿Cuándo usar parámetros por valor o por referencia?

Sintaxis de Procedimientos Function

FunctionName = Valor a devolver ‘Puede sustituirse por Return Valor a devolverr

EJEMPLO DE PROCEDIMIENTO TIPO Las funciones siempre devuelven el valor

Cálculo de la distancia entre dos puntos

Uso o llamada de un Procedimiento tipo Function

'Determinar la distancia entre punto p2 de coordenadas x2 y y2

Si observamos el problema de la página 6, vemos el llamado del subprograma factorial,

Sintaxis de Procedimientos Sub

EJEMPLO DE PROCEDIMIENTO TIPO SUB EN La sintaxis básica de un

EJEMPLO DE PROCEDIMIENTO TIPO SUB EN VISUAL BASIC

Cálculo de la distancia entre dos puntos

 ProcedureName es el nombre del procedimiento Sub que está creando.

Sí se modifican las variables o parámetros del procedimiento sub durante la ejecución de

Uso o llamada de un Procedimiento Sub

Los parámetros actuales o argumentos deben estar entre

No se puede colocar el llamado a un

PROGRAMA EN VISUAL BASIC USANDO PROCEDIMIENTOS SUB

'Variable local para este código no existe

'Calcular número de Combinaciones posibles

Las combinaciones posibles son: 1)Chocolate-Frutilla, 2)Chocolate-Vainilla,

¿Cuándo usar un parámetro por

¿Cómo enfrentar un problema?

 Diseñe la solución a cada subproblema considerando

que sea una función en cuyo caso se devolverá en el nombre de la función.

Recuerde el Programa principal es el que

Вам также может понравиться