Fino ad ora nello sviluppo dei programmi in C/C++ non avevamo mai sentito parlare di classi, oggetti, funzioni membro, attributi, overloading e tutto ciò che è previsto nella programmazione orientata agli oggetti. Scrivere un programma con la “logica” ad oggetti comporta una rivoluzione sostanziale nello sviluppo del programma stesso. Ciò, ovviamente, permette di sfruttare gli innumerevoli vantaggi che tale “logica” mette a disposizione. 

Il punto di partenza sta nel decidere qual è la scelta migliore per la gestione dei dati che devono essere trattati (organizzazione, memorizzazione, ecc); fatto ciò si deve passare alla definizione della classe, che in un certo qual modo è il cuore del programma, e alla sua implementazione.
Infine, con il main sarà possibile controllare il corretto funzionamento del programma. Infatti, il compilatore ci avverte se la sintassi del nostro programma è corretta, ma non ci garantisce che il risultato sia ottimo: per un compilatore l’istruzione A+B è corretta, come lo è A-B, ma non riesce a capire se in un determinato punto del programma l’operazione da compiere è l’addizione o la sottrazione al fine di avere un risultato, perlomeno, corretto.

Passiamo ora all'analisi di un semplice programma, quale può essere un euro-convertitore, prima di passare a qualcosa di più costruttivo.

Per prima cosa dobbiamo definire un classe, tale da garantire, perlomeno, la conversione euro/lire, lire/euro e una del tutto generale.

// definizione classe
class conversione
{
public:
conversione(); //costruttore
~conversione(); //distruttore
void fattore_conv(float fatt); //funz. di set fattore di conversione
void calcola(float num); //funzione di calcolo euro/lire
void calcola2(float num); //funzione di calcolo lire/euro
float visual_ris(); //funzione di intefaccia
private:
float *p; //
};

Come detto in precedenza la parola chiave class identifica la definizione di una classe, seguita dal sono nome (nel nostro caso conversione). La nostra classe presenta quattro funzioni membro, il cui accesso è di tipo public, cioè accessibile dall'esterno. Si può notare inoltre la definizione di un puntatore di tipo float: questo puntatore è indispensabile per allocare e deallocare nell'area di memoria heap i dati relativi al risultato della conversione ed al fattore di conversione; per una maggiore sicurezza è stato scelto un acceso di tipo private.

Per capire al meglio come opera un oggetto della classe, passiamo a descrivere il codice delle funzioni:

// implementazione classe
conversione::conversione()
{
p = new float [2];
p[0]=0; //fattore di conversione
p[1]=0; //risultato della conversione
}
conversione::~conversione()
{
delete[]p;
}
void conversione::fattore_conv(float fatt)
{
p[0]=fatt;
}
void conversione::calcola(float num)
{
p[1] = num / p[0];
}
void conversione::calcola2(float num)
{
p[1] = num * p[0];
}
float conversione::visual_ris()
{
return p[1];
}

In tal caso il costruttore definisce per ogni oggetto della classe un puntatore ad un vettore di dimensione 2, il quale viene allocato nello area di memoria heap. Al contrario, il distruttore dealloca il vettore dalla memoria all'atto di distruzione dell'oggetto stesso. Notiamo, inoltre, che le funzioni membro, come il distruttore e il costruttore, possono accedere direttamente al campo *p, che è privato e percio' invisibile all'esterno, ma accessibile a chi scrive il codice.

L'ultimo passo da compiere è la scrittura del main. In tal caso dobbiamo solo ricordare che per usare un oggetto precedentemente definito, bisogna scrivere il suo nome seguito dal "." e dall'operazione che deve eseguire. Data la sua semplicità si lascia all'utente il compito di scrivere il main.

Per il download del programma (comprensivo di main) clicca qui: convertitore.cpp