Esiste un software per convertire un diagramma di flusso in codice Java?



di

Uno svantaggio dei diagrammi di flusso è la loro mancanza di definizione dei dati. I diagrammi di flusso documentano la sequenza logica e i percorsi decisionali, ma non i dati usati dal programma.

Un programma completo richiede una chiara definizione sia dell'algoritmo (logica del programma) che dei dati su cui agisce. Uno degli obiettivi della programmazione orientata agli oggetti è quello di definire insieme dati e comportamento. Per esempio, se il vostro programma ha bisogno di una struttura dati Stack, questa struttura dati deve comportarsi in un modo ben definito e coerente.

Una Stack può essere implementata usando un array o può essere implementata usando una lista collegata, ma i comportamenti astratti saranno gli stessi. Per esempio, i comportamenti comuni di uno stack sono:

  • Push - Mettere un elemento in cima allo stack
  • Pop - Rimuovere l'elemento in cima allo stack
  • Top - Visualizzare l'elemento in cima allo stack senza cambiare lo stack
  • Clear - Svuotare tutti gli elementi dallo stack
  • Is_Empty - Indica quando uno stack è vuoto
  • Is_Full - Indica quando uno stack delimitato è pieno

Mentre un diagramma di flusso può essere creato per ciascuna di queste sei operazioni, un programma non può essere creato solo sapendo cosa deve fare ogni operazione. Lo stack sarà implementato usando un array, creando comunemente uno stack delimitato con una capacità massima fissa, o sarà implementato usando una lista collegata creando uno stack non delimitato la cui capacità è limitata solo dalla quantità di memoria disponibile sul computer?

Come farà un programma a sapere che tipo di stack implementare semplicemente leggendo un diagramma di flusso?

Molti linguaggi risolvono questo tipo di problema permettendo al programmatore di creare librerie di tipi di dati generici. I generici applicano un algoritmo e sono specializzati essendo parametrizzati con il tipo di dati che devono contenere, ed eventualmente il numero massimo di elementi che devono gestire.

Ecco due esempi di pacchetti di stack generici in Ada. The first example is a generic bounded stack. The second example is a generic unbounded stack.

  1. Generic 
  2. type Element_Type is private; 
  3. package Generic_Bounded_Stack is 
  4. type Stack(Size : Positive) is tagged private; 
  5. function Is_Empty(Item : in Stack) return Boolean; 
  6. function Is_Full(Item : in Stack) return Boolean; 
  7. function Count(Item : in Stack) return Natural; 
  8. function Top(Item : in Stack) return Element_Type with 
  9. Pre => not Item.Is_Empty; 
  10. procedure Push(Item : in out Stack; Value : in Element_Type) with 
  11. Pre => not Item.Is_Full, 
  12. Post => (Item.Count = Item'Old.Count + 1 and 
  13. Item.Top = Value); 
  14.  
  15. procedure Pop(Item : in out Stack; Value : out Element_Type) with 
  16. Pre => not Item.Is_Empty, 
  17. Post => (Item.Count = Item'Old.Count - 1 and 
  18. Value = Item'Old.Top); 
  19. private 
  20. type Buf_T is array(Natural range <>) of Element_Type; 
  21. type Stack(Size : Positive) is tagged record 
  22. Buf : Buf_T(1..Size); 
  23. Idx : Positive := 1; 
  24. Tally : Natural := 0; 
  25. end record; 
  26. end Generic_Bounded_Stack; 

The file shown above is the package specification for a generic unbounded stack. La specifica del pacchetto definisce il parametro generico usato dal pacchetto. In questo caso l'unico parametro è un tipo di dati. Può essere qualsiasi tipo di dati.

La specifica definisce l'API o interfaccia pubblica al tipo di dati Stack. La parte privata della specifica del pacchetto definisce il tipo di dati privato usato per implementare lo stack delimitato. Il tipo Stack consiste di una Dimensione, un array contenente i dati, un indice nell'array che indica la cima dello stack, e un conteggio degli elementi attualmente sullo stack.

The package specification for an unbounded stack is:

  1. generic 
  2. type Element_Type is private; 
  3. package Generic_Unbounded_Stack is 
  4. type Stack is tagged private; 
  5.  
  6. function Is_Empty(Item : Stack) return Boolean; 
  7. function Count(Item : Stack) return Natural; 
  8. procedure Push(Item : in out Stack; Value : Element_Type) with 
  9. Post => (Item.Count = Item'Old.Count + 1 and 
  10. Item.Top = Value); 
  11.  
  12. procedure Pop(Item : in out Stack; Value : out Element_Type) with 
  13. Pre => not Item.Is_Empty, 
  14. Post => (Item.Count = Item'Old.Count - 1 and 
  15. Value = Item'Old.Top); 
  16. function Top(Item : in Stack) return Element_Type with 
  17. Pre => not Item.Is_Empty; 
  18.  
  19. procedure Remove(Item : in out Stack) with 
  20. Post => Item.Is_Empty; 
  21. private 
  22. type Node; 
  23. type Node_Access is access Node; 
  24. type Node is record 
  25. Value : Element_Type; 
  26. Next : Node_Access; 
  27. end record; 
  28. type Stack is tagged record 
  29. Tally : Natural := 0; 
  30. Head : Node_Access; 
  31. end record; 
  32. end Generic_Unbounded_Stack; 

Note that the only difference between the public API for the unbounded stack is that it does not have a function Is_Full. The private part is very different. There is no data member named Size because the size is variable. The Stack type defined in the private part only contains a Tally holding the number of elements in the stack and a variable named Head which holds an access to the list containing the elements. Un accesso in Ada è simile a un riferimento in Java o C++.

Nota che la procedura Push per lo stack non delimitato non ha alcuna pre-condizione mentre la procedura Push per lo stack delimitato ha una pre-condizione. Vi aspettate che lo strumento automatizzato sia in grado di capire la differenza tra le pre-condizioni delle procedure da un diagramma di flusso?