Arreglos C#

PONTIFICIA UNIVERSIDAD CATÓLICA DE CHILE ESCUELA DE INGENIERÍA DEPARTAMENTO DE CIENCIA DE LA COMPUTACIÓN IIC 1102 INTRODUCCIÓN A LA PROGRAMACIÓN Profesor: Rodrigo Sandoval U.

Capítulo VII – Arreglos y Enumeraciones en C# 1

ARREGLOS ......................................................................................................................................................... 1 1.1 DECLARACIÓN DE ARREGLOS UNIDIMENSIONALES ........................................................................................ 2 1.2 USO DE ARREGLOS UNIDIMENSIONALES ......................................................................................................... 3 1.2.1 Funciones más comunes con arreglos.................................................................................................... 4 1.2.2 Foreach para el manejo de arreglos...................................................................................................... 5 1.2.3 Ejemplos de declaración y uso de arreglos............................................................................................ 6 1.2.4 Ejemplo: Cálculo de mínimo, máximo y promedio de una lista de notas de estudiantes....................... 7 1.2.5 Ejemplo: Programa de simulación de conjuntos con arreglos .............................................................. 9

2

ARREGLOS MULTIDIMENSIONALES ....................................................................................................... 13 2.1 DECLARACIÓN DE MATRICES........................................................................................................................ 13 2.2 USO DE MATRICES ........................................................................................................................................ 14 2.2.1 Obteniendo Dimensiones de una Matriz .............................................................................................. 14 2.2.2 Ejemplos de uso de Matrices................................................................................................................ 14 2.2.3 Foreach en matrices............................................................................................................................. 14 2.2.4 Ejemplo: Cálculo de las notas finales de un curso (mínimo, máximo, promedio) ............................... 15 2.2.5 Ejemplo: Multiplicación de Matrices Cuadradas ................................................................................ 18

3

ENUMERACIONES .......................................................................................................................................... 23

Material preparado por Rodrigo Sandoval U en Marzo 2004, basado en los apuntes de clase del curso IIC1102, año 2003, de M. Nussbaum, Marcos Sepúlveda, et.al

Intro. Prog. Orientada a Objeto – Arreglos y Enumeraciones

Rodrigo Sandoval U.

1 Arreglos Los arreglos son estructuras de datos complejas (en el sentido de que no son atómicas) que agrupan datos de un mismo tipo en particular, llamado el tipo base del arreglo. El tipo base de un arreglo puede ser cualquiera de los tipos básicos de C#, o incluso algunos tipos complejos como las clases. Un arreglo es también ejemplo de un modelo. Un arreglo puede considerarse como ejemplo de una variable compuesta capaz de almacenar uno o más datos al mismo tiempo.

La sintaxis del lenguaje permite referirse a cada uno de los elementos que constituyen el arreglo empleando índices. Esto es posible pues los elementos del arreglo están numerados en forma jerárquica y consecutiva, empezando en 0 en cada dimensión. El siguiente gráfico ilustra un ejemplo de un arreglo llamado numeros, cuya posición 0 almacena el valor 10, la posición 1 el valor de 21, etc. Este arreglo en total almacena n+1 elementos. El valor de n, depende de la memoria que pueda tener el computador y el tipo de elementos que se almacenen en el arreglo.

IIC 1102

Página: 1

Intro. Prog. Orientada a Objeto – Arreglos y Enumeraciones

Rodrigo Sandoval U.

Los arreglos, al igual que el resto de las variables se identifican con un nombre. Al emplear ese nombre, se hace referencia a la estructura de datos como un todo, es decir, con todos sus elementos. El lenguaje interpreta dicho nombre como un puntero. Cuando se utiliza el nombre del arreglo en forma indexada, es decir, combinado con índices, se hace referencia a un elemento particular, del tipo base, dentro de la estructura compleja. Importante: El lenguaje C# no controla la validez de los índices que se emplean para referenciar un arreglo. Esto quiere decir que es posible cometer errores graves y difíciles de detectar en este sentido. Más adelante se presenta un ejemplo en este sentido.

1.1

Declaración de Arreglos Unidimensionales

Los arreglos, al igual que las demás variables deben declararse antes de poder utilizarlas, y cumplen con las mismas reglas de alcance y vida. Los arreglos de una sola dimensión reciben también el nombre de vectores. La sintaxis de la declaración de un arreglo unidimensional es la siguiente: [] ; Observaciones: •

El puede ser cualquiera de los tipos básicos del lenguaje, o incluso algunos complejos como estructuras.

•

El es el nombre que distinguirá el arreglo.

•

Los corchetes [] son obligatorios y denotan que el identificador descrito, del tipo-base indicado, es un arreglo (lista de elementos del tipo base).

•

En esta declaración NO se define el tamaño que tendrá el arreglo (aunque se puede determinar las dimensiones, lo que se verá más adelante).

El tamaño del arreglo se determina en una segunda declaración, que puede ir en la siguiente línea, como se muestra a continuación.

= new [] En esta declaración, se dimensiona el arreglo con una cantidad determinada de elementos, todos correspondientes a tipo-base.

Es posible hacer la declaración del arreglo y su dimensionamiento en una misma sentencia: [] = new []

Adicionalmente es factible declarar, dimensionar, e inicializar un arreglo con todos sus elementos, en una sola declaración: [] = {valor1, valor2, ..., valorN}; Esta última declaración implícitamente dimensiona el arreglo para almacenar los N elementos descritos, por lo que no se requiere dimensionarlo aparte. Es decir: •

Con los valores indicados entre llaves {} se inicializarán los elementos del arreglo.

•

Los valores deben ser del del arreglo.

IIC 1102

Página: 2

Intro. Prog. Orientada a Objeto – Arreglos y Enumeraciones

Rodrigo Sandoval U.

También es factible declarar, dimensionar, e inicializar un arreglo con todos sus elementos, en una sola declaración, pero sólo indicando un subconjunto de los valores que el arreglo puede guardar: [] = new [N] {valor1, ..., valorM}; ... donde MN, en cuyo caso, el real dimensionamiento del arreglo se regirá por M. Algunos ejemplos:

// Arreglo para 10 enteros int [] numeros; numeros = new int[10]; // Arreglo para 10 enteros int [] numeros = new int[10]; // Arreglo para 10 enteros int [] numeros = { 1, 1, 1, 2, 3, 5, 2, 5, 3, 4 };

1.2

Uso de Arreglos Unidimensionales

Los elementos de un arreglo son variables del tipo base del vector, por lo que se utilizan de la misma manera en expresiones y demás instrucciones, como la asignación. Por ejemplo, para asignar un valor a un elemento de un arreglo basta con escribir:

[indice] = ; donde es el nombre de la variable e indice hace referencia a la posición del elemento al que se le quiere asignar el . La referencia de valores en un arreglo, se indexa desde el 0 al N-1. Importante: Puesto que los arreglos son estructuras complejas (es decir, no básicas), no es posible asignar un arreglo a otro mediante una simple asignación (=). Para hacer esto es necesario escribir un ciclo y asignar elemento a elemento. Como se mencionó anteriormente, el lenguaje C# no controla la validez de los índices que se emplean para referenciar un arreglo. Esto quiere decir que es posible cometer errores muy difíciles de detectar en este sentido. Es necesario prestar especial interés a los valores que toman los índices para evitar estos problemas. Por ejemplo, la siguiente porción de código compila sin problemas (es decir, sin errores sintácticos), pero probablemente produzca un error en tiempo de ejecución al referenciarse posiciones inexistentes del arreglo.

// Las posiciones con índices del 10 al 19 son inválidas. int[] arreglo = { 1,1,1,1,1,1,1,1,1,1 };

// 10 elementos

int i; for (i=0; i= 10

Página: 3

Intro. Prog. Orientada a Objeto – Arreglos y Enumeraciones

Rodrigo Sandoval U.

También es común cometer estos errores olvidando que las posiciones de los arreglos están numeradas a partir del índice cero. Es decir, en un arreglo de tamaño N las posiciones están numeradas de 0 a N-1.

1.2.1 Funciones más comunes con arreglos En C#, los arreglos se representan con un tipo específico, y por ello cuentan con sus propios atributos y métodos específicos. Por ejemplo, para obtener el largo (la cantidad de elementos dimensionados) de un arreglo, o para ordenarlo. El Largo de un Arreglo En el caso de los arreglos unidimensionales, el tamaño o cantidad de elementos se obtiene con la propiedad Length. int [] numeros = { 1,2,3,4,5,6 } Console.WriteLine(“Largo: {0}”, numeros.Length);

Ordenamiento de un Arreglo En el caso de los arreglos que sean de uno de los tipos predefinidos (int, float, char, etc.), es factible ordenarlos en forma creciente, aprovechando el método básico Sort() de la clase Array: int [] numeros = { 4,5,2,3,1,6 } Array.Sort(numeros); // 1,2,3,4,5,6

Revertir el Orden de un Arreglo En el mismo caso en que se pueda ordenar un arreglo, se puede reordenar exactamente al revés de cómo está, aprovechando el método básico Reverse() de la clase Array: int [] numeros = { 1,2,3,4,5,6 } Array.Reverse(numeros); // 6,5,4,3,2,1

Ejemplo de Manipulación de Arreglos using System; class Arreglo { int[] numeros; public Arreglo(int [] arreglo) { numeros = new int[arreglo.Length]; for (int i=0; i