Bienvenidos a este nuevo capítulo de este Curso Gratis de Programación #22 Procedimientos
¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?
Procedimiento
Es un subalgoritmo que realiza una tarea pero no retorna ningún valor al algoritmo que lo haya invocado. Procedimientos internos definidos por PSeint pueden ser los siguientes:
- mostrar: muestra por consola el parámetro que se envía al procedimiento.
- Leer: asigna un valor ingresado por el usuario a la variable que figura como parámetro.
El programador también puede definir sus propios procedimientos utilizando la siguiente sintaxis de pseudocódigo:
procedimiento <nombre de parametros)
var
Declaracion de variables locales
inicio
<acciones> //cuerpo del procedimiento
fin-procedimiento Llamar a un Procedimiento
procedimiento nombre_del_procedimiento (modo tipo: nombre-variable;…..) var:
// se declaran las variables y sus tipos inicio
// se codifica la tarea
fin-procedimientoLa definición de un procedimiento comienza con la palabra reservada procedimiento a continuación se coloca el nombre del procedimiento, tratando de darle un identificador que represente la tarea que codifica el subalgoritmo, a continuación, entre paréntesis se coloca la lista de parámetros indicando:
modo, tipo y nombre o identificador de la variable. Los parámetros se separan con punto y como. No hay limitación a la cantidad de parámetros que pueden indicarse entre paréntesis. En los lenguajes de programación suelen usarse hasta 4 o 5 parámetros, si se necesitasen más que esa cantidad, entonces, es posible que dicho subalgoritmo pueda descomponerse en dos o más subalgoritmos.
Modo: hay tres posibilidades: E (entrada), S (salida) y E/S (entrada y salida)
- El modo entrada (E), implica que el contenido de la variable solo puede ser leído o usado dentro del subalgoritmo, pero ese valor no puede ser modificado desde dentro del subalgoritmo.
- El modo salida (S), implica que el contenido de la variable no puede ser leído o usado dentro del subalgoritmo, pero si se puede generar un resultado o valor dentro del subalgoritmo y asignárselo a este parámetro de salida, y desde el algoritmo principal se puede hacer uso de ese valor.
- El modo entrada/salida (E/S), implica que el contenido de la variable puede ser leído o usado dentro del subalgoritmo, pero ese valor no puede ser modificado desde dentro del subalgoritmo.
Tipo: es cualquier tipo válido en pseudocódigo, por ejemplo, real, entero, lógico, cadena, carácter o registro (se verá más adelante).
Invocación de subalgoritmos.
Según se trate de un procedimiento o una función, se realiza lo siguiente:
La invocación se hace en el programa principal o algoritmo para lo cual se escribe: la palabra llamar-a (que es opcional, puede ir o suprimirse) y a continuación el nombre del procedimiento y entre paréntesis la lista de parámetros sin tipo ni modo, separados por coma., y la definición del subalgoritmo se coloca después de la línea de fin para el algoritmo principal.
Por ejemplo, implementar un programa que permita mediante un procedimiento sumar dos enteros pasados por parámetros desde el programa principal. Los sumandos serán tomados desde el teclado. El resultado de la suma se mostrará desde el subalgoritmo.
Comienza con la palabra reservada procedimiento y a continuación el nombre o identificador del procedimiento. entre paréntesis, se coloca la lista de parámetros indicando el tipo de dato y nombre o identificador de las variables. Los parámetros se separan con coma. Se pueden definir también variables locales al procedimiento en la sección var. el cuerpo de acciones del procedimiento debe delimitarse con las palabras reservadas inicio y fin-procedimiento.
Para llamar al procedimiento, se debe invocar su nombre con la lista de parámetros que este requiere:
nombre_procedimiento(lista de parámetros actuales). También se puede utilizar la sintaxis llamar_a para invocar a un procedimiento: llamar-a nombre_procedimiento(lista de parámetros actuales) Un programa que permita mostrar por pantalla la suma de dos números enteros. La suma de los números y la salida por pantalla del resultado se debe realizar con un procedimiento.
Algoritmo calcular_suma
var
entero: a, b
lnicio
mostrar("lngresar dos números enteros")
leer(a,b)
llamar-a suma(a, b)
fin
procedimiento suma(entero: a,b)
var
entero: sum
lmc10
sum <-a + b
mostrar("La suma es: ", sum)
fin-procedimiento A un procedimiento no se le puede asignar valor, y por consiguiente ningún tipo está asociado con el nombre del procedimiento.
EXPLICACIÓN:
- El procedimiento recibe dos parámetros de modo entrada, esto quiere decir que dentro del procedimiento solo se podrá leer su contenido, pero no se podrá modificar el contenido de las variables a y b.
- Dentro del procedimiento se declara una variable entera sum, local, sobre la que se guarda la suma de a y b.
- El procedimiento muestra por pantalla la suma de a y b.
PROCEDIMIENTOS o SUBRUTINAS
Un procedimiento o subrutina es un subalgoritmo que recibiendo o no datos permite devolver varios resultados, un resultado o ninguno.
Un procedimiento está compuesto por un grupo de sentencias a las que asigna un nombre (identificador o simplemente nombre del procedimiento) y constituye una unidad de programa.
La tarea asignada al procedimiento se ejecutará siempre que se encuentre el identificador (nombre del procedimiento) en el conjunto de sentencias que definen el programa.
Cómo trabajar con procedimientos?
- Declaración de un procedimiento
- Llamada a un procedimiento
Dónde escribir un procedimiento?
- Transferencia de información a/desde procedimientos: parámetros
- Ventajas de utilizar un procedimiento.
Declaración de un procedimiento
La declaración de un procedimiento no indica a la computadora que ejecute las instrucciones dadas, sino que indica a la computadora cuáles son estas instrucciones y dónde están localizadas cuando sea necesario.
Nombre: identificador válido Lista de parámetros formales: parámetros formales del procedimiento; sirven para pasar información al procedimiento y/o devolver información del procedimiento a la unidad de programa que le invoca.
Están separados por comas, y precedidos por las letras E (entrada), S (Salida) o E/S (Entrada/Salida)
Llamada al procedimiento Los procedimientos se llaman dentro de un programa o de otro procedimiento directamente por su nombre, de acuerdo a los formatos 1 o 2
La sentencia nombre indica la ejecución del procedimiento cuyo identificador coincide con nombre. Después que ha terminado la ejecución, se ejecuta la sentencia que sigue a la llamada al procedimiento.
En resumen, un procedimiento, al igual que un programa, consta de tres partes:
- Una cabecera del procedimiento que proporciona el nombre del mismo y, caso de existir, una lista de parámetros formales.
- Una sección de declaración que puede contener constantes variables, etc.
- Una sección ejecutable: cuerpo de acciones del procedimiento.
Este último procedimiento recibe como información el radio del círculo y devuelve el área del mismo. r es una variable de entrada: tiene un valor definido previamente (parámetro actual) A es una variable de salida: no tiene un valor asignado previamente y su valor es definido en por el conjunto de acciones del procedimiento. Dónde escribir el procedimiento? La posición adecuada de dónde escribir el procedimiento depende del lenguaje de codificación elegido. En seudocódigo, será indistinto el orden en que se escriben el algoritmo y los subalgoritmos.
En este ejemplo, adoptamos arbitrariamente escribirlo luego del programa principal.
Programa Círculo
Variables
Real : radio, area
Inicio
Escribir('ingrese radio del círculo')
Leer(radio)
Superficie(radio, area)
Escribir('el área del círculo es',area)
fin
Subrutina Superficie(E: r: real , S: A: real)
Inicio
A <-3. 1415192 * r ^2
Fin subrutina Transferencia de información a/desde procedimientos: parámetros Un parámetro es un método para pasar información – valores a variables – del programa principal a un procedimiento.
Procedimientos sin parámetros: no existe comunicación entre el programa principal y los procedimientos o entre dos procedimientos. Procedimientos con parámetros: existe comunicación entre el programa principal y los procedimientos o entre dos procedimientos.
Parámetros actuales y parámetros formales Las acciones que contienen el llamado al procedimiento constan de dos partes: un identificador (nombre del procedimiento) y una lista de parámetros actuales
Nombre (par1, par2, par3, ….)
Los parámetros actuales par1, par2, etc. Contienen los valores que se transferirán al procedimiento. En la declaración de un procedimiento, cuando se incluyen los parámetros, éstos se denominan parámetros formalesparf1,parf2, parf3, etc.
Ellos sirven para contener los valores de los parámetros actuales cuando se invoca al procedimiento.
Procedimiento Nombre (parf1, parf2, parf3, …)
Los parámetros actuales y formales deben coincidir en números, tipo y orden. Es decir debe existir correspondencia entre los parámetros actuales y formales
Parámetros valor y referencia (variable) Paso por VALOR: Los valores iniciales se proporcionan copiando los valores correspondientes en la lista de parámetros actuales. Paso por REFERENCIA: Se produce el paso de la dirección del parámetro actual.
En realidad se pasa la posición de memoria. Es decir que una variable pasada por referencia puede ser modificada dentro del subprograma y producir un efecto en el programa de llamada. Utilizaremos la palabra reservada var para indicar este tipo de paso.
Parámetros valor y referencia (variable)
Qué diferencias encuentra en el valor de C?
Parámetros valor y referencia (variable) La ejecución del algoritmo EJEMPLO utilizando:
- •PASO POR VALOR da como resultado un valor de C = 17 dado que el valor de la variables C en el programa principal no es afectada por los cambios en el procedimiento ya que esta fue pasada por valor, y por consiguiente el procedimiento no transmite su resultado.
- •PASO POR REFERENCIA el valor escrito en la pantalla del ordenador será C = 12.
La primera acción que realiza el procedimiento es la asignación de los valores iniciales a las variables x, y, z, v los cuales son 3, 3, 8, 17 respectivamente haciendo la aclaración IMPORTANTE que como las variables x e y como fueron pasadas por referencia y el valor inicial es el mismo dado por el valor almacenado en A, se corresponden a la misma posición de memoria.
Este hecho es fundamental a la hora de justificar el resultado del procedimiento ya que cuando de produce la asignación x ← x +1 el valor de x es 4, pero también lo será el valor de y, consecuentemente la próxima acción v ← y + z equivale a 12 = 4 + 8.
Ejercicio 1
Ejercicios de Aplicación–Primera parte1. Ejercicios de aplicación1) Implementar un algoritmo que permita representar información sobre la compra de un artículo. Cada artículo tiene un código, nombre y precio.
El algoritmo debe calcular y mostrar por pantalla el valor final de la compra. Se debe ingresar la información del artículo y la cantidad. Considerar la aplicación de impuestos por un valor de 21 % del subtotal.
algoritmo registros _ compra _ articulo
tipo
registro: registroArticulo
inicio
entero: codigo
cadena: nombre
real: precio
fin -registro
registro: registroCompra
inicio
registroArticulo: articulo
entero: cantidad
real: impuestos, subtotal, total
fin -registro
var
registroCompra: compra
const
real: porcentajelmpuestos <-0.21
inicio
mostrar("Cálculo de la compra de un articulo")
Mostrar("ingrese el nombre del articulo")
leer(compra.articulo.nombre)
Mostrar("ingrese el código del articulo")
leer compra. articulo.codigo)
Mostrar("ingrese el precio del articulo")
Leer(compra. articulo.precio)
Mostrar("ingrese la cantidad de articulos a comprar')
leer( compra.cantidad)
Compra.subtotal <-compra,articulo.precio * compra.cantidad
Compra.impuestos <-compra.subtotal * porcentajelmpuestos
Compra.total <-compra.subtotal + compra.impuestos
mostrar("El valor final de la compra es: compra, total)
FinEjercicio 2
algoritmo que permita representar la información de cinco alumnos. Para cada alumno, se debe ingresar la siguiente información: apellido,nota1, nota2, nota3, promedio. El algoritmo debe mostrar el alumno con mayor promedio y la cantidad de alumnos que superan el promedio de 4. (Nota: esta versión del algoritmo considera que los promedios más altos de los alumnos no se repiten, ya que siempre se muestra un único alumno como promedio más alto).
algoritmo registros_alumnos
tipo
registro: registroAlumno
inicio
cadena: apellido
vectorNotas: notas
real: promedio
fin -registro
Array[1…10] de registroAlumno: vectorAlumnos
arraya [1...3] de real: vectorNotas
var
entero: cantidadMayorPromedio4
vectorAlumnos: listadoAlumnos
registroAlumno: alumnoMayorPromedio
const
entero: cantidadAlumnos <- 5
inicio
cargarAlumnos(listadoAlumnos)
alumnoMayorPromedio <- buscarMayorpromedio(listadoAlumnos)
mostrar("El alumno con mayor promedio es ", alumnoMayorPromedio.apellido, "y su apellido es", alumnoMayorPromedio.promedio)
cantidadMayorPromedio4 <- buscarPromedioMayor4(listadoAlumnos)
mostrar("La cantidad de alumnos que superan el promedio de 4 es " cantidadMayorPromedio4)
Fin
procedimiento cargarAlumnos(vectorAlumnos: listadoAlumnos por referencia)
Var
entero: i, j
incio
mostrar("Carga de datos de alumnos")
desde i <- 1 hasta cantidadAlumnos hacer
mostrar("lngrese apellido del alumno ", i)
leer(listadoAlumno[i]. apellido)
desde j <-1 hasta 3 hacer
mostrar("lngrese la nota ", i, " del alumno", listadoalumno[i].apellido)
Leer(listadoalumnos[i].notas[j])
fin-desde
asignarPromedioalumno(listadoalumno[i])
fin -desde
fin-procedimiento
registroAlumno funcion buscarMayorPromedio(vectorAlumnos: listadoAlumnos)
Var
entero: i
registroAlumno: alumnoMayorPromedio
inicio
alumnoMayorPromedio<- listadoAlumnos[1]
desde i <- 2 hasta cantidadAlumnos hacer
si listadoAlumnos[i].promedio > alumnoMayorPromedio.promedio entonces
alumnoMayorPromedio <- listadoAlumnos[i]
fin -si
fin -desde
devolver(alumnoMayorPromedio)
fin-funcion
entero funcion buscarPromedioMayor4(vectorAlumnos: listadoAlumnos)
var
entero: i, cantidad
inicio
cantidad <-0
desde i <- 1 hasta cantidadAlumnos hacer
si listadoAlumnos[i].promedio > 4 entonces
cantidad <- cantidad + 1
fin -si
fin -desde
devolver(cantidad)
fin-función
procedimiento asignarpromedioAlumno(registroAlumno: alumno por referencia)
var
entero: i
real: suma, promedio
inicio
suma <-0
desde i <- 1 hasta 3 hacer
suma<- suma + alumno.notas[i]
fin -desde
promedio <- suma/ 3
alumno. promedio <- promedio
fin - procedimiento
Ejercicio 3
algoritmo que permita manipular la siguiente información de trabajadores:-apellido;-número de horas trabajadas;-precio por hora trabajada;-sexo (codificado por masculino: ‘M’ y femenino: ‘F’).
Cada trabajador debe ser representado mediante un registro. La información debe ser ingresada por el usuario del programa y se debe mostrar por pantalla: la remuneración promedio;-la mayor remuneración;-la remuneración promedio de los trabajadores de sexo femenino;-cantidad de trabajadores que perciben una remuneración por encima del promedio.
algoritmo registros_trabajadores
tipo
registro: registroTrabajador
inicio
cadena: apellido
entero: horasTrabajadas
real: precioHora
caracter: sexo
fin -registro
array[1…100] de registroTrabajador: vectorTrabajadores
var
entero: cantidadTrabajadores
vectorTrabajadores: listado
real: promedioRemuneracionFemenino
registro Trabajador: trabajadorMayorRem
inicio
mostrar("lngrese la cantidad de trabajadores que va cargar")
leer(cantidadTrabajadores)
cargarTrabajadores(listado, cantidadTrabajadores)
promedioRemuneracion <- calcularRemuneracionPromedio(listado, cantidadTrabajadores)
mostrar("La remuneración promedio es ", promedioRemuneracion)
trabajadorMayorRem <- calcularMayorRemuneracion(listado, cantidadTrabajadores)
mostrar("El trabajador con mayor remuneración es trabajadorMayorRem.apellido, " " y su remuneración es ", calcularRemuneracionTrabajador(trabajadorMayorRem))
promedioRemuneracionFemenino <- calcularRemPromedioFemenino(listado, cantidadTrabajadores)
mostrar("La remuneración promedio de las trabajadoras es " promedioRemuneracionFemenino)
mostrarTrabajadoresMayorPromedio(listado, cantidadTrabajadores)
Ejercicio 4
procedimiento cargarTrabajadores(vectorTrabajadores: listado por referencia, entero: N)
Var
entero: i
inicio
mostrar("Carga de datos de trabajadores")
desde i <- 1 hasta N hacer
mostrar("lngrese el apellido del trabajador i)
Leer(listado[i].apellido)
mostrar("lngrese el número de horas trabajadas del trabajador ", listado[i]. apellido)
Leer(listado[i].horasTrabajadas)
mostrar("lngrese el precio por hora del trabajador ", listado[i].apellido)
Leer(listado[i].precio.Horas)
mostrar("lngrese el sexo (masculino='M' - femenino= 'F') del trabajador " , listado[i]. apellido)
Leer(listado[i].sexo)
fin -desde
fin-procedimiento
real funcion calcularRemuneracionPromedio(vectorTrabajadores: listado, entero: N)
var
entero: i
real: suma, promedio
Inicio
suma <- 0
desde i <- 1 hasta N hacer
suma <- suma + calcularRemuneracionTrabajador(listado[i])
fin -desde
promedio <- suma /N
devolver(promedio)
fin-funcion
registro Trabajador funcion calcularMayorRemuneracion(vectorTrabajadores: listado, entero: N)
var
entero: i
registroTrabajador: trabajadorMayorRemuneracion
inicio
trabajadorMayorRemuneracion <- listado[1]
desde i <- 2 hasta N hacer
si calcularRemuneracionTrabajador(listado[i]) > calcularRemuneracion Trabajador(trabajadorMayorRemuneración) entonces
trabajadorMayorRemuneracjon <- listado[i]
fin -si
fin -desde
devolver(trabajadorMayorRemuneracion)
fin-funcion
real funcion calcularRemuneracionpromedio(vectorTrabajadores: listado, entero: N)
var
entero: i
real: sumaRemuneracion, promedioRemuneracion
inicio
sumaRemuneracion <- 0
desde i <- 1 hasta N hacer
sumaRemuneracion <- sumaRemuneracion + calcularRemuneracionrrabajador(listado[i])
fin -desde
promedioRemuneracion <- sumaRemuneracion / N
devolver promedioRemuneracion
fin-funcion
real funcion calcularRemPromedioFemenino(vectorTrabajadores: listado, entero: N)
Var
entero: i, cantidad
real: suma, promedio
inicio
suma <- 0
cantidad <- 0
desde i <- 1 hasta N hacer
Si listado{i}.sexo == 'F' entonces
suma <- suma + calcularRemuneracionTrabajador(listado[i])
cantidad <- cantidad + 1
fin -si
fin -desde
promedio <- suma / cantidad
devolver(promedio)
fin-funcion
procedimiento mostrarTrabajadoresMayorPromedio(vectorTrabajadores: listado, entero: N)
var
entero: i
real: remuneracionpromedio
inicio
remuneracionpromedio <- calcularRemuneracionPromedio(listado, N)
desde i <- hasta N hacer
si calcularRemuneracionTrabajador(listado[i]) > remuneracionPromedio entonces
mostrar("El trabajador ", listado[i].apellido, "tiene una remuneración mayor al promedio. Su remuneración es: ", calcularRemuneracionTrabajador(listado[i]))
fin -si
fin -desde
fin- procedimiento
real funcion calcularRemuneracionTrabajador(registroTrabajador: trabajador)
var
real: remuneracion
inicio
remuneracion <- trabajador.horasTrabajadas * trabajador.precioHora
devolver(remuneracion)
fin-funcion
Paso de Parámetros
Los parámetros son vías de comunicación entre el algoritmo y los subalgoritmos de un programa más complejo. Estas vías de comunicación pueden ser unidireccionales o bidireccionales. Es decir información de entrada, o información de salida del subalgoritmo o información bidireccional es decir de entrada y de salida del subalgoritmo. Es necesario aclarar los conceptos referidos a variables locales y globales.
Una variable local es aquella que está declarada y definida dentro de un subprograma, en el sentido de que está declarada dentro de la parte var del subalgoritmo y es distinta de las variables con igual nombre y tipo que está declarada en la sección var del algoritmo principal. Es más si otro subalgoritmo, declara y usa una variable del mismo tipo y nombre que otro subalgoritmo, no hay conflicto entre estas variables, pues pertenecen a ámbitos distintos.
El significado de una variable se confina al procedimiento en el que está declarada. Una variable global es aquella que está declarada para el programa o algoritmo principal, del que dependen todos los subprogramas. La parte del programa en la que una variable se define, se llama ámbito.
Ventajas del uso de variables locales
El uso de variables locales tiene sus ventajas. Usar variables locales en lugar de globales, hace a los subprogramas independientes, pues la comunicación entre programa y subprograma se realiza a través de los parámetros. Para usar un subalgoritmos solo tenemos que saber qué hace y no como lo hace.
Una variable local a un procedimiento no tiene ningún significado en otros subprogramas, por el contrario, las variables globales tienen la característica de compartir información de diferentes subprogramas, sin estar presente entre los parámetros. Los lenguajes que admiten variables locales y globales suelen tener la posibilidad explícita de definir dichas variables como tales en el cuerpo del programa, o definir su ámbito de actuación.
Los parámetros actuales son los que aparecen entre paréntesis en la invocación del subalgoritmo dentro del algoritmo principal. Mientras que los parámetros formales son los que se encuentran entre paréntesis en la definición del subalgoritmo
COMUNICACIÓN CON SUBPROGRAMAS: PASO DE PARÁMETROS
Cuando un programa llama (invoca) a un subprograma, la información se comunica a través de la lista de parámetros y se establece una correspondencia automática entre los parámetros formales y actuales. Los parámetros actuales son “sustituidos” o “utilizados” en lugar de los parámetros formales.
La correspondencia se establece aparejando los parámetros reales y formales según su posición en las listas: así, Fi se corresponde con Ai donde i = 1, 2, …, n. Este método tiene algunas desventajas de legibilidad cuando el número de parámetros es grande.
Paso de parámetros
Existen diferentes métodos para la transmisión o el paso de los parámetros a subprogramas. Es preciso conocer el método adoptado por cada lenguaje, ya que la elección puede afectar a la semántica del lenguaje. Dicho de otro modo, un mismo programa puede producir diferentes resultados bajo diferentes sistemas de paso de parámetros.
Los métodos más empleados para realizar el paso de parámetros son: paso por valor (también conocido por parámetro valor) paso por referencia o dirección (también conocido por parámetro variable)
Paso por valor
El paso por valor se utiliza en muchos lenguajes de programación; por ejemplo, Modula-2, Pascal, C\ C++, Algol, Snobol. La razón de su popularidad es la analogía con los argumentos de una función, donde los valores se proporcionan en el orden de cálculo de resultados. Los parámetros se tratan como variables locales y los valores iniciales se proporcionan copiando los valores de los correspondientes argumentos.
Los parámetros formales -locales a la función- reciben como valores iniciales los valores de los parámetros actuales y con ello se ejecutan las acciones descritas en el subprograma. No se hace diferencia entre un argumento que es variable, constante o expresión, ya que sólo importa el valor del argumento.
Aunque el paso por valor es sencillo, tiene una limitación acusada: no existe ninguna otra conexión con los parámetros actuales, y entonces los cambios que se produzcan por efecto del subprograma no producen cambios en los argumentos originales y, por consiguiente, no se pueden pasar valores de retorno al punto de llamada: es decir, todos los parámetros son sólo de entrada. El parámetro actual no puede modificarse por el subprograma.
Cualquier cambio realizado en los valores de los parámetros formales durante la ejecución del subprograma se destruye cuando se termina el subprograma. La llamada por valor no devuelve información al programa que llama.
Paso por referencia
En numerosas ocasiones se requiere que ciertos parámetros sirvan como parámetros de salida, es decir, se devuelvan los resultados a la unidad o programas que llama. Este método se denomina paso por referencia o también de llamada por dirección o referencia. La unidad que llama pasa a la unidad llamada la dirección del parámetro actual (que está en el ámbito de la unidad llamante).
Una referencia al correspondiente parámetro formal se trata como una referencia a la posición de memoria, cuya dirección se ha pasado. Entonces una variable pasada como parámetro real es compartida, es decir, se puede modificar directamente por el subprograma. Si el parámetro actual es una expresión, el subprograma recibe la dirección de la posición temporal que contiene el valor de la expresión.
Este método existe en VB, C++, Delphi, FORTRAN, COBOL, Modula-2, Pascal, PL/1 y Algol 68. La característica de este método se debe a su simplicidad y su analogía directa con la idea de que las variables tienen una posición de memoria asignada desde la cual se pueden obtener o actualizar sus valores.
El área de almacenamiento (direcciones de memoria) se utiliza para pasar información de entrada y / o salida; en ambas direcciones. En este método los parámetros son de entrada / salida y los parámetros se denominan parámetros variables.
Los parámetros por valor y los parámetros por variable se suelen definir en la cabecera del subprograma. En el caso de lenguajes como Pascal, los parámetros variables deben ir precedidos por la palabra clave var; en nuestros ejemplos se indicará expresamente el método de paso con líneas comentario.
La llamada por referencia es muy útil para parámetros donde se necesita la comunicación del valor en ambas direcciones.
NOTAS:
Ambos métodos de paso de parámetros se aplican tanto a la llamada de funciones como a las de procedimientos. Una función tiene la posibilidad de devolver los valores al programa principal de dos formas:
- valor de la función
- argumentos gobernados por la llamada de referencia en la correspondencia parámetro actual-parámetro formal.
Un procedimiento sólo puede devolver valores por referencia.
Síntesis de la transmisión de parámetros
Los métodos de transmisión de parámetros más utilizados son: por valor y por referencia. El paso de un parámetro por valor significa que el valor del argumento —parámetro actual o real— se asigna al parámetro formal. En otras palabras, antes de que el subprograma comience a ejecutarse, el argumento se evalúa a un valor específico (por ejemplo, 8 ó 12). Este valor se copia entonces en el correspondiente parámetro formal dentro del subprograma.
Una vez que el procedimiento arranca, cualquier cambio del valor de tal parámetro formal no se refleja en un cambio en el correspondiente argumento. Esto es, cuando el subprograma se termine, el argumento tendrá exactamente el mismo valor que cuando el subprograma comenzó, con independencia de lo que haya sucedido al parámetro formal. Estos parámetros de entrada se denominan parámetros valor.
El paso de un parámetro por referencia o dirección, llamado parámetro variable, en oposición al parámetro por valor. En este caso, la posición o dirección (no el valor) del argumento o parámetro actual se envía al subprograma. Si a un parámetro formal se le da el atributo de parámetro variable y si el parámetro actual es una variable, entonces un cambio en el parámetro formal se refleja en un cambio en el correspondiente parámetro actual, ya que ambos tienen la misma posición de memoria.
Es importante volver a recordar que:
Las variables locales se declaran dentro de un módulo o subalgoritmo y sólo tienen utilidad dentro de ese módulo, no se podrá acceder a ellas desde otros módulos. Pueden existir variables locales con el mismo nombre siempre que estén en módulos diferentes. Los parámetros por valor son variables locales.
Las variables globales son declaradas de forma que puedan ser utilizadas (consultada y/o modificada) desde cualquiera de los módulos que forman el programa. En este caso, no puede haber dos variables globales con el mismo nombre, ya que esto produciría una ambigüedad que el compilador no podría resolver. En el diseño estructurado de algoritmos se desaconseja el uso de variables globales. Las variables globales no pueden ser parámetros de subalgoritmos.
No te detengas, sigue avanzando
Aquí tienes un propósito para este 2024 que debes considerar seriamente: si has querido mejorar tus habilidades en hacking, Ciberseguridad y programación ahora es definitivamente el momento de dar el siguiente paso. ¡Desarrolla tus habilidades aprovechando nuestros cursos a un precio increíble y avanza en tu carrera!
Python Practicando. Desde 0 hasta Desarrollador en Python
Aprende Python, donde iniciamos desde 0, sin conocimientos previos hasta desarrollar aplicaciones con mucha practica!
Calificación: 4,6 de 5 (20.833 calificaciones) 249.493 estudiantes Creado por Alvaro Chirou • 1.800.000+ Enrollments Worldwide, Walter Coto || +450,000 Estudiantes Español.
Lo que aprenderás
- Ejercitar la lógica de programación
- Comprender cómo la vida cotidiana puede ser fácilitada o simulada con código
- Aprender programación desde cero
- Usar Visual Studio Code como Editor de Código
- Conocer y aprender el lenguaje de programación Python
- Ser un programador desde cero, sin conocimiento en otro lenguaje o con algo previo
- Mejorar las habilidades de programación, mejorar procesos y fácilitar la comprensión de código
- Preparar un entorno dónde programar en Python
- Operaciones aritméticas y jerarquía de Python
- Manejo de cadenas en Python
- Digitar datos por teclado con Python
- Mostrar Datos por Pantalla al usuario en Python
- Operadores Relacionales de Python
- Operadores Lógicos de Python
- Condicionales en Python
- Estructuras de Datos: Listas, Tuplas y Diccionarios
- Iteraciones y bucles repetitivos de Python
- Segmentar Código y hacerlo más eficaz con las Funciones en Python
- Gestionar posibles errores que puedan dar tus programas
- Programación Orientada a Objetos
- HTML y CSS
- Selenium Web Driver con Python
- Ejercitar todo lo Aprendido con Ejercicios
Este curso incluye:
- 25,5 horas de vídeo bajo demanda
- 21 artículos
- 148 recursos descargables
- Acceso en dispositivos móviles y TV
- Certificado de finalización
Python es Hoy uno de los lenguajes más utilizados por Excelencia.
Esto se debe por su simpleza al momento de Desarrollar aplicaciones.
Por su capacidad de procesamiento a altas velocidades con grandes volúmenes de información.
Es un increíble lenguaje con el cual si no sabes programar, podrás aprender.
Y si ya sabes desarrollar, te aconsejo aprenderlo ya que en el mercado cada vez se solicitan más desarrolladores en Python.
Aspirar al trabajo que desean, o mejorar sus ingresos con un aumento de salario.
Python se utiliza para muchisimas cosas como:
- Machine Learning
- Data Science
- Inteligencia Artificial.
- Y mucho más!
En este curso te acompañare en el proceso por el cual aprenderás las bases del lenguaje, para luego determinar qué camino quieres seguir.
Te invito que me acompañes a conocer este Gran Lenguaje!
Aprende con nuestros más de 100 cursos que tenemos disponibles para vos
¿Te gustaría enterarte de cuando lanzamos descuentos y nuevos cursos?
Sobre los autores
Álvaro Chirou
Yo soy Álvaro Chirou, tengo más de 20 Años de experiencia trabajando en Tecnología, eh dado disertaciones en eventos internacionales como OWASP, tengo más de 1.800.000 estudiantes en Udemy y 100 formaciones profesionales impartidas en la misma. Puedes serguirme en mis redes:
Laprovittera Carlos
Soy Laprovittera Carlos. Con más de 20 años de experiencia en IT brindo Educación y Consultoría en Seguridad de la Información para profesionales, bancos y empresas. Puedes saber más de mi y de mis servicios en mi sitio web: laprovittera.com y seguirme en mis redes:
¿Quieres iniciarte en hacking y ciberseguridad pero no sabes por dónde empezar? Inicia leyendo nuestra guia gratuita: https://achirou.com/como-iniciarse-en-ciberseguridad-y-hacking-en-2024/ que te lleva de 0 a 100. Desde los fundamentos más básicos, pasando por cursos, recursos y certificaciones hasta cómo obtener tu primer empleo.