Il primo progetto che si propone di costruire (a scopo puramente didattico, per comprendere le metodologie fondamentali delo sviluppo di un’applicazione) consiste nella preparazione di una applicazione Windows che chiede il nome dell’utente e, ricevutolo, gli mandi un messaggio di saluto. Il risultato del lavoro è quindi un file eseguibile di nome “Saluto.exe”.
La versione di C++Builder alla quale si fa riferimento è la 6.0.
Seguendo le istruzioni del paragrafo precedente, si crei nella posizione adeguata una cartella e le si assegni il nome “Saluto” e si lanci C++Builder.
Lanciando C++Builder dal desktop di Windows si entra nell’ambiente integrato di sviluppo (IDE=”Integrated Development Environment”) che presenta all’utente un menù principale.
Attivando ogni voce di tale menù si apre un menù secondario a tendina contenente altre voci. In generale si indicheranno le sequenze di voci di menù unendole con una freccia: ad esempio File->New Application.
All’inizio di una seduta di programmazione in C++Builder conviene accertarsi, selezionando Tools->Environment Options, che l’assetto dello IDE corrisponda alle proprie esigenze.
In particolare è utile attivare, nel foglio “Preferences”, l’opzione “Show compiler progress”. Si fa così in modo che, al termine della compilazione di un progetto, C++Builder comunichi al programmatore l’esito della compilazione stessa.
Se nella seduta inizia l’elaborazione di un nuovo progetto conviene seguire questa procedura.
Selezionare File->Close All per essere sicuri che l’ambiente di programmazione sia pulito.
Selezionare File->New Application per creare l’interfaccia grafica del programma.
Appare sul monitor un rettangolo, che rappresenta appunto la finestra creata.
Questa finestra è uno dei componenti visivi di C++Builder, cioè un oggetto grafico di C++Builder, descritto in una delle sue librerie (VCL=”Visual Component Library”): in specifico si tratta di un TForm.
C++Builder usa infatti come linguaggio di programmazione il C++ cioè una versione del C potenziata per permettere l’elaborazione degli “oggetti” cioè di un tipo di dati molto più complessi di quelli previsti dal C classico.
Il tipo oggetto è un tipo strutturato composto da
Le proprietà specificano le caratteristiche dell’oggetto e sono rappresentate da dati di tipo semplice (interi, stringhe, reali, verità, puntatori) o strutturato (array, record, liste, oggetti).
I metodi sono funzioni, cioè sequenze di istruzioni che possono accedere direttamente alle proprietà dell’oggetto.
I rilevatori di eventi sono funzioni che controllano il sistema e segnalano all’oggetto i cambiamenti eventualmente intervenuti nel sistema stesso (ad esempio la pressione di un tasto, il movimento del mouse, ecc.) perché l’oggetto possa rispondere eseguendo un opportuno metodo all’evento stesso.
La composizione di tutti gli oggetti dello stesso tipo è stabilita in generale da un 'descrittore di oggetti' detto classe.
La relazione tra classe e oggetto è, pressapoco, quella esistente tra uno stampo e il pezzo stampato: nello stampo sono definite tutte le caratteristiche degli oggetti da stampare, ma i pezzi reali, concreti, esistono solo dopo essere stampati. Finché c'è solo lo stampo, i pezzi sono solo 'potenziali' non 'attuali'.
Una volta descritta una classe, si possono generare oggetti di questa classe usando un metodo speciale, stabilito nella descrizione della classe, detto costruttore (constructor). Una classe può avere più costruttori, ma tutti devono avere lo stesso identificatore della classe, differendo tra loro solo per il tipo di argomenti. Un costruttore è attivato dall'operatore new.
Ad esempio, se si è descritta la classe 'Cane' si può generare un oggetto 'cane' usando l'operatore new nel seguente modo:
class Cane: public TObject //la classe Cane è 'figlia' della classe TObject,
//predefinita in C++Buider e 'antenata' di tutte le sue classi
{
public:
Ansitring razza, nome; //proprietà di tipo AnsiString
int eta; //proprietà di dipo int
Cane(); //intestazione del costruttore
};
.......................
Cane::Cane(): //corpo del costruttore Cane(): invoca il costruttore della classe 'madre'
TObject()
{
}
.......................
Cane *cane = new Cane(); //Si costruisce un oggetto di classe Cane.
//Questo oggetto è indicato dal puntatore *cane.
//Proprietà e metodi di un oggetto indicato da un puntatore
//sono individuati dal nome del puntatore seguito da ->
//seguito dal nome della proprietà o del metodo.
//I valori delle stringhe sono delimitati dalle doppie virgolette.
cane->nome = "Pluto"; //si definiscono i valori delle proprietà dell'oggetto cane
cane->razza = "bastardo";
cane->eta = 5;
.......................
Nell'esempio si è descritta la classe 'Cane' dotata delle proprietà
e del costruttore Cane().
Proprietà e costruttore sono pubblici, cioè sono accessibili anche dall'esterno della classe. Proprio in quanto questi dati sono pubblici è possibile, in qualunque altro punto di un programma, riferirsi ad essi, quindi, ad esempio, invocare il costruttore o assegnare un valore alle proprietà.
Notare che in C++ maiuscole è minuscole sono considerate lettere diverse: nell'esempio Cane è la classe, *cane è il puntatore all'oggetto. Per non fare confusioni, è bene darsi delle regole, anche se non obbligatorie: qui si è deciso di indicare le classi con un identificatore che comincia con maiuscola e gli oggetti con idendificatori inizianti con minuscola.
In C++Builder tutte le classi di libreria, cioè predefinite dalla Borland, iniziano con T maiuscola.
Una volta descritta una classe si può dedurre dalla sua descrizione una nuova classe che mantiene tutti i caratteri della precedente con l'aggiunta di nuove proprietà, nuovi metodi, nuovi eventi.
class Bulldog: public Cane //la classe Bulldog è 'figlia' della classe Cane e
//ne eredita le proprietà e i metodi
{
public:
Bulldog(AnsiString n, int e); //costruttore della classe Bulldog: intestazione (header)
};
....................... corpo del costruttore..........................
Bulldog::Bulldog(AnsiString n, int e): //costruttore della classe Bulldog: corpo (body)
Cane()
{
razza = "Bulldog";
nome = n;
eta = e;
}
.......................
Bulldog *canebd = new Bulldog("Bull",2);//costruzione dell'oggetto canebd
.......................
Cliccando su New Application C++Buider definisce
Quest'oggetto viene rappresentato sullo schermo.
Per vedere ed eventualmente cambiare le proprietà dell’oggetto creato, cliccare su View->Object Inspector. Appare così di fianco al rettangolo della finestra, un riquadro intestato appunto Object Inspector (in seguito OI) diviso in due fogli selezionabili con un click del mouse:
Properties presenta una tabella a due colonne: a sinistra il nome delle proprietà, a destra il suo valore.
Alcune proprietà sono di tipo intero, altre di tipo stringa, altre di tipo booleano (true, false) altre possono assumere solo valori prefissati all’interno di una lista.
Ad esempio:
Caption: è l’intestazione della finestra, cioè la scritta che compare su fondo scuro in alto. In OI di fianco a Caption c’è una scritta provvisoria (ad esempio Form1), assegnata da C++Builder per “default” (cioè in mancanza di indicazioni dell’utente). Scrivere al posto di Form1 il titolo Saluto.
Premendo Invio al termine della digitazione, si osserva il cambiamento dell’intestazione della finestra.
Name: è l’identificatore, cioè il nome dell’oggetto. Questo nome, preceduto da una 'T' diventa anche il nome della classe creata, figlia di TForm. Di fianco a Name appare ancora Form1. Sostituire a questa scritta un nome significativo per il programmatore. Questo nome, come tutti gli identificatori del C++, deve essere una stringa continua di caratteri alfanumerici inglesi con iniziale alfabetica. Non può contenere spazi né lettere accentate. Se si vogliono evidenziare parole componenti, usare il trattino di sottolineatura (in inglese “underscore”). Scrivere, ad esempio, FrmSaluto (per “Form Saluto”).
Attenzione a non confondere Caption e Name. Come valore di Caption si può scrivere qualunque cosa, con spazi e lettere accentate. Scrivendo FrmSaluto come valore di Name si osserva che cambia il nome dell’oggetto in OI.
Non è obbligatorio, ma è una comodità per un programmatore italiano, usare per i propri identificatori nomi italiani, in modo da distinguerli dai nomi di default prodotti da C++Builder.
Color: è il colore di sfondo della finestra. Lasciare il colore di default o cliccando sulla freccetta nella colonna destra, selezionare il nome del colore desiderato. Gli sfondi delle finestre devono essere colori tenui e pastellati, per non rovinare la vista gli utenti. Evitare quindi “clRed” o cose del genere. Sperimentare.
Left, Top: sono interi che fissano la posizione del vertice sinistro alto del rettangolo della finestra rispetto allo schermo del monitor. Ricordare che ogni punto di uno schermo grafico è individuato da una copia di numeri interi (ascissa e ordinata) con origine (0,0) nel punto sinistro alto dello schermo. Quindi all’aumentare dell’ordinata il punto si sposta in basso. Le dimensioni dello schermo vanno fissate dal desktop di Windows. Di solito va bene 800x600.
Width, Height: sono larghezza e altezza della finestra creata. Ovviamente non ha senso che superino le corrispondenti dimensioni dello schermo.
Ma in linea di massima le dimensioni della finestra principale di un programma è bene che coincidano con quelle dello schermo. Per ottenere che la finestra, all’avvio del programma, copra l’intero schermo, andare all’ultima proprietà in OI, cioè WindowState e selezionare wsMaximized.
La creazione della finestra principale è già sufficiente per produrre un eseguibile di Windows. Tale eseguibile non fa molto di più che esistere, ma è già un risultato significativo.
A questo scopo si salvino nella giusta locazione e con i nomi adeguati tutti i files che C++Builder ha prodotto per gestire il progetto.
Attivare File->Save as....
Appare un dialogo tramite cui è possibile selezionare la cartella “Saluto” e scrivere il nome da assegnare al file contenente il codice della TForm FrmSaluto appena creata e messa a punto.
Si scriva come nome del file UnitSaluto (Unità Saluto) perché tale file non è il file del programma, ma il file di una unità ausiliaria. Fatto ciò, cliccare su “Salva” concludendo l’operazione e chiedendo il dialogo. Il file è salvato con nome “UnitSaluto.cpp”.
Attivare File->Save Project as....
Appare un dialogo simile al precedente per il salvataggio del progetto. Selezionare sempre la cartella di progetto e scrivere il nome da assegnare al file di programma. Questo nome sarà anche quello dell’eseguibile di Windows. Fatto ciò, cliccare su “Salva” concludendo l’operazione e chiudendo il dialogo. Il file è salvato con nome “Saluto.bpr” (L’estensione bpr sta per Builder Project).
Ora il progetto ha un nome e può essere compilato senza confusioni.
Project->Build Saluto. Se si è attivata l’opzione “Show compiler progress” un riquadro riporta l’andamento della compilazione e, se tutto va bene, al termine della stessa segnala OK. Si è ottenuta così la compilazione del progetto e la produzione del file eseguibile Saluto.exe, che viene registrato sempre nella cartella del progetto. Questo file potrà essere eseguito da tutti i computer cha hanno Windows come sistema operativo.
Saluto.exe può comunque essere lanciato anche da C++Builder attivando Run->Run. Provando si vede che lo schermo viene occupato da una finestra intestata “Saluto” (la Caption assegnata) e di colore corrispondente a quello assegnato alla proprietà Color.
Questa finestra, pur non servendo a molto per il momento, è già dotata di notevoli caratteristiche. Agendo con il mouse può essere ridimensionata e poi spostata sullo schermo. Possiede in alto a destra tre piccole icone che, con un click, permettono di minimizzarla, riportarla alle precedenti dimensioni e posizione e chiuderla.
Dopo aver sperimentato, chiudere la finestra.
Si torna così nello IDE di C++Builder.
