DIVISIÓN DE INGENIERÍA EN SISTEMAS COMPUTACIONALES

INVESTIGACIÓN TERCER PARCIAL

FUNDAMENTOS DE PROGRAMACIÓN

PROFESOR:
ING. OLIVARES LÓPEZ OSCAR

NOMBRE DEL ALUMNO:

NAVARRO JIMÉNEZ CHRISTIAN RICARDO

GRUPO:
311-V

2019-1
 INDICE

Título Página

Introducción 3
Memoria Estática 4
Arrays Unidimensionales 6
Arrays Bidimensionales 9
Arrays Multidimensionales 12
Conclusión 14
Referencias 15
 INTRODUCCIÓN

En el presente trabajo quiero mostrar una investigación un tanto detallada sobre lo que es
la memoria estática, cual es su definición, para que nos sirve, cuales son sus ventajas y sus
desventajas y cuando es posible o no implementarla. También explicaré lo que son los
arrays (arreglos) unidimensionales, bidimensionales y multidimensionales.
Hemos estado trabajando hasta ahorita en lo que va del semestre solo con dos tipos de
arreglos, los unidimensionales y los bidimensionales, y esto se debe a que los programas
que hemos estado haciendo no requieren un uso excesivo de datos y también no requieren
de tanta reserva de memoria para los datos que vamos a utilizar, introducir y generar.
Quiero comentar que hay dos tipos de memoria, la memoria estática y la dinámica, pero en
este trabajo solo me voy a enfocar en la memoria estática, pues ahorita que estamos
iniciando con la programación no tenemos tanto problema en utilizar este tipo de memoria.
Espero que el presente trabajo pueda dar un gran entendimiento de los temas que planeo
explicar.
 MEMORIA ESTÁTICA

Para empezar con este tema y con su entendimiento primero quiero citar diferentes
definiciones y, una vez analizadas, poder dar una definición más general que pueda ser
entendida.
De acuerdo con (Muñoz Celaya, 2014) se le llama memoria estática a “la asignación para
algunos elementos fijos del programa que es controlada por el compilador”.
Otra definición es de (López Valverde, 2016) que dice que “el tamaño y forma de la memoria
estática es constante durante la ejecución de un programa y por tanto se determina en
tiempo de compilación”.
Por último (Villar Torres, 2007) nos dice que “la memoria destinada a datos estáticos que
se gestiona en tiempo de compilación se conoce como memoria estática”.
Con base a estás tres definiciones podemos definir entonces que:
La memoria estática es aquella que es definida durante la codificación del
programa para la asignación de valores y que es controlada por el compilador en
tiempo de compilación, por lo cual no puede cambiar, es siempre constante.
Entonces queda claro que este tipo de memoria es la que nosotros como programadores
definimos durante la codificación, ya que almacenamos cierta cantidad de memoria para
algunos valores. Un ejemplo son los arrays, que en la mayoría de las ocasiones requiere
que se defina las dimensiones de estos.
Este tipo de asignación de memoria es sencillo, ya que como se menciono se puede realizar
durante la compilación del programa.
Algunas de las ventajas de la memoria estática son:
 Sencillez de implementación
 Requerimientos de memoria
 Se pueden asignar tamaños fijos de memoria para ciertos valores y/o estructuras
 La memoria almacenada no se verá afectada
Pero a la vez tiene sus desventajas:
 El tamaño de las variables debe ser conocido en tiempo de compilación
 El tamaño no puede cambiar durante la ejecución del programa
 Muchas veces los programadores no pueden saber el tamaño correcto que va a
utilizar la estructura, por lo que si almacena una cantidad grande de memoria se
puede llegar a desperdiciar, pero si almacena una cantidad muy pequeña entonces
el programa puede dar errores y no podrá realizar bien su funcionamiento.
 No se puede aplicar la recursividad.
Una representación de la memoria estática es la siguiente:

En este caso se tiene la memoria estática de un arreglo, en el cual se han reservado 100
espacios en memoria para poder guardar datos de tipo flotante, uno por cada posición de
memoria.
Como ya lo mencioné, la memoria reservada para este arreglo no puede cambiar durante
la ejecución, por lo que será constantemente reservados 100 espacios en memoria y, como
también lo mencioné, en dado caso de que no se lleguen a usar los 100 espacios en
memoria, que solo se usen 40, entonces los otros 60 se perderán lo que ocasionara un
desperdicio de memoria. Sucede lo contrario cuando aun con los 100 espacios de memoria
reservados nos faltan otros 50, entonces aquí ya tenemos la necesidad de más memoria
reservada, pero esta no puede ser modificada durante la ejecución, entonces aquí ya
nuestro programa tendría incongruencias y falta de recursos.
Algunos de los elementos que residen en la memoria estática son:
 Código fuente del programa. Toda la serie de líneas de código, variables, funciones
y demás que nosotros escribimos para la ejecución de nuestro programa.
 Todas las variables que son declaradas en la sección del programa (int a = 10,
double c = 16,7, String p, char x). Estás solo pueden cambiar el contenido dentro de
ellas, pero no su tamaño.
 Las variables que son declaradas estáticas en el programa.

Entonces, ¿Me sirve como programador utilizar la memoria estática?

La respuesta, a mi parecer, es sí y no.
Si por que podemos utilizarla para programas que sean muy pequeños y que sabemos que
sus valores no van a cambiar en lo absoluto, programas como almacenar 10 nombres,
guardar 10 direcciones, sumar dos números, mostrar algún mensaje en pantalla, programas
muy sencillos que sabemos que no vamos a usar cantidades demasiado grandes de
memoria.
No porque si llegamos a hacer un programa en el cual tengamos que ir introduciendo más
y más valores en la medida que se nos presenten o según las especificaciones del
problema, entonces la memoria estática no nos servirá ya que al tener un tamaño fijo
entonces no podremos modificarla durante la ejecución del programa, nos tendríamos que
estar metiendo en el código y eso se torna bastante tedioso, estar modificando el tamaño
cada vez que lo necesitemos, además de que podemos llegar a desperdiciar demasiada
memoria y tener errores en el futuro.

Arrays Unidimensionales

Ya que definimos de cierta manera lo que es la memoria estática, sus usos, sus
ventajas y desventajas y si es factible o no el utilizarla entonces podemos pasar a unas de
las estructuras básicas en la programación y que están más ligadas con el uso de la
memoria estática, estos son los arreglos o arrays (en inglés).
Dentro de los arrays conocemos tres tipos: unidimensionales, bidimensionales y
multidimensionales. Pero antes de pasar a definir y explicar que es y para que sirve cada
una de estás debemos definir primero lo que es un array en general.
De acuerdo con (Joyanes Aguilar, Fundamentos de programación - Algoritmos, Estructuras
de Datos y Objetos, 2008) un array “Es un conjunto finito y ordenado de elementos
ordenados”. Con esto queremos decir que los elementos siempre van a estar ordenados,
los elementos dentro del array pueden ser identificados fácilmente.
Otra definición es de (M. Deitel & J. Deitel, 2004) “Un arreglo es un grupo consecutivo de
localidades de memoria relacionadas por el hecho de que tienen el mismo nombre y tipo”
La última definición de (Joyanes Aguilar & Zahonero Martínez, ALGORITMOS Y
ESTRCUTURAS DE DATOS Una perspectiva en C, 2004) “Un array es una secuencia de
datos del mismo tipo. Los datos se llaman elementos del array y se numeran
consecutivamente (o, 1, 2, 3…)”
De acuerdo con estás definiciones podemos deducir entonces que
Un array (arreglo) es un conjunto ordenado y finito (con un cierto límite) de
elementos del mismo tipo, los cuales están ordenados consecutivamente siguiendo
el orden de 0 hasta la posición N, donde N es el límite de elementos a guardar en el
arreglo
El array o arreglo más común y utilizado es el unidimensional, que no más que un vector o
una matriz de una sola dimensión.
Los arreglos solo pueden contener datos del mismo tipo, por lo que, si definimos un array
unidimensional de tipo entero, entonces solo podremos almacenar en él, datos de tipo
entero como 1, 10, 60, 99, 88 pero no podremos almacenar datos de tipo char como a, b,
y, x o String como hola, palabra, Christian, ya que los arreglos no permiten almacenar datos
de distintos tipos.
Una forma de definir un array de tipo entero puede ser la siguiente
int [ ] a1; int a1 [ ];
No importa cual de las dos formas se implemente, las dos van orientadas a la misma
declaración de un array. Los corchetes quieren decir que se va a crear un array
unidimensional de tipo entero el cual tendrá como nombre la variable a1 (arreglo 1
abreviado).
Si nosotros ahora hacemos esto:
int a1 [ ] = {1, 2, 3, 4, 5};
Lo que estamos haciendo es guardar estos 5 valores en el arreglo a1.
Otra forma de declarar un array es guardando una cierta cantidad de memoria para dicho
array, como lo vimos en los programas que hicimos en este parcial.
int a1 [ ] = new int [9];
En este caso estamos creando un array de tipo entero y estamos solicitando la reservación
de memoria para 9 elementos. Este arreglo se puede representar de la siguiente manera:

0 1 2 3 4 5 6 7 8

Este representa a un vector o matriz de una sola dimensión en la que se solicito al

compilador que se reservara memoria estática para 9 elementos. Los elementos se irán
introduciendo 1 a 1 en cada una de las posiciones en orden. Por ejemplo, digamos que le
pedimos al usuario introducir números aleatorios por pantalla, el introduce los números {2,
8, 55, 6, 7, 4. 12, 25 y 30} entonces estos se irán almacenando en el vector de la siguiente
manera:

2 8 55 6 7 4 12 25 30

0 1 2 3 4 5 6 7 8

Los números que el usuario introdujo se fueron almacenando en orden en el vector,

entonces las posiciones correspondientes a cada uno de estos números quedarían de la
siguiente manera:
a1 [0] = 2 a1 [7] = 25
a1 [1] = 8 a1 [8] = 30
a1 [2] = 55
a1 [3] = 6
a1 [4] = 7
a1 [5] = 4
a1 [6] = 12
Para poder hacer el recorrido de un array unidimensional, ya sea para almacenar datos en
el o poder realizar la impresión de los elementos se ocupa un ciclo for. Este ciclo lo que
hace es que se irá repitiendo hasta que se haya completado el recorrido del vector por
completo.
Digamos que queremos hacer la introducción de los elementos al vector que declaramos
anteriormente de 9 elementos, nuestro ciclo for quedaría de la siguiente manera
(implementado con cuadros de dialogo en Java):
for (int i = 0; i<9; i++) {
a1[i] = Integer.parseInt(JOptionPane.showInputDialog(null, "Dame un número para V"));
}
Con este ciclo for lo que estamos haciendo es que el usuario introduzca números enteros
al azar en el vector hasta que se cumpla la condición de que i sea menor a 9, en caso de
que no sea así entonces el ciclo se irá repitiendo hasta que dicha condición se cumpla.
Entonces queda claro que un arreglo nos sirve para ir almacenando valores del mismo tipo
en un cierto orden y que un arreglo unidimensional nos puede servir para cierto tipo de
programas. Por ejemplo, almacenar cierto número de cantidades, guardar 10 nombres, para
sacar el curp de una persona o incluso se pueden almacenar datos directamente desde el
código del programa.
 Arrays bidimensionales
Ya explicando anteriormente lo que es un array y el tipo de array unidimensional
entonces voy a explicar lo que es un array multidimensional.
De acuerdo con (Joyanes Aguilar, Fundamentos de programación - Algoritmos, Estructuras
de Datos y Objetos, 2008) “Un array bidimensional es un conjunto de elementos, todos del
mismo tipo, en el cual el orden de los componentes es significativo y en el que se necesita
especificar dos subíndices para poder identificar cada elemento del array”.
¿Qué quiere decir esto? Bueno, a diferencia de los arrays unidimensionales que
representaban un vector, los arrays bidimensionales representan a una matriz o una tabla.
En el caso de los arreglos bidimensionales nos vamos a encontrar que estos van a tener
dos índices, en programación estos se conocen uno para las filas y otro para las columnas.
Entonces digamos que nosotros queremos declarar un array bidimensional en el cual
queremos almacenar números ya declarados directamente en el código, entonces este
quedaría de la siguiente manera:
int m1 [ ] [ ] {
{1, 2, 3},
{4, 5, 6,},
};
En este caso, se esta creando un array bidimensional de 2x3(2 filas x 3 columnas) en el
cual se van a almacenar los números del 1 al 6 en el array y cada conjunto de corchetes
representa un nivel del array. La representación gráfica de este array quedaría de la
siguiente manera:

0 1 2

0 1 2 3

1 4 5 6

Estos números se almacenaron en la matriz y cada uno tiene diferentes subíndices:

m1 [0][0] = 1
m1 [0][1] = 2
m1 [0][2] = 3
m1 [1][0] = 4
m1 [1][1] = 5
m1 [1][2] = 6
Ahora si nosotros quisiéramos crear un array bidimensional, pero quisiéramos que el
usuario introdujera los números en el arreglo, los que el quiera, entonces se haría de la
siguiente manera:
int mat2 [ ] [ ] = new int [6][5];
En este caso estamos creando un array bidimensional de tipo entero, en el cual estamos
solicitando al compilador que almacene memoria para un arreglo bidimensional de 6x5.
Luego, para que el usuario pueda almacenar los números que el quiera dentro del arreglo
vamos a usar lo mismo que en el arreglo unidimensional, con la diferencia de que ahora
vamos a implementar dos ciclos for, ya que uno nos va a servir para el recorrido de las filas
y el otro de las columnas.
El código para la introducción de los números mediante cuadros de dialogo en Java
quedaría de la siguiente manera:
for (int i = 0; i<6; i++) {
for (int j = 0; j<5; j++) {
b[i][j] = Integer.parseInt(JOptionPane.showInputDialog(null, "Dame un valor para M"));
}
}
Lo que hace esta sección de código es que se va a ir repitiendo cada uno de los for hasta
que cumplan las sentencias. Se ejecuta el primer for con i menor a 6 y como es verdadero
esto (ya que i se inicializa a 0) entonces se ejecutará lo que está dentro de este for. Aquí
nos encontramos que hay otro for dentro del primero, entonces este segundo ciclo for se va
a ejecutar si y solo si j es menor a 5, lo cual es cierto ya que j esta inicializada a 0. Pasando
a las instrucciones dentro del segundo for nos encontramos que aquí es donde se mostrara
el cuadro de dialogo para que el usuario vaya introduciendo los valores.
El segundo for se irá cumpliendo consecutivamente, una vez que j no sea menor a 5
entonces dejará de ejecutarse el segundo for y, en este caso, se regresara al primer for
donde i ya no valdrá 0, ahora vale 1, por lo que se volverá a ejecutar las instrucciones dentro
de este mismo que es el segundo for, con la diferencia de que i ahora es igual a 1. Así se
irá repitiendo hasta que i sea menor a 6, en caso contrario se ha cumplido con las
condiciones de este.
Ahora suponiendo que el usuario introduce los siguientes 30 valores:
{1, 2, 4, 5, 6, 78, 12, 3, 44, 15, 2, 3 ,8, 9, 10, 11, 16, 34, 22, 78, 100, 11, 12, 45, 34,11, 17,
18, 34, 40}
Estos se van a ir almacenando en el arreglo bidimensional de 6x5 de la siguiente manera:
0 1 2 3 4
0 1 2 4 5 6
1 78 12 3 44 15
2 2 3 8 9 10
3 11 16 34 22 78
4 100 11 12 45 34
5 11 17 18 34 40
Estos números se fueron introduciendo en la matriz y cada uno tiene diferentes
subíndices:
m1 [0][0] = 1 m1 [3][0] = 11
m1 [0][1] = 2 m1 [3][1] = 16
m1 [0][2] = 4 m1 [3][2] = 34
m1 [0][3] = 5 m1 [3][3] = 22
m1 [0][4] = 6 m1 [3][4] = 78
m1 [1][0] = 78 m1 [4][0] = 100
m1 [1][1] = 12 m1 [4][1] = 11
m1 [1][2] = 3 m1 [4][2] = 12
m1 [1][3] =44 m1 [4][3] = 45
m1 [1][4] = 15 m1 [4][4] = 34
m1 [2][0] = 2 m1 [5][0] = 11
m1 [2][1] = 3 m1 [5][1] = 17
m1 [2][2] = 8 m1 [5][2] = 18
m1 [2][3] = 9 m1 [5][3] = 34
m1 [2][4] = 10 m1 [5][4] = 40
Al igual que los arreglos unidimensionales, los arreglos bidimensionales nos son de gran
utilidad pues nos permiten almacenar grandes cantidades de datos, sirven para representar
tablas, matrices y para realizar operaciones.
 Arrays Multidimensionales
Por último, queda explicar y definir lo que son los arreglos multidimensionales ya
para terminar cerrar.

De acuerdo con (Joyanes Aguilar & Zahonero Martínez, ALGORITMOS Y ESTRCUTURAS

DE DATOS Una perspectiva en C, 2004) “Los arrays multidimensionales son aquellos que
tienen más de una dimensión y, en consecuencia, más de un índice”.

Y (Joyanes Aguilar, Fundamentos de programación - Algoritmos, Estructuras de Datos y

Objetos, 2008) nos dice que “Un array puede ser definido de tres dimensiones, cuatro
dimensiones, hasta n-dimensiones. Los conceptos de rango de subíndices y numero de
elementos se puede ampliar directamente desde arrays de una y dos dimensiones a estos
arrays de orden más alto”.

Entonces, de acuerdo con estás dos definiciones, podemos entender que un array
multidimensional es aquel que se puede construir a partir de un array unidimensional y
bidimensional, que no tiene un limite y puede almacenar una cantidad mucho más grande
de elementos.

Este es un ejemplo sacado de (Joyanes Aguilar, Fundamentos de programación -

Algoritmos, Estructuras de Datos y Objetos, 2008) :

EJEMPLO 7.9

Un array de tres dimensiones puede ser uno que contenga los datos relativos al número de
estudiantes de la universidad ALFA de acuerdo con los siguientes criterios:
 cursos (primero a quinto),
 sexo (varón/hembra),
 diez facultades.
El array ALFA puede ser de dimensiones 5 por 2 por 10 (alternativamente 10 × 5 × 2 o 10
× 2 × 5, 2 × 5 × 10, etcétera). La Figura 7.6 representa el array ALFA.
El valor de elemento ALFA [I, J, K] es el número de estudiantes del curso I de sexo J de la
facultad K. Para ser válido I debe ser 1, 2, 3, 4 o 5; J debe ser 1 o 2; K debe estar
comprendida entre 1 y 10 inclusive.
Debido a que la memoria de la computadora es lineal, un array multidimensional debe estar
linealizado para su disposición en el almacenamiento. Los lenguajes de programación
pueden almacenar los arrays en memoria de dos formas: orden de fila mayor y orden de
columna mayor.
El medio más natural en que se leen y almacenan los arrays en la mayoría de los
compiladores es el denominado orden de fila mayor (véase Figura 7.8). Por ejemplo, si un
array es B 1:2, 1:3], el orden de los elementos en la memoria es:
 Conclusión

De acuerdo con la investigación que realice pude darme cuenta y reforzar más el tema del
uso de la memoria para la programación y conocer un poco más a fondo lo que son los
arrays.
El uso de memoria estática como lo investigué y entendí puede llegar a tener sus beneficios,
pues podemos llegar a tener ya la memoria reservada para algunos datos que vamos a
utilizar en nuestro programa, pero a la vez si queremos utilizar más datos y la memoria no
nos alcanza entonces nuestro programa se verá afectado. Por eso hay que tener cuidado
cuando usemos la memoria estática y no reservar de más ni de menos dicha memoria.
También los arreglos nos ayudan mucho para ir almacenando diferentes tipos de datos,
pero al igual que en la memoria estática, el mal uso de la declaración de estos mismos nos
puede afectar en nuestros programas.
Debemos ser conscientes de que el uso de la memoria y de estás estructuras de datos
debe ser de manera consciente y eficaz.
Referencias
Joyanes Aguilar, L. (2008). Fundamentos de programación - Algoritmos,
Estructuras de Datos y Objetos. España: McGraw Hill.
Joyanes Aguilar, L., & Zahonero Martínez, I. (2004). ALGORITMOS Y
ESTRCUTURAS DE DATOS Una perspectiva en C. Madrid España:
McGraw Hill.
López Valverde, F. (2016). Universidad de Malaga. Obtenido de Lenguajes y
Ciencias de la Computación: http://www.lcc.uma.es/~lopez/lp2/apuntes/03-
punteros/memoria_dinamica.pdf
M. Deitel, H., & J. Deitel, P. (2004). Como programar en C/C++ y Java. México:
PEARSON EDUCACIÓN.
Muñoz Celaya, R. C. (09 de 2014). INGENIERIATICELAYA. Obtenido de
https://ingenieriaticelaya.files.wordpress.com/2014/09/manejo-de-
memoria.pdf
Villar Torres, J. M. (2007). UNIVERSITAT JAUME I. Obtenido de Repositori
Universitat Jaume I:
http://repositori.uji.es/xmlui/bitstream/handle/10234/5915/memoria.apun.pdf;
jsessionid=7F748BC7A35D5136DDB1325668FC4A0D?sequence=1