1. 1 Introducción
2. 2 Historia
3. 3 Manual de referencia
4. 4 Instalación
5. 5 Hola Mundo
6. 6 Elementos del lenguaje
7. 7 Tipos
8. 8 Enteros
9. 9 Enumeraciones
10. 10 Coma flotante
11. 11 Coma fija
12. 12 Arrays
13. 13 Strings
14. 14 Registros
15. 15 Registros discriminados
16. 16 Registros variantes
17. 17 Punteros a objetos
18. 18 Punteros a subprogramas
19. 19 Tipos derivados
20. 20 Tipos etiquetados (orientación a objetos)
21. 21 Subtipos
22. 22 Objetos (variables y constantes)
23. 23 Atributos
24. 24 Expresiones
25. 25 Operadores
26. 26 Sentencias y estructuras de control
27. 27 Subprogramas
28. 28 Sobrecarga
29. 29 Entrada/salida
30. 30 Pragmas
31. 31 Interfaz con otros lenguajes
32. 32 Diseño y programación de sistemas grandes
33. 33 Paquetes
34. 34 Clausula use
35. 35 Clausula with
36. 36 Paquete Standard
37. 37 Declaraciones
38. 38 Ámbito
39. 39 Visibilidad
40. 40 Renombrado
41. 41 La biblioteca Ada (unidades y subunidades)
42. 42 Unidades de biblioteca
43. 43 Unidades hijas
44. 44 Subunidades
45. 45 Compilación separada y dependiente
46. 46 Tipos abstractos de datos
47. 47 Tipos limitados
48. 48 Unidades genéricas
49. 49 Excepciones
50. 50 Paquete Ada.Exceptions
51. 51 Concurrencia
52. 52 Tareas
53. 53 Sincronización de tareas mediante puntos de entrada o citas (entry)
54. 54 Aceptación de citas (accept)
55. 55 Selección de citas (select)
56. 56 Llamadas a punto de entrada complejas
57. 57 Tareas dinamicas: creación dinamica de tareas (tipos t
58. 58 Dependencia de tareas
59. 59 Ejemplos de tareas
60. 60 Programación distribuida con GLADE
61. 61 Novedades de Ada 2005
62. 62 Unidades predefinidas
63. 63 Paquete Ada.Strings.Fixed
64. 64 Paquete Ada.Strings.Unbounded
65. 65 Paquete Ada.Text_IO
66. 66 Paquete Ada.Text_IO.Editing
67. 67 Paquete Ada.Float_Text_IO
68. 68 Paquete Ada.Sequential_IO
69. 69 Paquete Ada.Command_Line
70. 70 Paquete Interfaces
71. 71 Recursos en la Web

26 - Sentencias y estructuras de control

Curso gratis creado por José Alfonso Malo Romero . Extraido de: http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Ada_/_Introducci%C3%B3n

16 Marzo 2006

""

Clasificación de sentencias

• Simple:
  
  
  
  • Secuencial:
    
    
    
    • Nula (null).
      
    • Asignación (X := Y;)
      
    • Llamada a procedimiento.
      
    • Código.
      
    • Llamada a punto de entrada (entry). En procesamiento paralelo.
      
    • Espera (delay).
      
    • Terminación abrupta (abort). En procesamiento paralelo.
    
    
  • Control:
    
    
    
    • Terminación de bucle (exit).
      
    • Salto a etiquetas (goto). No recomendable.
      
    • Elevación de excepción (raise).
      
    • Retorno de subprograma (return).
  
  
• Compuesta:
  
  
  
  • Secuencial:
    
    
    
    • Bloque.
      
    • Sentencia if.
      
    • Sentencia case.
      
    • Bucle (loop).
    
    
  • Paralela:
    
    
    
    • Sentencia accept.
      
    • Sentencia select.

Bloques

Ada distingue entre declaraciones, que introducen identificadores nuevos, y sentencias, que no lo hacen. El fragmento de texto más simple que incluye declaraciones y sentencias es un bloque.

Definición

bloque ::=

   [ identificador : ]

   [ declare

     parte_declarativa ]

   begin

     sentencias

   [ exception

     manejador_de_excepción

     { manejador_de_excepción } ]

   end [ identificador ] ;

 

Ejemplo

-- Supuestas X e Y declaradas con anterioridad de tipo Float:

 declare

   Temp: Float;  -- Esta variable sólo es visible dentro del bloque.

 begin  -- Se intercambian 2 variables.

   Temp := X;

   X := Y;

   Y := Temp;

 end;

 

Destacar que un bloque es una sentencia, cuando se ejecuta, se elaboran las declaraciones contenidas en su parte declarativa (entre declare y begin) y después se ejecutan las sentencias del cuerpo (entre begin y end).

El ámbito de las variables declaradas en un bloque finaliza cuando termina dicho bloque.

Sentencia de selección (if)

Flujo de control if-then-else

Definición

sentencia_selección ::=

   if condición then secuencia_de_sentencias

   [ { elsif condición then secuencia_de_sentencias } ]

   [ else secuencia_de_sentencias ]

   end if ;

 

Ejemplo

if Hoy = DOM then  -- Si hoy es domingo.

   Mañana := LUN;

 elsif Hoy /= SAB then  -- Si no es domingo ni sábado.

   Laborable := True;

 else  -- Cualquier otro caso.

   Mañana := TDía'Succ(Hoy);

 end if;

 

Sentencia de selección por casos (case)

Flujo de control de la estructura case

Definición

sentencia_selección_por_casos ::=

   case expresión is

     alternativa_caso { alternativa_caso }

   end case ;

 

 alternativa_caso ::=

   when elección { | elección } => secuencia_de_sentencias

 elección ::= expresión_simple | rango_discreto | others

 

Ejemplo

case Hoy is

   when MIE..VIE => Entrenar_duro;  -- Rango.

   when MAR | SAB => Entrenar_poco;  -- Varias elecciones.

   when DOM => Competir;  -- Una elección.

   when others => Descansar;  -- Debe ser única y la última alternativa.

 end case;

 

Bucles

Sentencia de bucle simple (loop)

Definición

sentencia_bucle_simple ::=

   [ identificador_bucle : ] loop

     secuencia_de_sentencias

   end loop [ identificador_bucle ] ;

 

Ejemplo

Vida: loop  -- El bucle dura indefinidamente.

   Trabajar;

   Comer;

   Dormir;

 end loop Vida;

 

Este bucle sólo se puede abandonar si alguno de los procedimientos levanta una excepción.

El bucle simple a menudo se acompaña de una sentencia exit para abandonar el bucle cuando se cumple una condición.

loop

   Alimentar_Caldera;

   Monitorizar_Sensor;

   exit when Temperatura_Ideal;

 end loop;

 

Sentencia de bucle iterativo (for)

Definición

sentencia_bucle_iterativo ::=

   [ identificador_bucle : ] for parámetros_for loop

     secuencia_de_sentencias

   end loop [ identificador_bucle ] ;

 

 parámetros_for ::= identificador in [ reverse ] rango_discreto

 

Ejemplo

for I in 1..N loop  -- I se itera desde 1 hasta N.

   V(I) := 0;

 end loop;

 

Sentencia de bucle condicional (while)

Definición

sentencia_bucle_iterativo ::=

   [ identificador_bucle : ] while condición loop

     secuencia_de_sentencias

   end loop [ identificador_bucle ] ;

 

Ejemplo

I := 1;

 while I > N loop  -- Se hace el bucle mientras se cumpla la condición.

   V(I) := 0;

   I := I + 1;

 end loop;

 

Otras sentencias de control (goto, exit, return, abort)

Sentencia goto

Antes de nada, decir que la utilización de sentencias goto se desaconseja totalmente. Ada posee estructuras de control adecuadas para evitar su uso. Si se soporta su utilización es por si se quiere traducir de otro lenguaje a Ada automáticamente.

Se especifica una etiqueta entre los símbolos << y >>, por ejemplo, <<Salto>>.

Se realiza el salto a dicha etiqueta con la sentencia goto Salto; que transferiría el control a la siguiente sentencia después de la etiqueta.

No puede usarse para transferir control fuera de un subprograma.

Sentencia exit

Termina el bucle nombrado en la sentencia o, si no aparece, el bucle más próximo que la contiene. Su notación sintáctica es:

sentencia_exit ::= exit [ nombre_bucle ] [ when condición ] ;

 

Sentencia return

Termina la ejecución del subprograma más próximo que la contiene, tanto en procedimientos como en funciones donde, además, se utiliza para devolver el resultado de dicha función. Su notación sintáctica es:

sentencia_return ::= return [ expresión ] ;

 

Sentencia abort

Se utiliza sólo para tareas. Implica la terminación incondicional de las tareas que se especifiquen. Su notación sintáctica es:

sentencia_abort ::= abort nombre_tarea { , nombre_tarea } ;

 

Manual de referencia de Ada

• Section 5: Statements

 

""

Anuncios Google

Autor y licencia de 'Curso de Ada'

Curso gratis de José Alfonso Malo Romero . Extraido de: http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Ada_/_Introducci%C3%B3n