GUIDA Corso di Pascal/Delphi

gronag

Utente Èlite
20,848
7,077
La realizzazione di un programma software è un'attività che possiamo suddividere in diverse fasi (secondo l'approccio top-down): la definizione dei dati del problema, l'organizzazione dell'algoritmo, la stesura del programma, la fase di testing e di debugging, la documentazione e la manutenzione.
Facendo una valutazione del rapporto tra i costi di produzione del software e i costi di manutenzione, si evince che questi ultimi sono molto più elevati rispetto ai primi, per cui, al fine di razionalizzare al meglio il lavoro di costruzione di un programma, sono state definite alcune regole che, nel loro insieme, costituiscono il metodo della "programmazione strutturata".
Formalmente la programmazione strutturata mira alla progettazione di un programma costituito da parti interdipendenti, in base ad un determinato modello organizzativo.
All'interno di un algoritmo si possono individuare tre strutture tipiche, vale a dire tre schemi in cui le istruzioni possono essere organizzate: la sequenza, la selezione (o alternativa) e la ripetizione (o ciclo).
Queste tre strutture organizzative vengono chiamate "strutture di controllo", in quanto atte a controllare il percorso risolutivo del programma che poi perverrà al risultato voluto.
In base al classico teorema di Bohm-Jacopini, del 1966, un qualsiasi algoritmo può essere scritto utilizzando esclusivamente le tre strutture di base (sequenza, selezione e ripetizione).
In effetti, nella formulazione originale, il teorema di Bohm-Jacopini affermava che un algoritmo che usa istruzioni di salto (goto), si può rappresentare soltanto con le tre strutture menzionate: si tratta di due forme equivalenti ma ovviamente quella prodotta usando le strutture di controllo consente la costruzione di algoritmi più ordinati.
Vediamo di definire meglio i termini della questione: innanzitutto per programma "proprio" s'intende un programma che ha un unico ingresso ed un'unica uscita e nel quale ciascuno statement appartiene ad un percorso che porta dall'ingresso all'uscita (non è consentito saltare dall'interno di un blocco all'inizio di un altro blocco, né tantomeno in mezzo).
Inoltre due programmi si dicono equivalenti se realizzano lo stesso algoritmo, con operazioni diverse.
Su queste premesse, il teorema di Bohm-Jacopini (che non dimostrerò) afferma che, dato un programma proprio, è possibile costruire un programma strutturato equivalente, che fa uso di soli tre oggetti logici, i quali risultano gli unici costrutti sintattici della programmazione strutturata (che godono delle proprietà dei programmi propri).
A partire dalla programmazione strutturata si sono evolute, attraverso gli approcci top-down e bottom-up, altre metodologie di lavoro che, nel loro insieme, assumono il nome di "ingegneria del software".

Qui ho parlato di Delphi: https://forum.tomshw.it/threads/tut...-manuali-tutorial-risorse.290243/post-7865101
Delphi è un linguaggio OOP, in cui i concetti di classe ed oggetto sono fondamentali: una classe é la rappresentazione astratta di un'entità, un oggetto è un esemplare della classe o meglio un'istanza della classe.
Attraverso il meccanismo dell'ereditarietà, è possibile ottenere classi derivate a partire da classi base. Una classe consente di descrivere i campi, le proprietà, i metodi e gli eventi di un oggetto.
Proprietà e metodi vengono denominati "membri" dell'oggetto. Con Delphi è possibile creare applicazioni nell'ambiente .NET Framework, l'infrastruttura software per il Web creata da Microsoft, inoltre si possono utilizzare le librerie ADO.NET per la connessione dei database in rete e ASP.NET per le applicazioni eseguibili sul server Web, infine con Windows Forms si possono creare interfacce grafiche e potenti applicazioni in ambiente Windows (Windows-based).
Un programma in Delphi viene chiamato "progetto" e può contenere parecchi file di diverso tipo. Per creare un nuovo progetto, si possono utilizzare le librerie VCL dei componenti visuali oppure l'applicazione Windows Forms: in questo trattato verrà utilizzata la modalità VCL, in cui ciascuna finestra corrisponde ad un form.

P.S. In casi eccezionali è possibile, al fine di migliorare l'efficienza di un programma, utilizzare l'istruzione di salto incondizionato GOTO ma sottolineo ancora una volta che qualsiasi programma può essere scritto senza far uso di salti incondizionati (secondo i dettami della programmazione strutturata) che lo rendono non strutturato e ne diminuiscono notevolmente la leggibilità. Pascal e Delphi contemplano il GOTO ma se ne suggerisce l'uso soltanto per gestire situazioni eccezionali, come ad esempio la gestione degli errori o altre anomalie.
 

gronag

Utente Èlite
20,848
7,077
LE STRUTTURE DI CONTROLLO
---------------------------------
Come abbiamo visto, le strutture di controllo fondamentali della programmazione strutturata godono delle proprietà tipiche dei programmi propri, ovvero delle strutture a blocchi.

LA SEQUENZA
----------------
Qualsiasi programma si risolve eseguendo una serie di azioni in sequenza.
La sequenza è una concatenazione di due o più blocchi tale che l'uscita di un blocco corrisponde all'ingresso del blocco successivo e così via.
Volendo, ad esempio, calcolare l'età media di un certo numero di individui, conoscendo il numero di componenti NC e le relative età e utilizzando il formalismo dei flow-chart, avremo:



LA SELEZIONE (IF-THEN-ELSE)
---------------------------------
Per risolvere un problema generalmente è necessario operare delle scelte per decidere quali azioni intraprendere. Tali scelte, nel caso della programmazione, non sono soggettive ma determinate dal verificarsi o meno di certe condizioni.
Graficamente il costrutto IF-THEN-ELSE si rappresenta con una losanga (un rombo) con un unico ingresso e due rami di uscita contrassegnati TRUE (vero) e FALSE (falso), che si ricongiungono alla fine del costrutto.
All'interno della losanga è contenuta la condizione. Se la condizione risulta vera, si deve percorrere il ramo TRUE, altrimenti si deve percorrere il ramo FALSE. Ribadisco che per soddisfare le proprietà dei programmi propri, è fondamentale il ricongiungimento dei due rami. Come esempio, supponiamo di voler calcolare le radici reali di un'equazione di secondo grado, con coefficienti A, B e C. In base al simbolismo dei flow-chart, avremo:



Volendo dettagliare il programma, inseriamo sul ramo TRUE un altro blocco in modo da distinguere i due casi D>0 e D=0:



I CICLI (WHILE-DO e REPEAT-UNTIL)
----------------------------------------
A volte accade che, nella risoluzione di un problema, alcune azioni possano ripetersi fino al verificarsi di una certa condizione. I cicli (o loop) possono essere implementati mediante il costrutto WHILE-DO, nel quale si distinguono due componenti: la condizione e il blocco ripetuto. La condizione è presente all'interno della losanga alla quale si perviene da un ramo d'ingresso, il ramo d'uscita è contrassegnato FALSE mentre il ramo TRUE contiene il blocco da ripetere e si ricongiunge col ramo d'ingresso alla losanga.

1613140077523.png

Esiste un altro costrutto che, in alcuni casi, può sostituire il WHILE-DO: si tratta del REPEAT-UNTIL.
Il REPEAT-UNTIL esegue il test in fondo al blocco iterativo, quindi esegue il blocco, valuta la condizione, se essa è FALSE riesegue il ciclo, se è TRUE esce dal ciclo.

1613142059987.png


Le due strutture sono equivalenti, il REPEAT-UNTIL si può ricondurre ad un WHILE-DO.
A presto 😉

P.S. Il costrutto for (esattamente for-do nel caso di Pascal/Delphi) viene utilizzato nel caso in cui si conosca esattamente il numero di volte che un blocco di istruzioni deve essere eseguito (in pratica il numero di cicli è definito a priori).
Nel caso della somma di N numeri naturali, ad esempio, c'è bisogno di un contatore, che assume la funzione di variabile di controllo, allo scopo di controllare l'esecuzione del ciclo; tale variabile può essere di un qualsiasi tipo scalare.
Il contatore viene incrementato di 1 automaticamente ad ogni iterazione e ovviamente all'interno del ciclo non può essere modificato. Quindi N contiene il numero di iterazioni (in pratica quanti sono i numeri naturali da sommare), inizializziamo la somma a 0 (somma:=0) e il contatore I a 1 (I:=1).
Ora "iteriamo": somma <-- somma+1 e I <-- I+1.
Facciamo il test: I>N ?
Se è FALSE, torniamo all'iterazione, se è TRUE usciamo dal ciclo e visualizziamo la somma finale.
Ricapitolando (in una sorta di diagramma di flusso in pseudo-codifica Pascal-like):

1) START
2) N (richiesta di quanti numeri naturali si devono sommare);
3) somma:=0;
4) I:=1;
5) somma <-- somma+1; (questo è l'inizio del ciclo)
6) I <-- I+1;
7) I>N ?
Se FALSE, tornare al punto 5) (cioè "cicliamo").
Se TRUE, usciamo e visualizziamo il risultato della variabile somma.

Da notare che nel diagramma di flusso l'inizializzazione del contatore I di controllo viene fatta all'esterno del ciclo for ma in realtà essa avviene all'interno del for (cioè for I := 1 to N do ... in Pascal/Delphi) e il suo incremento è automatico a ciascuna esecuzione del ciclo. Dunque è errato scrivere I := I+1 all'interno del ciclo.
 

Allegati

  • 1613140148768.png
    1613140148768.png
    33.2 KB · Visualizzazioni: 7

gronag

Utente Èlite
20,848
7,077
UNO SGUARDO ALL'IDE DI DELPHI
--------------------------------------

Partiamo dalla definizione di form: il form è una finestra vuota nella quale vengono inseriti gli elementi che un utente vede. Gli oggetti che vengono inseriti nel form prendono il nome di "controls" (controlli).
Le istruzioni (statements) formate dalle parole-chiave del linguaggio Delphi e associate ad un form costituiscono il "code" (codice) del linguaggio stesso. Le procedure e le dichiarazioni sono contenute nelle "units" (unità).
L'ambiente di lavoro contiene, nella parte superiore, sia la barra dei menu che la barra degli strumenti, uguali a quelle degli applicativi di Windows.
https://www.embarcadero.com/products/delphi (animazione dell'IDE di Delphi)
Vediamo ora le finestre tipiche dell'IDE di Delphi: 1) l'Object Inspector (la finestra delle proprietà) consente di visualizzare e modificare i valori degli attributi degli oggetti dell'interfaccia grafica; 2) la finestra di "design" comprende il form e i controlli ad esso associati; 3) il Project Manager (la finestra del progetto) contiene le componenti del progetto; 4) la Tool Palette (la casella degli strumenti) contiene tutti i controlli (i bottoni, le etichette, le caselle di testo, ecc.) dell'interfaccia utente.
La finestra del codice in Pascal può essere aperta in vari modi, ad esempio facendo doppio click in un punto qualsiasi del form.
I form e i controlli formano gli oggetti per creare un'interfaccia grafica. Ad ogni form è associata una unit che contiene il codice associato ai controlli per gestire gli eventi causati dalle azioni dell'utente o dal sistema.
Per progettare un controllo si utilizza la tool palette. Form e controlli hanno alcune proprietà che ne specificano le caratteristiche.
Le istruzioni di Delphi vengono organizzate in sottoprogrammi: procedure e function. Le unit sono i file (con estensione .pas) che contengono il codice sorgente.
E' opportuno che tutti i file di un progetto si trovino nella stessa directory.

P.S. Quanto detto vale anche per Lazarus, l'IDE cross-platform per applicazioni RAD compatibile con Delphi 😉
 

Entra

oppure Accedi utilizzando

Hot: Quale crypto per il futuro?

  • Bitcoin

    Voti: 82 47.1%
  • Ethereum

    Voti: 67 38.5%
  • Cardano

    Voti: 23 13.2%
  • Polkadot

    Voti: 8 4.6%
  • Monero

    Voti: 15 8.6%
  • XRP

    Voti: 14 8.0%
  • Uniswap

    Voti: 4 2.3%
  • Litecoin

    Voti: 12 6.9%
  • Stellar

    Voti: 12 6.9%
  • Altro (Specifica)

    Voti: 25 14.4%

Discussioni Simili