Una de las estructuras más básicas de control que existe en todo lenguaje son los arrays o arreglos como los conocemos en español.

En esta ocasión trataremos el tema de arreglos comenzando por mencionar la parte teórica que los sostiene. De entrada en lo particular debemos entender que un arreglo es «una colección de elementos homogéneos denotados por un mismo nombre y que ocupan localidades de memoria sucesivas».

Los arreglos tienen tamaño, dimensión e indices. El tamaño esta dado por la cantidad de elementos que se van a alojar en él. La dimensión permite clasificar a los arreglos en unidimensionales, bidimensionales, tridimensionales y n-dimensionales en función de las dimensiones que se requieran trabajar.

Típicamente a los arreglos unidimensionales se les llama «vectores» y a los bidimensionales se les llama «matrices». De tal suerte que, un vector se puede declarar de la siguiente manera:

int[ ] miVector =  new int[10]; 

De donde podemos observar lo siguiente, miVector es la etiqueta o nombre de la variable, new se encarga de reservar la memoria suficiente para almacenar [10] elementos de tipo int tomando en cuenta el tamaño del tipo de dato, en otras palabras, si sabemos que un int ocupa 4 bytes, entonces el tamaño que new reserva para este ejemplo es de 40 bytes para todo el vector.

Ahora, se dice que ocupan localidades de memoria sucesivas porque si tenemos

miVector[10]  esto se podría ver como miVector{ [0][1][2][3][4][5][6][7][8][9] }

significa que conociendo solamente la dirección de memoria de la posición inicial [0] es suficiente para que la computadora sepa de manera interna que la posición [1] se encuentra a 4 bytes de la posición inicial. Este proceso se repite consecutivamente hasta obtener el tamaño total de bytes del arreglo y con esto la computadora puede calcular cuando se hace referencia a un elemento que no esta dentro del espacio de memoria asignado. Cuando esto pasa obtendremos una excepción del tipo System.IndexOutOfRangeException.

Los números dentro de los corchetes denotan el índice de cada posición no su contenido. De tal suerte que se puede asignar un valor a cualquier posición del arreglo haciendo algo como

miVector[3] = 158;

donde el 3 es el índice de la posición a la que se hace referencia y 158 es el valor entero que se guardará en esa en ella. Reafirmando, podemos hacer

Console.WriteLine(miVector[3]); y la salida que arrojaría en pantalla sería 158

Ahora hagamos un código para ejemplificar todo lo que hasta este punto hemos dicho.

Primero generamos un nuevo proyecto en VisualStudio que sea una aplicación de consola.

Le damos el nombre que deseemos, en mi caso le pondré EjemploArreglos. Una vez abierto el editor, crearemos una carpeta que se llame Clases. Es una práctica de buena programación el mantener nuestros códigos limpios y organizados.

Para crear la carpeta damos clic derecho sobre el nombre del proyecto en la vista del Explorador de Soluciones, buscamos la opción Agregar dentro del menú contextual y seleccionamos la opción Nueva Carpeta.

Dentro de la carpeta que acabamos de crear, creamos una nueva clase llamada Arreglo, para esto repetimos el mismo proceso para crear una carpeta solo que esta vez damos clic sobre la carpeta y seleccionamos la opción Clase del menú contextual. En el cuadro de dialogo que se abre, verificamos que este seleccionada la opción Clase y escribimos el nombre Arreglo. Cabe recordar que los nombres de las clases por convención siempre se escriben con mayúscula al inicio.

Entonces dentro de la nueva clase pondremos el siguiente código:

class Arreglo
    {
        //zona de atributos

        //zona de métodos
        public void ArregloUnidimensional()
        {
            //declaracion del arreglo unidimensional
            int[] miVector = new int[10];

            //llenar el arreglo con un valor
            for (int i = 0; i < miVector.Length; i++)
            {
                miVector[i] = 5;
            }

            //imprimir el contenido del arreglo
            for (int i = 0; i < miVector.Length; i++)
            {
                Console.Write("[" + miVector[i] + "|" + i +"] ");
            }
        }
    }

Ahora agregamos la llamada de nuestra nueva clase dentro de la clase Program.cs con un código como el que sigue:

class Program
    {
        static void Main(string[] args)
        {
            Arreglo miArreglo = new Arreglo();
            
            miArreglo.ArregloUnidimensional();
            
            Console.ReadKey();
        }
    }

Si ejecutamos el programa obtenemos como salida la siguiente pantalla:

Podemos notar que las casillas contienen dos cosas, el valor del posición y el índice de la misma. Donde el 5 es el valor, y los números del 0 al 9 son los indices de nuestro vector.

Hasta aquí dejaré la primer parte, en la segunda parte continuaremos con el tema de los arreglos bidimensionales.