Tecnológico Nacional de México

Instituto Tecnológico Gustavo A. Madero

Ingeniería Industrial

Algoritmos y Lenguaje de Programación

Profesora Lorena López Sánchez

Actividad 1 Tema 6

Alondra Noemí Domínguez Baca

Contenido
INTRODUCCIÓN............................................................................................................................... 3
Subalgoritmo............................................................................................................................... 3
DESARROLLO.................................................................................................................................. 3
Función........................................................................................................................................ 3
Elementos de una subrutina........................................................................................................ 3
Funciones estándar...................................................................................................................... 4
Entrada y Salida de datos............................................................................................................ 4
Funciones Definidas por el Usuario.............................................................................................. 4
Pase por valor.............................................................................................................................. 5
Pase por referencia...................................................................................................................... 5
Punteros....................................................................................................................................... 5
Referencias:.................................................................................................................................... 6
INTRODUCCIÓN
Subalgoritmo
Cada parte de un algoritmo más general que resuelve cada tarea específica que el
algoritmo general necesita para lograr su objetivo de diseño (es decir, resolver un
problema) se denomina subalgoritmo.

Variables locales: Se declaran en un módulo o subalgoritmo y son útiles sólo en ese

módulo, no se puede acceder a ellas desde otros módulos. Pueden existir variables
locales con el mismo nombre siempre que estén en módulos diferentes.

Variables globales: Se declaran para que puedan ser utilizadas (leídas y/o
modificadas) desde cualquier módulo que conforma el programa. En este caso, no
puede tener dos variables globales con el mismo nombre, porque eso crearía una
confusión que el compilador no puede resolver.

DESARROLLO
Función
También conocido como subrutina o subprograma, como concepto general, un
subalgoritmo es una parte de un algoritmo en estrella que permite resolver una tarea
específica. Algunos lenguajes de programación, como Visual Basic, .NET o Fortran,
utilizan funciones con nombre para hacer referencia a subrutinas que devuelven
valores. Cuando se llama a una subrutina en un programa, hace que el código
principal se detenga e indica a la subrutina que se ejecute, pero cuando se llama a
una macro, el compilador recupera el código de la macro y lo coloca en la ubicación
llamada, incrementando el código fuente.

Una función se puede llamar varias veces e incluso llamarse a sí misma (función de
bucle)

Elementos de una subrutina.

Las declaraciones de subrutinas generalmente son especificadas por:
 - Un nombre único en el ámbito: nombre de la función con el que se identifica y se
distingue de otras.
- Un tipo de dato de retorno: tipo de dato del valor que la subrutina devolverá al
terminar su ejecución
- Una lista de parámetros: especificación del conjunto de argumentos (pueden ser
cero, uno o más) que la función debe recibir para realizar su tarea.
- El código u órdenes de procesamiento: conjunto de órdenes y sentencias que
debe ejecutar la subrutina

Las funciones en programación generalmente son las que realizan los cálculos para
retornar el valor correspondiente a una función matemática.

Funciones estándar.
Las funciones estándar se dividen en grupos y todas las funciones que pertenecen a
un grupo se declaran en un archivo de encabezado. Para incluir funciones
pertenecientes a estos encabezados, necesitamos escribir líneas de código como se
muestra en el ejemplo: #include.
Entrada y Salida de datos.
Proporciona un método para transferir información entre la memoria interna (E/S) y los
dispositivos externos (E/S). Los dispositivos periféricos conectados a una
computadora requieren enlaces de comunicación especiales para actuar como
interfaces con el dispositivo central.
El propósito del enlace de comunicación es resolver las diferencias que existen entre
la computadora host y los diversos dispositivos periféricos. Se denominan interfaces
porque se comunican tanto con los canales del procesador como con los periféricos.
Funciones Definidas por el Usuario.
Algunos objetos le permiten especificar una función que se evaluará durante el
renderizado para determinar la superficie de esos objetos. En este sentido, las
funciones son fundamentalmente diferentes de las macros, que se evalúan durante el
análisis pero no afectan la representación. Además, estas funciones se pueden llamar
en cualquier lugar donde se permitan funciones de punto flotante, incluso durante el
análisis. La sintaxis es la misma que la de las expresiones de punto flotante, pero solo
se pueden utilizar funciones de punto flotante que operan con valores de punto
flotante. Se pueden llamar en consultas u otras declaraciones o expresiones (como
columnas calculadas o expresiones de cadena). Puede utilizar la instrucción
EXECUTE para ejecutar funciones con valores escalares.
Pase por valor.
Pasar por valor significa que cuando se compilan la función y el código que la llama, la
función recibe una copia del valor del parámetro que se le pasa como argumento. Las
variables reales no se pasan a la función, solo una copia de su valor. Los parámetros
deben pasarse por referencia si la función necesita modificar el valor de la variable
pasada como parámetro y devolver esa modificación a la función que llama. Con este
método, el compilador no pasa una copia del valor del parámetro, sino que pasa una
copia del valor del parámetro. En cambio, envía una referencia que le indica a la
función dónde está la variable en la memoria.
Pase por referencia
La referencia resultante de la concatenación es la dirección de la variable. En otras
palabras, pasar parámetros por referencia solo le dice al compilador la dirección del
parámetro pasado. De forma predeterminada, los parámetros de la función se pasan
por valor (por lo que, si cambia el valor de un parámetro dentro de la función, no
cambia fuera de la función). Antes de que una función pueda cambiar sus parámetros,
deben pasarse por referencia.
Punteros.
Un puntero (o puntero) es una variable administrada que hace referencia a una
cadena de memoria; En otras palabras, es una variable cuyo valor es una dirección de
memoria. Si tiene una variable puntero "p" que contiene la dirección de memoria
donde se almacena el valor "v", se dice que "p" apunta a "v".

Paso de variable
Establece una variable local o global en un valor específico. Se pueden crear y utilizar
variables locales y globales en los cálculos. Las variables locales solo se pueden
utilizar en pasos de guión dentro de un guión en ejecución. Las variables globales se
pueden utilizar en cálculos o secuencias de comandos en cualquier parte del archivo,
por ejemplo, secuencias de comandos u otras rutas de archivo. Las variables locales y
globales (o incluso dos variables locales en scripts diferentes) pueden tener el mismo
nombre, pero se consideran variables diferentes y pueden contener valores diferentes.

Conclusión
En conclusión, un subalgoritmo es una componente específica de un algoritmo
general, diseñada para abordar tareas particulares dentro del proceso de resolución
de un problema. Las variables utilizadas en los subalgoritmos pueden ser locales,
restringidas a ese módulo específico, o globales, accesibles desde cualquier módulo
del programa. Las funciones, también conocidas como subrutinas o subprogramas,
representan un tipo especial de subalgoritmo que devuelve valores y puede llamarse
repetidamente, incluso de manera recursiva. Estas funciones se definen mediante un
nombre único, un tipo de dato de retorno, una lista de parámetros, y el código de
procesamiento. Además, existen funciones estándar agrupadas en archivos de
encabezado y funciones definidas por el usuario que permiten evaluaciones durante el
renderizado. La transferencia de datos entre el programa y los dispositivos externos se
realiza mediante interfaces de entrada y salida. En términos de paso de parámetros,
las funciones pueden recibir valores por valor, donde se pasa una copia del dato, o por
referencia, donde se pasa la dirección de memoria del dato. Los punteros son
variables que almacenan direcciones de memoria, permitiendo una gestión más
flexible y dinámica de la memoria en la programación.

Referencias:
Completo, V. mi P. (s/f). Algoritmos y lenguaje de programacion. [Link]. Recuperado el 17 de

mayo de 2024, de [Link]

(pdfcofee, 24)

pdfcofee. (16 de 05 de 24). pdfcofee. Obtenido de [Link]

[Link]

Guest. (2020, junio 21). Unidad 6 “Funciones” Algoritmos y Lenguajes de

Programación. [Link]. [Link]

[Link]