Saltar al contenido

Arrays en C# y matrices bidimensionales.

Los arrays en C#, o vectores son muy parecidos a las variables, pero a diferencia de las variables pueden almacenar varios datos de un mismo tipo en un mismo espacio de la memoria.

Un array se considera un objeto y en lugar de almacenar un solo dato, podemos almacenar varios.

Pueden tener un tipo de dato entero, decimal, un texto etc. Antes de poner el ejemplo, tener una cuenta una cosa. La memoria del ordenador está compuesta de celdas, cuanta más memoria, más celdas, es igual que la batería de los ordenadores portátiles a más duración más celdas.

Por otro lado, dependiendo de si un array o vector contiene datos o no, puede ser de diferentes tipos.

¿Cómo pueden ser los arrays?

  • Si están llenos en cada una de sus posiciones diremos que el vector está lleno.
  • Diremos que el vector está semilleno si contiene valores en algunas posiciones pero no en todas.
  • Por el contrario, si el array no contiene datos diremos que está vacío.

¿Cómo se declaran los arrays en C#?

Para declarar un array en C# poniendo dos corchetes al final de la declaración. De la siguiente forma:

Tipo de dato + [] + nombre del vector;

Ejemplo de declaración de arrays en C#.

En este punto vamos a declarar un espacio en memoria para almacenar un vector. Por el momento vamos a reservar un espacio en la memoria para almacenarlo, aunque todavía no vamos a crear el objeto vector. Esto lo haremos igual que en lenguaje java.

using System;

namespace Operaciones_con_Matrices
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos un vector de números enteros.
            int[] vector;
        }
    }
}

Como se declaran las posiciones de los vectores.

  • Lo primero que hacemos es declarar el objeto vector.
  • Después creamos el objeto vector, eso lo haremos con la palabra new, seguido de unos corchetes y el tipo de dato que va a contener.
  • Dentro de los corchetes, pondremos el número de posiciones que va a contener el vector.

En este ejemplo declararemos un primer vector de tres posiciones y un segundo vector de cinco posiciones para ver las dos formas de declarar e iniciar los arrays.

using System;

namespace Operaciones_con_Matrices
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos un vector de números enteros.
            int[] vector;

            // Creamos el objeto y le decimos las posiciones.
            vector = new int[3];

            /* Tambien podemos declarar e iniciar el vector
             * en una linea de la siguiente manera:*/
            int segundoVector = new int[5];
        }
    }

¿Cómo rellenar un arrays en c# de forma manual?

En este ejemplo se rellena de forma manual un vector. Esto no es muy común pero no está de más saber como hacerlo, por si en algún momento lo necesitamos. También mostraremos de forma manual el vector en consola.

using System;

namespace Operaciones_con_Matrices
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos un vector de números enteros.
            int[] vector;

            // Creamos el objeto y le decimos las posiciones.
            vector = new int[3];

            // Asignamos manualmente valores al vector
            // teniendo en cuenta que la primera posicion
            // del array en la posicion cero.

            vector[0] = 10;
            vector[1] = 27;
            vector[2] = 92;

            // Para mostrarlo por pantalla podemos hacer lo siguiente
            Console.WriteLine(vector[0]);
            Console.WriteLine(vector[1]);
            Console.WriteLine(vector[2]);
        }
    }
}

Aunque la forma anterior puede usarse para asignar valores a un vector, lo normal es hacerlo dinámicamente.

Para rellenar y mostrar un vector de forma dinámica, usaremos un bucle for.

Arrays o vectores dinámicos.

Lo más normal es que los arrays se rellenen de forma dinámica. Para realizar este ejemplo usaremos la clase Random(). Esta clase permite generar números aleatorios entre dos valores. Con la clase Random() crearemos un objeto de tipo Random() que se encargará de crear números aleatorios para mostrarlos por consola.

using System;

namespace Operaciones_con_Matrices
{
    class Program
    {
        static void Main(string[] args)
        {

            /* Declaramos un vector de números enteros y creamos
             * el objeto vector en la misma linea con las posiciones
             * que va a tener el vector en este caso 10 posiciones*/

            int[] vector = new int[10];

            /* Creamos un objeto de tipo random y lo almacenamos
             * en una variable objeto llamada aleatorios*/
            Random aleatorios = new Random();

            /* Hacemos uso de un bucle for para asignar cada valor
             * que se genere el cada posicion del vector.
             * Nos ayudamos de una variable contador que va a ir
             * recorriendo cada posicion para asignar el número aleatorio*/

            for (byte posicion = 0; posicion < vector.Length; posicion++)
            {
                /* Para la posicion del vector igual a cero
                 * mientras la variable posicion sea menor que
                 * la longitud del vector, incrementamos en uno
                 * la variable posicion
                 * y almacenamos en la posicion
                 * un número aleatorio entre 1 y 100 ambos incluidos*/
                vector[posicion] = aleatorios.Next(1, 101);

                /* Una vez generado el número aleatorio
                 * y almacenado en cada posicion,
                 * lo mostramos por consola.*/
                Console.WriteLine("Posición {0}: número{1}", posicion, vector[posicion]);
            }

            // Una vez finaliza el bucle pausamos la consola
            Console.ReadKey();
        }
    }
}

Bucle foreach en csharp. Rellenado automático de vectores.

En este caso, este bucle puede traducirse por: para cada. Es otro tipo de bucle además de los vistos anteriormente. Es otra forma de rellenar el vector. En este caso el ejemplo sería igual que el anterior pero cambiaremos el bucle for normal por el bucle foreach.

using System;

namespace Operaciones_con_Matrices
{
    class Program
    {
        static void Main(string[] args)
        {
            /* Hacemos uso de un bucle foreach para asignar cada valor
             * que se genere el cada posicion del vector.
             * Nos ayudamos de una variable contador que va a ir
             * recorriendo cada posicion para asignar el número aleatorio*/

            foreach (byte posiciondelvector in vector)
            {
                /* Para cada posicion del vector en el objeto vector
                 * almacenamos en cada posicion un número aleatorio
                 * un número aleatorio entre 1 y 100 ambos incluidos*/
                vector[posiciondelvector] = aleatorios.Next(1, 101);

                // Una vez almacenados los mostramos por consola
                Console.WriteLine("Posición {0}: número{1}", posiciondelvector, vector[posiciondelvector]);
            }

            // Una vez finaliza el bucle pausamos la consola
            Console.ReadKey();
        }
    }
}

MÁS INFORMACIÓN

Matrices bidimensionales.

Las matrices en C# son arrays de más de una dimensión. En este caso las más utilizadas son lo que llamamos matrices o arrays bidimensionales. Para ejemplificar este tipo de estructuras, podemos imaginarnos una tabla de Excel.

Al igual que los vectores, también están determinadas por una serie de posiciones. Una matriz, primero se declara el espacio en memoria. Después se construye con la palabra reservada new y se le asigna una dimensión. Las matrices también son consideradas objetos en programación. En una matriz primero se asignan las filas y luego las columnas. Vamos a ver la siguiente imagen en la que veremos una matriz y sus posiciones.

matrices bidimensionales en c#
matriz bidimensional en c#

Declaración de matrices bidimensionales.

Para realizar la declaración se hace igual que cuando se declaran vectores. La única diferencia es una coma dentro de los corchetes. El número a la izquierda de la coma indicará las filas. Por el contrario el número a la derecha de la coma indicará las columnas. Veamos un ejemplo práctico.

using System;

namespace Operaciones_con_Matrices
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos una matriz bidimensional. Para ello ponemos
            // una coma entre los dos corchetes.
            int[,] mEjemplo;

            // Construimos la matriz y le damos una dimensión
            mEjemplo = new int[3, 4];
            // Esto indica 3 filas y 4 columnas.
        }
    }
}

Como rellenar matrices bidimensionales de forma dinámica.

Esto lo haremos a través de bucles for anidados, es decir un bucle for dentro de otro. El primer bucle for indica que se estarán recorriendo las filas de la matriz. Por otro lado, el segundo bucle for indicará que se estarán recorriendo las columnas. Veamos un ejemplo. En este caso al igual que en el ejemplo con los vectores, usaremos números aleatorios.

using System;

namespace Operaciones_con_Matrices
{
    class Program
    {
        static void Main(string[] args)
        {
            // Declaramos una matriz bidimensional. Para ello ponemos
            // una coma entre los dos corchetes.
            int[,] mEjemplo;

            // Construimos la matriz y le damos una dimensión
            mEjemplo = new int[3, 4]; // 3 filas y 4 columnas.

            // Creamos un objeto para generar números aleatorios
            // entre 1 y 100 ambos incluidos.
            Random aleatorios = new Random();

            // Declaramos un bucle for para recorrer las filas
            for (byte fila = 0; fila < 3; fila++)
            {
                /* Cuando entramos en este bucle por primera vez
                 * estamos en la fila cero. Ahora lo que quiero es
                 * situarme en la columna cero.*/
                for (byte columna = 0; columna < 4; columna++)
                {
                    /* Cuando entramos por primera vez en este bucle
                     * estamos en la columna cero.
                     * Ahora en la fila cero, columna cero [0,0]
                     * colocamos el primer valor*/
                    mEjemplo[fila, columna] = aleatorios.Next(1, 101);

                    // Una vez almacenamos el número en la posición
                    // Lo mostramos en consola y con un "\t"
                    // creamos una tabulación.
                    Console.Write(mEjemplo[fila, columna] + "\t");
                }
                // Cuando sale del bucle a esta altura ya relleno
                // la primera fila en cada una de sus columnas.
                // así que creamos un salto de linea
                Console.WriteLine();
            }
            // Cuando sale aquí ya salio del los dos bucles.
            // Así que pausamos la consola para ver el resultado
            Console.ReadKey();
        }
    }
}

MÁS INFORMACIÓN