Saltar a contenido principal

Introducción a la programación con C#

Usted se ha identificado como Mariela Pavó (Salir)
Ruta a la página

 Página Principal
 / ► Mis cursos
 / ► P.O.O C#
 / ► Tema 3
 / ► Ciclos y Arreglos

Ciclos y Arreglos
Lección #4

Lección #4 Título: Ciclos y arreglos.

Objetivo: Conocer  el funcionamiento de las estructuras repetitivas y los

arreglos

Contenidos:

 Ciclos
 Arreglos

Sesión de Cuestionario:

Sesión Foro: 

 Ciclos

 En C# existen 3 estructuras repetitivas: while, for y do .. while

while

Si queremos hacer que una sección de nuestro programa se repita

mientras se cumpla una cierta condición, usaremos la orden "while". Esta
orden tiene dos formatos distintos, según comprobemos la condición al
principio o al final.
En el primer caso, su sintaxis es

   while (condición)
     sentencia;

Es decir, la sentencia se repetirá mientras la condición sea cierta. Si la

condición es falsa ya desde un principio, la sentencia no se ejecuta
nunca. Si queremos que se repita más de una sentencia, basta
agruparlas entre { y }.

Un ejemplo que nos diga si cada número que tecleemos es positivo o

negativo, y que pare cuando tecleemos el número 0, podría ser:

  public static void Main()

 {

    int numero;

    Console.Write("Teclea un número (0 para salir): ");

    numero = Convert.ToInt32(Console.ReadLine());

    while (numero != 0)

    {

      if (numero > 0) Console.WriteLine("Es positivo");

        else Console.WriteLine("Es negativo");

      Console.WriteLine("Teclea otro número (0 para salir): ");

      numero = Convert.ToInt32(Console.ReadLine());

    }

 }

}
En este ejemplo, si se introduce 0 la primera vez, la condición es falsa y
ni siquiera se entra al bloque del "while", terminando el programa
inmediatamente.

. do ... while

Este es el otro formato que puede tener la orden "while": la condición se

comprueba al final. El punto en que comienza a repetirse se indica con la
orden "do", así:

   do

     sentencia;

   while (condición);

Al igual que en el caso anterior, si queremos que se repitan varias

órdenes (es lo habitual), deberemos encerrarlas entre llaves.

Como ejemplo, vamos a ver cómo sería el típico programa que nos pide
una clave de acceso y no nos deja entrar hasta que tecleemos la clave
correcta:

  public static void Main()

 {

     int valida = 711;

    int clave;

     do

    {

      Console.Write("Introduzca su clave numérica: ");

      clave = Convert.ToInt32(Console.ReadLine());

      if (clave != valida) Console.WriteLine("No válida!\n");

    }
    while (clave != valida);

    Console.WriteLine("Aceptada.\n");

   }

En este caso, se comprueba la condición al final, de modo que se nos

preguntará la clave al menos una vez. Mientras que la respuesta que
demos no sea la correcta, se nos vuelve a preguntar. Finalmente, cuando
tecleamos la clave correcta, el ordenador escribe "Aceptada" y termina el
programa.

Si preferimos que la clave sea un texto en vez de un número, los

cambios al programa son mínimos:

  public static void Main()

 {

     string valida = "secreto";

    string clave;

     do

    {

      Console.Write("Introduzca su clave: ");

      clave = Console.ReadLine();

      if (clave != valida) Console.WriteLine("No válida!\n");

    }

    while (clave != valida);

    Console.WriteLine("Aceptada.\n");

   }
}

 for

Ésta es la orden que usaremos habitualmente para crear partes del

programa que se repitan un cierto número de veces. El formato de "for"
es.

   for (valorInicial; CondiciónRepetición; Incremento)

     Sentencia;

Así, para contar del 1 al 10, tendríamos 1 como valor inicial, <=10 como
condición de repetición, y el incremento sería de 1 en 1. Por tanto, el
programa quedaría:

   public static void Main()

 {

     int contador;

     for (contador=1; contador<=10; contador++)

      Console.Write("{0} ", contador);

   }

Recordemos que "contador++" es una forma abreviada de escribir.

"contador=contador+1", de modo que en este ejemplo aumentamos la
variable de uno en uno.

En un "for", realmente, la parte que hemos llamado "Incremento" no tiene

por qué incrementar la variable, aunque ése es su uso más habitual. Es
simplemente una orden que se ejecuta cuando se termine la "Sentencia"
y antes de volver a comprobar si todavía se cumple la condición de
repetición.

Por eso, si escribimos la siguiente línea:

     for (contador=1; contador<=10; )

la variable "contador" no se incrementa nunca, por lo que nunca se
cumplirá la condición de salida: nos quedamos encerrados dando vueltas
dentro de la orden que siga al "for".

Un caso todavía más exagerado de algo a lo que se entra y de lo que no

se sale sería la siguiente orden:

     for ( ; ; )

Los bucles "for" se pueden anidar (incluir uno dentro de otro), de modo
que podríamos escribir las tablas de multiplicar del 1 al 5 con:

 public class Ejemplo26

  public static void Main()

 {

     int tabla, numero;

     for (tabla=1; tabla<=5; tabla++)

      for (numero=1; numero<=10; numero++)

        Console.WriteLine("{0} por {1} es {2}", tabla, numero,

          tabla*numero);

   }

En estos ejemplos que hemos visto, después de "for" había una única
sentencia. Si queremos que se hagan varias cosas, basta definirlas como
un bloque (una sentencia compuesta) encerrándolas entre llaves. Por
ejemplo, si queremos mejorar el ejemplo anterior haciendo que deje una
línea en blanco entre tabla y tabla, sería:

  public static void Main()

 {
    int tabla, numero;

    for (tabla=1; tabla<=5; tabla++)

    {

      for (numero=1; numero<=10; numero++)

        Console.WriteLine("{0} por {1} es {2}", tabla, numero,

          tabla*numero);

      Console.WriteLine();

    }

   }

Para "contar" no necesariamente hay que usar números. Por ejemplo,

podemos contar con letras así:

  public static void Main()

 {

     char letra;

     for (letra='a'; letra<='z'; letra++)

      Console.Write("{0} ", letra);

   }

En este caso, empezamos en la "a" y terminamos en la "z", aumentando

de uno en uno.
Si queremos contar de forma decreciente, o de dos en dos, o como nos
interese, basta indicarlo en la condición de finalización del "for" y en la
parte que lo incrementa:

  public static void Main()

 {

     char letra;

     for (letra='z'; letra>='a'; letra--)

      Console.Write("{0} ", letra);

   }

Arreglos

Un arreglo unidimensional es un tipo especial de variable que es capaz

de almacenar en su interior y de manera ordenada varios elementos de
un determinado tipo” [12]. Se entiende en este caso por orden, que cada
elemento ocupa una posición, es decir, cada uno tiene predecesor
(exceptuando el primero) y sucesor (exceptuando el último).

Seguidamente se muestran algunas formas de declarar e inicializar

arreglos para representar secuencias en C#.

            int[] temperaturas = {28, -5};

            uint[] notas = {5, 4, 3, 4, 5};

            double[] pesos = {70.3, 60, 65.7};   

            char[] palabra = {'H', 'o', 'l', 'a'};

            string[] nombres = {"Ana"};

De forma general para declarar un arreglo en C#, se colocan corchetes

vacíos entre el tipo y el nombre de la variable como se muestra a
continuación:
            <identificador de tipo> [ ] <identificador de variable>;

Nota:   Vale destacar que en este caso la combinación de símbolos “[ ]”

no se está usando para representar opcionalidad sino como un elemento
intrínseco de la declaración de los arreglos.

En C# los arrays son objetos cuya clase base es System.Array. Por lo

tanto aunque la sintaxis para definir un array parezca similar a la de otros
lenguajes, realmente estamos instanciando una clase .NET, lo que
significa que todos los arrays declarados tienen los mismos métodos de
la clase System.Array.

Al igual que el resto de las variables, los arreglos en C# se pueden

instanciar en el momento de la declaración o posteriormente y que esta
declaración (aún cuando utiliza semántica por referencia) no es
obligatoriamente a través del operador new como se puede apreciar en
los ejemplos mostrados con anterioridad.

Los arreglos utilizan semántica por referencia, las variables de arreglo

guardan solamente la referencia al bloque de memoria donde realmente
se encuentran los valores. En la figura siguiente se muestra una
representación en memoria de los arreglos definidos e inicializados en el
listado anterior.

Pregunta: ¿Cómo acceder a los distintos elementos que están

almacenados en las variables definidas e inicializadas anteriormente?

Para acceder a los elementos de un arreglo se utilizan índices como se

muestra a continuación:

            Temperaturas[1]; notas[4]; pesos[2]; palabra[3]; nombres[0];

En todos los casos se ha accedido al último elemento de los respectivos

arreglos, puesto que el índice de los arreglos en C# comienza en cero
(0), esto significa que el primer elemento de un arreglo tendrá siempre
índice cero (0), mientras que el último elemento tiene como índice la
longitud del mismo (long, cantidad de elementos) menos uno (long-1).

Pregunta: ¿Cómo determinar el número de elementos que contiene el

arreglo pesos?
Para determinar el número de elementos de cualquier arreglo se utiliza la
propiedad Length que poseen todas las variables de arreglo, en lo
particular para pesos sería de la siguiente forma:

pesos.Length

Situación de análisis

Sin dudas que no siempre es posible tener previamente definida la

secuencia de valores para definir e inicializar el arreglo de una vez.

Pregunta: ¿Cómo es posible entonces utilizar los arreglos de forma

dinámica?

El número de elementos del arreglo se indica en el momento de

instanciarlo, esto puede ocurrir en la misma declaración (ejemplos
anteriores) o posteriormente a través del operador new. El operador new
se usa seguido del tipo y entre corchetes el número de elementos del
arreglo a crear.

new <tipo de dato> [<cantidad de elementos>]

En ese momento se asigna el bloque de memoria necesario para crear el

arreglo, guardando la dirección en una variable en caso de realizar la
asignación.

Seguidamente se muestran algunos ejemplos de creación de arreglos a

través del operador new.

            /* 1 */ int[] temperaturas;

            /* 2 */ uint[] notas;

            /* 3 */ double[] pesos = new double[3];        

            /* 4 */ char[] palabra = new char[4];

            /* 5 */ string[] nombres = new string[1];

            /* 6 */ temperaturas = new int[2];

            /* 7 */ notas = new uint[5];

Pregunta: ¿Qué sucederá en la memoria al ejecutarse cada una de las

instrucciones anteriores?

En las dos primeras instrucciones solamente se están declarando las

variables, en este caso se le asigna a ambas el valor por defecto de las
referencias (null). Posteriormente, ante las respectivas aplicaciones del
operador new, se crea en la memoria (heap) una instancia para cada uno
de los arreglos y la referencia se almacena en las respectivas variables.
Las diferentes localizaciones de los arreglos se inicializan en los valores
por defecto de los respectivos tipos de datos.

Sea cual sea la forma de instanciar el arreglo, luego de instanciarlo, se

puede acceder a cualquiera de sus elementos. No hay que olvidar que la
variable declarada como arreglo lo que contiene es una referencia al
arreglo y no el arreglo en si mismo. Esa referencia es posible usarla para
acceder individualmente a cualquiera de los elementos, disponiendo del
índice del elemento al cual se desea acceder como ya se vio con
anterioridad.

Como se ha expuesto con anterioridad, C# permite indicar el tamaño del

arreglo de forma dinámica. Es por ello que se pueden declarar e
instanciar los arreglos en tiempo de ejecución. Cuando se declara un
arreglo y no se instancia, C# crea una referencia nula al arreglo como se
demuestra en la representación gráfica de las dos primeras instrucciones
en la figura anterior. Cualquier intento de acceso usando esta referencia
causaría una excepción. Es posible usar la constante null para
comprobar si se ha instanciado la variable o no como se muestra a
continuación:

if (notas == null) …

Aún cuando existen diferencias en la implementación de los arreglos en

los diferentes lenguajes, los arreglos son un recurso de construcción de
tipos que se caracteriza porque asocia a un conjunto de valores índices
un conjunto de valores que son las componentes. El nombre de la
estructura establece una cierta función donde el dominio es el tipo que
sirve de índice y la imagen es el tipo del componente [8]:
temperaturas : 0..4                 int

notas : 0..1                         uint

pesos : 0..2                       double

alabra : 0..3                      char

nombres : 0..0                   string

Para acceder a cualquiera de los elementos de los arreglos se realiza de

la forma conocida a través de los corchetes y los índices.

Situación de análisis

Imagine ahora que fue creado el arreglo notas para cinco (5) asignaturas
y luego tenemos una sexta (6) nota que se debe incluir.

Pregunta:        ¿Cómo es posible adicionar una sexta nota si solamente

se tienen cinco localizaciones en el arreglo notas? Manteniendo la
referencia a través de la variable notas y sin perder los datos anteriores?

Esto no es posible directamente, es decir, los arreglos se crean

dinámicamente, pero una vez creados son estáticos, no pueden cambiar
su tamaño. Pero existe una solución para esto creando un arreglo
temporal (tempNotas) con las nuevas capacidades que necesitamos (6),
después se copian los elementos existentes en el arreglo original hacia
este temporal y finalmente se cambia la referencia del original hacia el
nuevo arreglo creado. Ahora se dispone de una nueva localización
creada para almacenar el nuevo elemento (la sexta nota).  Seguidamente
se muestra un bloque de código donde se ejemplifican estos pasos.

            uint[] tempNotas = new uint[6];

            notas.CopyTo(tempNotas, 0);

            notas = tempNotas;

            notas[5] = 4;

}
Cuando se asigna una variable que contiene un valor de un tipo de dato
simple a otra variable del mismo tipo, lo que se hace es copiar el valor de
la primera a la segunda (semántica de copia por valor) y por tanto se
tienen dos variables con el mismo valor que son independientes entre si.
Sin embargo, los arreglos utilizan semántica de copia por referencia, o
sea, al asignar una variable de tipo arreglo a otra de su mismo tipo, lo
que se hace es duplicar la referencia. Es decir, ahora se cuenta con un
único arreglo pero con dos referencias al mismo en dos variables
diferentes

Saltar Navegación

Navegación
 Página Principal
o Área personal
o Páginas del sitio
o Mi perfil
o Mis cursos
 P.O.O C#
 Participantes
 General
 Tema 1
 Tema 2
 Tema 3
 Declaración de variables. Expresiones,
operadores,...
 Cuestionario lección #3
 Ciclos y Arreglos
 Custionario Lección #4
 Métodos. Creación de clases y objetos. Manejo de
l...
 Custionario lección #5
 Relaciones entre clases
 Abstracción, herencia, polimorfismo.
Encapsulamiento
 Cuestionario lección #7
 Implementación de clases en C#
 Implementación de clase en C#
 Tarea #2
 Tarea Integradora
 PB
 VB
Saltar Joven Club de Computación y Electrónica

Joven Club de Computación y Electrónica

Enlace al Sitio de los Joven Club de Computación y Electrónica.

Cursos a distancia. Joven Club de Computación y Electrónica

Usted se ha identificado como Mariela Pavó (Salir)

P.O.O C#