Índice

5. Arreglos y archivos ................................................................................................... 2

5.1. Arreglo unidimensionales .................................................................................. 2
5.2. Arreglo bidimensionales .................................................................................... 6
5.3. Archivos............................................................................................................. 10
5.4. Elaboración de programas ............................................................................... 12
6. Funciones ................................................................................................................ 14
6.1. Introducción ...................................................................................................... 14
6.2. Funciones estándar .......................................................................................... 16
6.3. Entrada y salida de datos ................................................................................. 17
6.4. Funciones definidas por el usuario ................................................................. 19
6.5. Pase por valor ................................................................................................... 21
6.6. Pase por referencia ........................................................................................... 24
6.7. Punteros ............................................................................................................ 25
6.8. Elaboración de programas ............................................................................... 26
Bibliografía .................................................................................................................. 29
Libros ........................................................................................................................ 29
Páginas de internet .................................................................................................. 29
5. Arreglos y archivos
5.1. Arreglo unidimensionales

Los arreglos son una colección de variables del mismo tipo que se referencian utilizando
un nombre común. Un arreglo consta de posiciones de memoria contigua. La dirección
más baja corresponde al primer elemento y la más alta al último. Un arreglo puede tener
una o varias dimensiones. Para acceder a un elemento en particular de un arreglo se usa
un índice. El formato para declarar un arreglo unidimensional es:

Tipo nombre_arr [ tamaño ]

Por ejemplo, para declarar un arreglo de enteros llamado a con diez elementos se hace
de la siguiente forma:

Int a[10]; En C, todos los arreglos usan cero como índice para el primer elemento. Por
tanto, el ejemplo anterior declara un arreglo de enteros
condiez elementos desde a[0] hasta a[9]. La forma como pueden seraccesados los
elementos de un arreglo, es de la siguiente forma:

a[2] = 15; /* Asigna 15 al 3er elemento del arreglo a*/

num = a[2]; /* Asigna el contenido del 3er elemento a la variable num */ El lenguaje C no
realiza comprobación de contornos en los arreglos. En el caso de que sobrepase el final
durante una operación de asignación, entonces se asignarán valores a otra variable o a
un trozo del código, esto es, si se dimensiona un arreglo de tamaño N, se puede
referenciar el arreglo por encima de N sin provocar ningún mensaje de error en tiempo
de compilación o ejecución, incluso aunque probablemente se provoque un error en el
programa. Como programador se es responsable de asegurar que todos los arreglos
sean lo suficientemente grandes para guardar lo que pondrá en ellos
el programa. C permite arreglos con más de una dimensión, el formato general es:

tipo nombre_arr [ tam1 ][ tam2 ] ... [ tamN]; Por ejemplo un arreglo de enteros
bidimensionales se escribirá como:

pág. 2
int b[50][50]; Observar que para declarar cada dimensión lleva sus propios paréntesis
cuadrados.

Para acceder los elementos se procede de forma similar al ejemplo del arreglo
unidimensional, esto es,

b[2][3] = 15; /* Asigna 15 al elemento de la 3ª fila y la 4ª columna*/

num = b[25][16]; A continuación se muestra un ejemplo que asigna al primer elemento

de un arreglo bidimensional cero, al siguiente 1, y así sucesivamente.

main() { int t,i,num[3][4];

for(t=0; t<3; ++t) for(i=0; i<4; ++i) num[t][i]=(t*4)+i*1;

for(t=0; t<3; ++t){ for(i=0; i<4; ++i) printf("num[%d][%d]=%d ",

t,i,num[t][i]); printf("\n"); }

En C se permite la inicialización de arreglos, debiendo seguir el siguiente formato:

tipo nombre_arr[ tam1 ][ tam2 ] ... [ tamN] = {lista-valores};

Por ejemplo:

int c[10] = {1,2,3,4,5,6,7,8,9,10};

int num[3][4]={0,1,2,3,4,5,6,7,8,9,10,11}

ARREGLOS:
Las estructuras de datos que hemos visto hasta ahora (listas, tuplas, diccionarios,
conjuntos) permiten manipular datos de manera muy flexible. Combinándolas y
anidándolas, es posible organizar información de manera estructurada para representar
sistemas del mundo real.

En muchas aplicaciones de Ingeniería, por otra parte, más importante que la

organización de los datos es la capacidad de hacer muchas operaciones a la vez sobre
grandes conjuntos de datos numéricos de manera eficiente.

pág. 3
Algunos ejemplos de problemas que requieren manipular grandes secuencias de
números son: la predicción del clima, la construcción de edificios, y el análisis de
indicadores financieros entre muchos otros.

La estructura de datos que sirve para almacenar estas grandes secuencias de números
(generalmente de tipo float) es el arreglo.

Los arreglos tienen algunas similitudes con las listas: los elementos tienen un orden y se
pueden acceder mediante su posición, los elementos se pueden recorrer usando un ciclo
for.
Sin embargo, también tienen algunas restricciones: todos los elementos del arreglo
deben tener el mismo tipo, en general, el tamaño del arreglo es fijo (no van creciendo
dinámicamente como las listas), se ocupan principalmente para almacenar datos
numéricos.
Los arreglos son los equivalentes en programación de las matrices y vectores
de las matemáticas. Precisamente, una gran motivación para usar arreglos es que hay
mucha teoría detrás de ellos que puede ser usada en el diseño de algoritmos para
resolver problemas verdaderamente interesantes.

Crear arreglos
El módulo que provee las estructuras de datos y las funciones para trabajar con arreglos
se llama NumPy, y no viene incluido con Python, por lo que hay que instalarlo por
separado.

El tipo de datos de los arreglos se llama array. Para crear un arreglo nuevo, se puede
usar la función array pasándole como parámetro la lista de valores que deseamos
agregar al arreglo:
>>>a= a r r a y ( [ 6,1,3,9,8])
>>>a
array([6, 1, 3, 9, 8])

pág. 4
Todos los elementos del arreglo tienen exactamente el mismo tipo. Para crear un arreglo
de números reales, basta con que uno de los valores lo sea:
>>>b= a r r a y ( [ 6.0,1,3,9,8])
>>>b
array([ 6., 1., 3., 9., 8.])
Otra opción es convertir el arreglo a otro tipo usando el método astype:
>>>aa r r a y ( [ 6 , 1 , 3 , 9 , 8 ] )
>>>a.a s t y p e ( float)
array([ 6., 1., 3., 9., 8.])
>>>a.a s t y p e ( complex)
array([ 6.+0.j, 1.+0.j, 3.+0.j, 9.+0.j, 8.+0.j])

Funciones sobre arreglos

NumPy provee muchas funciones matemáticas que también operan elemento a

elemento. Por ejemplo, podemos obtener el seno de 9 valores equi espaciados entre 0 y
π/2 con una sola llamada a la función sin:
>>>f r o m n u m p y import linspace, pi, sin
>>>x= l i n s p a c e ( 0, pi/2,9)
>>>xarray([ 0. , 0.19634954, 0.39269908,
0.58904862, 0.78539816, 0.9817477,
1.17809725, 1.37444679, 1.57079633])
>>>s i n ( x )
array([ 0. , 0.19509032, 0.38268343,
0.55557023, 0.70710678, 0.83146961,
0.92387953, 0.98078528, 1. ])
Los valores obtenidos crecen desde 0 hasta 1, que es justamente cómo se comporta la
función seno en el intervalo [0, π /2].
Aquí también se hace evidente otra de las ventajas de los arreglos: al mostrarlos en la
consola o al imprimirlos, los valores aparecen perfectamente alineados. Con las listas,
esto no ocurre:

pág. 5
>>>list( s i n ( x ) )
[0.0, 0.19509032201612825, 0.38268343236508978, 0.5555702330 1
960218, 0.70710678118654746, 0.83146961230254524,
0.9238795 3251128674, 0.98078528040323043, 1.0].

5.2. Arreglo bidimensionales

Los arreglos bidimensionales son tablas de valores. Cada elemento de un arreglo

bidimensional está simultáneamente en una fila y en una columna. En matemáticas, a
los arreglos bidimensionales se les llama matrices, y son muy utilizados en problemas
de Ingeniería. En un arreglo bidimensional, cada elemento tiene una posición que se
identifica mediante dos índices: el de su fila y el de su columna.

Crear arreglos bidimensionales

Los arreglos bidimensionales también son provistos por NumPy, por lo que debemos
comenzar importando las funciones de este módulo

From numpy import*

Al igual que los arreglos de una dimensión, los arreglos bidimensionales también
pueden ser creados usando la función array, pero pasando como argumentos una lista
con las filas de la matriz:
a= a r r a y ( [ [ 5.1,7.4,3.2,9.9],
[1.9,6.8,4.1,2.3],
[2.9,6.4,4.3,1.4]])
Todas las filas deben ser del mismo largo, o si no ocurre un error de valor:
>>>a r r a y ( [ [ 1], [2,3]])
Traceback (most recent call last):
File"<stdin>", line1, in <module>
ValueError : setting an array element with a sequence.

pág. 6
Los arreglos tienen un atributo llamado shape, que es una tupla con los tamaños de
cada dimensión. En el ejemplo, a es un arreglo de dos dimensiones que tiene tres filas y
cuatro columnas:
>>>a.s h a p e
(3, 4)
Los arreglos también tienen otro atributo llamado size que indica cuántos elementos tiene
el arreglo:
>>>a.s i z e
12
Por supuesto, el valor de a.size siempre es el producto de los elementos de a.shape.
Hay que tener cuidado con la función len, ya que no retorna el tamaño del arreglo, sino
su cantidad de filas:
>>>len(a)
3
Las funciones zeros y ones también sirven para crear arreglos bidimensionales. En vez
de pasarles como argumento un entero, hay que entregarles una tupla con las cantidades
de filas y columnas que tendrá la matriz:

>>>z e r o s ( ( 3,2))
array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]])

>>>o n e s ( ( 2,5))
array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
Lo mismo se cumple para muchas otras funciones que crean arreglos; por ejemplo la
función random:
>>>f r o m numpy.random import r a n d o m
>>>r a n d o m ( ( 5,2))
array([[ 0.80177393, 0.46951148],

pág. 7
 [ 0.37728842, 0.72704627],
[ 0.56237317, 0.3491332 ],
[ 0.35710483, 0.44033758],
[ 0.04107107, 0.47408363]])
Operaciones con arreglos bidimensionales
Al igual que los arreglos de una dimensión, las operaciones sobre las matrices se
aplican término a término:
>>>a= a r r a y ( [ [ 5,1,4],
... [0,3,2]])
>>>b= a r r a y ( [ [ 2,3,-1],
... [1,0,1]])

>>>a+ 2
array([[7, 3, 6],
[2, 5, 4]])
>>>a** b
array([[25, 1, 0],
[ 0, 1, 2]])
Cuando dos matrices aparecen en una operación, ambas deben tener exactamente la
misma forma:
>>>a= a r r a y ( [ [ 5,1,4],
... [0,3,2]])
>>>b= a r r a y ( [ [ 2,3],
... [-1,1],
... [0,1]])
>>>a+ b
Traceback (most recent call last):
File"<stdin>", line1, in <module>
V a l u e E r r o r : shape mismatch: objects cannot be broadcast to a single s h a p e

pág. 8
Obtener elementos de un arreglo bidimensional
Para obtener un elemento de un arreglo, debe indicarse los índices de su fila i y su
columna j mediante la sintaxis a[i, j]:
>>>a= a r r a y ( [ [ 3.21, 5.33, 4.67, 6.41],
[ 9.54, 0.30, 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56],
[ 8.19, 2.12, 6.28, 8.76],
[ 8.72, 1.47, 0.77, 8.78]])
>>>a[1,2]
2.14
>>>a[4,3]
8.78
>>>a[-1,-1]
8.78
>>>a[0,-1]
6.41
También se puede obtener secciones rectangulares del arreglo usando el operador de
rebanado con los índices:
>>>a[2:3,1:4]
array([[ 0.54, 0.71, 2.56]])
>>>a[1:4,0:4]
array([[ 9.54, 0.3 , 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56],
[ 8.19, 2.12, 6.28, 8.76]])
>>>a[1:3,2]
array([ 2.14, 0.71])
>>>a[0:4:2,3:0:-1]
array([[ 6.41, 4.67, 5.33],
[ 2.56, 0.71, 0.54]])
>>>a[::4, ::3]
array([[ 3.21, 6.41],

pág. 9
 [ 8.72, 8.78]])
Para obtener una fila completa, hay que indicar el índice de la fila, y poner: en el de las
columnas (significa «desde el principio hasta el final»). Lo mismo para las columnas:
>>>a[2, :]
array([ 5.62, 0.54, 0.71, 2.56])

>>>a[:,3]array ([ 6.41, 6.57, 2.56, 8.76, 8.78])

Note que el número de dimensiones es igual a la cantidad de rebanados que hay en los
índices:
>>>a[2,3] # valor escalar (arreglo de cero dimensiones)
2.56
>>>a[2:3,3] # arreglo de una dimensión de 1 elemento
array([ 2.56])
>>>a[2:3,3:4] # arreglo de dos dimensiones de 1 x 1
array([[ 2.56]])

5.3. Archivos

Los archivos son un mecanismo de abstracción: proporcionan una forma de almacenar

información en el disco y leerla después.
Cuando un proceso crea un archivo, le asigna un nombre.
Cuando el proceso termina, el archivo sigue existiendo y otros procesos pueden acceder
a él utilizando su nombre.

Las reglas exactas para nombrar archivos varían tanto de un sistema a otro, pero todos
los sistemas operativos permiten cadenas de 1 a 8 caracteres como nombres de archivos
válidos. En muchos casos se permite también dígitos y caracteres especiales.
Estructura de Archivos
Los archivos pueden estructurarse de varias maneras. Tres posibles comunes son:
 Secuencia de bytes
 Secuencia de registros

pág. 10
  Árbol
Tipos de Archivos
 Archivos Regulares: Son los que contienen información del usuario.
 Directorios: Son archivos de sistema que sirven para mantener la estructura del
sistema de archivos.
 Archivos Especiales por Caracteres: Están relacionados con E/S y sirven para
modelar dispositivos de E/S en serie.
 Archivos Especiales por Bloques: Sirven para modelar discos.

Acceso a Archivos

Los primeros sistemas operativos solo ofrecían un tipo de acceso a los archivos: Acceso
Secuencial. En estos sistemas, un proceso podía leer todos los bytes o registros de un
archivo en orden, comenzado por el principio, pero no podía saltar de un lado a otro y
leerlos en desorden.

Los archivos cuyos bytes o registros se pueden leer en cualquier orden se

denominan Archivos de Acceso Aleatorio. Los Archivos de Acceso Directo son
esenciales para muchas aplicaciones.

Atributos de Archivos

Todo archivo tiene un nombre y ciertos datos. Además, todos los sistemas operativos
asocian información adicional a cada archivo. Llamamos a estos datos adicionales
Atributos del Archivo. La lista de atributos varía considerablemente de un sistema a otro.

Operaciones con Archivos

Los diferentes archivos ofrecen distintas operaciones de almacenamiento y

recuperación.
Create
Delete

pág. 11
Open
Close
Rea
Write
Append
Seek
Get attributes
Set attributes
Rename

5.4. Elaboración de programas

Ejm:
char c1,c2,c3;
c1 = „a‟; c2 = ‟)‟; c3 = ‟9‟;

Características de caracteres:
 Secuencialidad de los caracteres
 comparar caracteres… c1>c2
 mayúsculas < minúsculas..

Ejemplo:
int i;
for (i=65; i<91; i++)
Ejemplo:
char c;
for (c='a'; c<='z'; c++)

Problemas:
 car1, car3,

pág. 12
  Tabla ascii
 Conversión mayúsculas a minúsculas…

Arreglo de caracteres
char a[N]={'r','u','t','h'};
Problema:
detectar un palíndrome
String:
Cadena de caracteres.
char linea[] = "buenos dias"
b u e n o s d i a s \0
0 1 2 3 4 5 6 7 8 9 10 11

Ejemplos:
 como asignar datos a un string [string1.c]
 ingresa nombre y saluda [string2.c]
 despliega las letras del nombre separadas con un blanco [string3.c]

pág. 13
6. Funciones
6.1. Introducción

Subalgoritmo.
Se le llama así a cada una de las partes de un algoritmo más general que resuelve cada
una de las tareas particulares necesarias para que dicho algoritmo general alcance el
objetivo para el que fue diseñado, es decir resolver un problema.

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.

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.

Función.

También conocido como una subrutina o subprograma, como idea general, se presenta
como un Subalgoritmo que forma parte del algoritmo principal, el cual permite resolver
una tarea específica. Algunos lenguajes de programación, como Visual Basic .NET o
Fortran, utilizan el nombre función para referirse a subrutinas que devuelven un valor.

Una subrutina al ser llamada dentro de un programa hace que el código principal se
detenga y se dirija a ejecutar el código de la subrutina, en cambio cuando se llama a una
macro, el compilador toma el código de la macro y lo implanta donde fue llamado,
aumentando así el código fuente y por consiguiente el objeto.

Elementos de la declaración de una subrutina. Las declaraciones de subrutinas

generalmente son especificadas por:

pág. 14
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.

Por ejemplo un seudocódigo puede ser

Private Sub cmdregre_Click() (programa principal)
Unload Me
End Sub
Sub Sumar(ByRef Valor As Long)
Valor = Valor + 100
End Sub
Private Sub cmdByRef_Click()
Dim Un_Valor As Long
Un_Valor = 100
Call Sumar(Un_Valor)
MsgBox Un_Valor, vbInformation, "Modifica la variable"
End Sub (fin del programa)

Donde se puede ver claramente donde inicia la función del programa y donde termina.

pág. 15
6.2. Funciones estándar

1. Cadenas de caracteres.
Len: Indica la cantidad de caracteres que tiene una determinada cadena.
Lcase y Ucase: Convierte cadenas de texto aminúscula y mayúscula.

2. Con números.
Round: se utiliza para redondear un número decimal, devolviendo un número entero.
Dim Mimumero As Long
Minumero = Round (245.8) '(La función devuelve 246)

3. Fechas
FormatCurrency: Formato en dinero.

Ejemplo:

FormatCurrency(txt1) esto quiere decir que los datos numéricos puestos en el text box
1 se dará en forma de dinero

FormatPercent: Porcentajes.

Ejemplo: FormatPercent(txt2) los datos introducidos en text box 2 se dará en formato de

porcentaje.

pág. 16
4. Presentar mensajes en pantalla

Función InputBox: Presenta un mensaje al usuario, permitiéndole ingresar un valor en

una caja de texto.

6.3. Entrada y salida de datos

La entrada de datos consiste en colocar en la memoria principal datos provenientes

desde algún dispositivo de entrada (teclado, disco, etc.) para que la computadora, de
acuerdo a un programa, realice una tarea. La salida de datos consiste en enviar datos
(que, generalmente, son el resultado de un procesamiento) desde la memoria principal
hacia un dispositivo de salida (pantalla, impresora, disco, etc.).

Esquema conceptual del equipo de cómputo.

 Esquema conceptual del equipo de cómputo La consola

 En los albores de la computación, el teclado y la pantalla formaban laconsola.
 En la actualidad, a la combinación de teclado y pantalla se les sigueconsiderando
como a la antigua consola.
 En C#, la entrada y la salida de datos se pueden manejar a través delos métodos
de la clase Console.
 Entrada de datos desde el tecladoPara la entrada de datos por medio del teclado
se pueden utilizar losmétodos Read( ) y ReadLine( ) de la clase Console.

pág. 17
Ejemplos:

 System.Console.Read( ) ; // Lee el siguiente carácter desde el flujo dela entrada

estándar.
 System.Console.ReadLine( ) ; // Lee la siguiente línea de caracteres desde el flujo
de la entrada estándar.
Salida de datos hacia la pantalla
 La salida de datos hacia la pantalla se puede realizar utilizando los métodos Write
y WriteLine( ) de la clase Console

Ejemplos:

 System.Console.Write( ) ; // Escribe el siguiente carácter en el flujo dela salida

estándar (la pantalla).
 System.Console.WriteLine( ) ; // Escribe la siguiente línea decaracteres en el flujo
de la salida estándar.

Cuadro de Mensaje

Muestra un mensaje en un cuadro de diálogo, espera a que el usuario haga clic en un

botón. Si se emplea como función, devuelve un tipo Integer correspondiente al botón
elegido por el usuario.
La sintaxis es:

MsgBox (mensaje [, botones] [, título] [, archivo Ayuda, contexto])

Cuando MsgBox se emplea como función, devuelve un tipo Integer correspondiente al

botón elegido por el usuario.

Visual-Basic tiene una serie de constantes memo-técnicas que permiten fácilmente

recordar las opciones posibles.

pág. 18
Función InputBox

El InputBox o cuadro de entrada es otro de los cuadros de diálogos utilizados para la

interacción del usuario con la aplicación. El InputBox permite mostrar un cuadro de
diálogo donde el usuario pasará un parámetro, valor o dato para que el programa lo trate
y lo ejecute. El mensaje que quiere que aparezca se realiza de forma casi idéntica al
MsgBox.

La sintaxis es:

InputBox (mensaje [,título][, estándar] [,posx][,posy][, archivo Ayuda , contexto])

Salida de datos
El método Print visualiza datos en un formulario (objeto Form). Así mismo, permite
visualizar datos en la ventana inmediato (a través del objeto Debug), en una caja de
imagen (ControlPictureBox) o en una impresora (utilizando el objeto Printer)
6.4. Funciones definidas por el usuario

Son funciones que el usuario crea para cubrir necesidades que están fuera del alcance
de las funciones estándar. 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. 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.

Además, una misma puede ser llamada muchas veces en un mismo programa, e incluso
puede ser reutilizada por otros programas. Una función es capaz de mantener una gran
independencia con el resto del programa.

Las funciones siempre devuelven un valor al programa que las invocó.

pág. 19
Para llamar a un procedimiento se escribe su nombre en el cuerpo del programa, y si los
necesita, se incluyen los parámetros entre paréntesis. Para invocar una función es
necesario hacerlo en una expresión.

• Existen cuatro formas de pasar un argumento a una función (subrutina) procedimiento:

por valor, por referencia, por valor-resultado y por nombre.

Ventajas de las funciones definidas por el usuario

Las ventajas de utilizar las funciones definidas por el usuario en SQL Server son:

 Permiten una programación modular. Puede crear la función una vez,

almacenarla en la base de datos y llamarla desde el programa tantas veces como
desee. Las funciones definidas por el usuario se pueden modificar,
independientemente del código de origen del programa.
 Permiten una ejecución más rápida.

Al igual que los procedimientos almacenados, las funciones definidas por el usuario
Transact-SQL reducen el costo de compilación del código Transact-SQL almacenando
los planes en la caché y reutilizándolos para ejecuciones repetidas. Esto significa que no
es necesario volver a analizar y optimizar la función definida por el usuario con cada uso,
lo que permite obtener tiempos de ejecución mucho más rápidos.

Las funciones CLR ofrecen una ventaja de rendimiento importante sobre las funciones
Transact-SQL para tareas de cálculo, manipulación de cadenas y lógica empresarial.
Transact-SQL se adecuan mejor a la lógica intensiva del acceso a datos.

 Pueden reducir el tráfico de red.

Una operación que filtra datos basándose en restricciones complejas que no se puede
expresar en una sola expresión escalar se puede expresar como una función. La función
se puede invocar en la cláusula WHERE para reducir el número de filas que se envían
al cliente.

Tipos de funciones

 Función escalar:

pág. 20
Las funciones escalares definidas por el usuario devuelven un único valor de datos del
tipo definido en la cláusula RETURNS. En una función escalar insertada no hay cuerpo
de la función; el valor escalar es el resultado de una sola instrucción. Para una función
escalar de varias instrucciones, el cuerpo de la función, definido en un bloque
BEGIN...END, contiene una serie de instrucciones de Transact-SQL que devuelven el
único valor. El tipo devuelto puede ser de cualquier tipo de datos excepto

Text, ntext, image, cursor y timestamp.

Funciones con valores de tabla

Las funciones con valores de tabla definidas por el usuario devuelven un tipo de datos
table. Las funciones insertadas con valores de tabla no tienen cuerpo; la tabla es el
conjunto de resultados de una sola instrucción SELECT.

 Funciones del sistema

SQL Server proporciona numerosas funciones del sistema que se pueden usar para
realizar diversas operaciones. No se pueden modificar.

6.5. Pase por valor

Pasar por valor implica crear una nueva variable dentro de la función y pasarle una copia
del valor de la variable externa. Si se modifica el valor de la variable copia, la variable
original queda inalterada.

Los tipos de valor incluyen lo siguiente:

Todos los tipos de datos numéricos

Boolean, Char y Date

Todas las estructuras, incluso si sus miembros son tipos de referencia

Las enumeraciones, ya que su tipo subyacente es siempre SByte, Short, Integer, Long,
Byte, UShort, UInteger o ULong.

pág. 21
Pasando datos de tipo básico

Sea la función
void funcion (int x){
x=5;
System.out.println("dentro de la función: a="+x);
}
Sea la variable a que toma inicialmente el valor de 3. ¿Cuál será el valor de
a después de la llamada a la función funcion?

int a=3;
funcion(a)
;System.out.println("después de la llamada: a="+a);

En primer lugar, recordaremos que la función denominada funcion tiene un único

parámetro x, cuyo alcance es desde la llave de apretura hasta la llave de cierre de la
función. La variable x deja de existir una vez que la función retorna.
En este ejemplo el significado de "paso por valor". La variable a toma el valor inicial de
3. Cuando se llama a la función se pasa el valor de a en su único argumento, el valor de
a se copia en el parámetro x, la variable x toma el valor de 3. En el curso de la llamada
a la función, el valor de x cambia a 5, pero cuando la función retorna, la variable x ha
dejado de existir. La variable a no se ha modificado en el curso de la llamada a la función,
y sigue valiendo 3.

Durante el curso de la llamada a la función función, existe la variable a y su copia x, pero

son dos variables distintas, aunque inicialmente guarden el mismo valor.

Pasando objetos
Creamos una clase Entero muy sencilla que tiene como miembro dato un número entero
valor, y un constructor que inicializa dicho miembro público al crearse un objeto de la
clase Entero.

pág. 22
public class Entero {
public int valor;
public Entero(int valor){
this.valor=valor;
}
}
El valor devuelto por new al cear un objeto es una referencia a un objeto en memoria,
que hemos denominado objeto. Creamos un objeto aInt de la clase Entero para guardar
el número tres.

Entero aInt=new Entero(3);

funcion(aInt);

El valor devuelto por New lo guardamos en aInt, y se lo pasamos a la función denominada

función.

void función(Entero xInt){

xInt.valor=5;
}

Dentro de la función denominada función disponemos en xInt de la referencia al objeto

aInt. Como el argumento aInt y el parámetro xInt guardan la referencia al mismo objeto,
es posible modificar dicho objeto en el curso de la llamada a la función, accediendo a sus
miembros públicos. Desde xInt accedemos al miembro público valor para
modificarlo. Cuando la función retorna, el objeto aInt habrá modificado su estado.

public class ValorApp2 {

public static void main(String[] args) {
Entero aInt=new Entero(3);
System.out.println("Antes de llamar a la función");

pág. 23
 System.out.println("objeto.miembro "+aInt.valor);
funcion(aInt);
System.out.println("Después de llamar a la función");
System.out.println("objeto.miembro "+aInt.valor);
}
public static void function(Enter xInt){
xInt.valor=5;}
}

Estos dos ejemplos, nos ponen de manifiesto el significado de la frase "pasar por valor
un dato a una función", y el distinto comportamiento de los tipos básicos de datos, que
no se pueden modificar en el curso de la llamada a la función, de los objetos que si se
pueden modificar. La referencia a un objeto se pasa por valor a la función. Dentro de la
función, desde esta referencia podemos acceder a los miembros públicos de dicho objeto
para modificar su estado. Cuando la función retorna el objeto estará modificado.

6.6. Pase por referencia

Pasar un argumento por referencia implica que en realidad se pasa a la función la

variable original, de modo que la función puede modificar su valor.

Los tipos de referencia incluyen lo siguiente:

String

Todas las matrices, incluso si sus elementos son tipos de valores

Los tipos de clase, como Form

Delegados

pág. 24
6.7. Punteros

Un puntero es un tipo simple que siempre está asociado a otro tipo (punteros a enteros,
a reales, a registros, etc.).

Se pueden ver los punteros como variables que almacenan direcciones de memoria; de
aquí se deduce:

Un puntero es un medio para acceder al contenido “real” apuntado por la variable.

La declaración de un puntero no implica que exista contenido apuntado por la misma. Es
necesario crear y destruir explícitamente el contenido apuntado por punteros. Se puede
establecer una analogía entre los punteros y las direcciones postales: Una dirección
postal permite acceder al lugar físico indicado.

El hecho de disponer de una dirección postal no garantiza que el lugar exista. Para
declarar variables de tipo puntero en la notación algorítmica se utiliza la sintaxis
siguiente: variable puntero a tipo

Por ejemplo:
Puntero a real
Una vez se declara un puntero pueden llevarse a cabo dos acciones básicas sobre el
mismo: Asignarle memoria para almacenar un dato del tipo al que apunta:

Crear

Eliminar la memoria que tiene asignada y con ella el dato apuntado:

Destruir

Crear (variable puntero)

Destruir (variable puntero)

pág. 25
Es posible asignar a un puntero el contenido de otro; para hacer esto es necesario que
la variable a la que vamos a asignar un Valor no apunte a ningún dato pues en ese caso
el dato original Quedaría inaccesible. Así pues, sólo deberíamos asignar un puntero a
otro si el Puntero asignado no tiene memoria reservada.

6.8. Elaboración de programas

Código:

Private Sub cmdconv_Click()

If opt1.Value = True Then
txt1 = UCase(txt1)
opt1.Value = False
End If
If opt2.Value = True Then
txt1 = LCase(txt1)
opt2.Value = False
End If
End Sub
Private Sub cmdend_Click()EndEnd SubPrivate Function suma(num1 As Integer, num2
As Integer) As Integer
Dim resultado As Integer
suma = num1 + num2
End Function

Private Sub cmdsuma_Click()

resultado = suma(175, 25)MsgBox "La suma de 175 + 25 = " & resultado, vbInformation,
"Resultado de funcion"

End Sub

pág. 26
Private Sub Form_Load()

End Sub

Private Sub iblsuma_Click()

resultado = suma(175, 25)

lblsuma.Caption = resultado

End Sub

Pase por valor y pase por referencia

El programa es un enunciado, lógicamente ordenado y clasificado, de los procedimientos

de auditoría que han de emplearse, la extensión que se les ha de dar y la oportunidad
en que se han de aplicar. Dado que los programas de auditoría se preparan
anticipadamente en la etapa de planeación, estos pueden ser modificados en la medida
en que se ejecute el trabajo, teniendo en cuenta los hechos concretos que se vayan
observando.

Se acostumbra a elaborar un programa por cada sección a examinar, el cual debe incluir
por lo menos el programa de trabajo en un sentido estricto y el programa adscrito al
personal del trabajo a realizar. Cada programa permite el desarrollo del plan de trabajo
general, pero a un nivel más analítico, aplicado a un área en particular.

El programa contiene prácticamente la misma información que el plan de trabajo, pero

difiere de este en que se le han adicionado columnas para el tiempo estimado, el tiempo
real, la referencia al papel de trabajo donde quedó plasmada la ejecución del programa,
la rúbrica de quien realizó cada paso y la fecha del mismo.

Por medio de cada programa, el auditor adquiere control sobre el desarrollo del examen,
pues estos además de ser una guía para los asistentes sirven para efectuar una
adecuada supervisión sobre los mismos, permitiendo también determinar el tiempo real
de ejecución de cada procedimiento para compararlo con el estimado y así servir de

pág. 27
pauta para la planeación de las próximas, así mismo, permite conocer en cualquier
momento el estado de adelanto del trabajo, ayudando a la toma de decisiones sobre la
labor pendiente por realizar.

Generalmente el programa de auditoría comprenderá una sección por cada área de los
estados financieros que se examinan. Cada sección del programa de auditoría debe
comprender:

Una introducción que describa la naturaleza de las cuentas examinadas y resuma los
procedimientos de contabilidad de la compañía.
Una descripción de los objetivos de auditoría que se persiguen en la revisión de la
sección.
Una relación de los pasos de auditoría que se consideran necesarios para alcanzar los
objetivos señalados anteriormente.

Esta sección debe tener columnas para indicar la persona que efectúa el trabajo, el
tiempo empleado y referencias cruzadas a las planillas o cédulas donde se realiza el
trabajo.

pág. 28
Bibliografía
Libros
Joyanes Aguilar, Luis. PROGRAMACIÓN EN C+; Algoritmos, estructura de datos y
objetos.
Joyanes Agular, Luis. METODOLOGIA DE LA PROGRAMACION; Diagramas de flujo
de algoritmos y programación estructurada. Pgs, 245.

Páginas de internet
http://profesores.fi-b.unam.mx/cintia/cmn5.pdf

https://es.scribd.com/doc/185569333/Trabajo-de-Investigaciona-Lgoritmo

http://programacionunefa.blogspot.mx/2008/06/arreglos-unidimensionales.html

http://sistemasoperativos.angelfire.com/html/5.3.html

http://sistemasdearchivosyproteccion-vera.blogspot.mx/2008/11/53-componentes-de-
un-sistema-de.html

pág. 29