La possibilità di suddividere grossi programmi in porzioni il più possibile ridotte e autosufficienti (detti moduli) è una caratteristica che semplifica le operazioni di produzione e manutenzione del software. I programmi risultano più chiari e quindi più facili da mantenere ed aggiornare (specie se i programmatori che lavorano a un stesso progetto sono molti).

Un modulo è costituito da dati logicamente correlati e dalle procedure che li utilizzano. L'idea base è quella del "data hiding" (occultamento dei dati), in ragione della quale un programmatore "utente" del modulo non ha bisogno di conoscere l'effettiva implementazione delle funzioni offerte da un modulo con relativi tipi e variabili, ma gli basta sapere come sappia come utilizzarlo. Un modulo è pertanto paragonabile a un dispositivo (il cui meccanismo interno è a noi sconosciuto), con il quale possiamo comunicare attraverso particolari funzioni di input/output.
Tali operazioni sono a loro volta raggruppate in un elemento separato, detto interfaccia che rappresenta l'unico canale di comunicazione fra il modulo effettivo e i suoi "moduli clienti". La programmazione modulare offre così un duplice vantaggio:

• quello di separare l'interfaccia dal codice di implementazione del modulo, dando la possibilità al modulo di essere modificato senza che il codice del "modulo utente" ne sia influenzato;
• quello di permettere al "modulo utente" di definire i nomi delle variabili, dei tipi, delle funzioni ecc.. senza doversi preoccupare di eventuali conflitti con i nomi usati nel modulo e dell'insorgere di errori dovuti a simboli duplicati.

Dal punto di vista sintattico, la definizione di un namespace somiglia molto a quella di una struttura (cambia la parola-chiave e inoltre il punto e virgola in fondo non è obbligatorio). A differenza dalle strutture, il namespace non è un tipo (non può essere istanziato da oggetti) ma identifica semplicemente un ambito di visibilità (scope). Il programmatore è perciò libero di definire gli stessi nomi usati all'interno di un namespace anche al di fuori, senza pericolo di conflitti o ambiguità.

namespace [NomeNameSpace]
{
   tipo var1;
   . . .
   tipo varN;
   funzione membro1 { //implementazione della funzione }
   . . .
   funzione membroM { //implementazione della funzione }
};

Definire un namespace significa dichiarare/definire un gruppo di nomi a sua volta identificato da un nome. I membri di un namespace sono dichiarazioni o definizioni (con eventuali inizializzazioni) di identificatori di qualunque genere (variabili, funzioni, typedef, strutture, enumeratori, altri tipi astratti qualsiasi ecc...).

Namespace anonimi

Namespace annidati

void  f( );
namespace A
{
   void  g( );
   namespace B
   {
      void  h( );
   }
}

void A::B::h( ) {......} // definizione esterna della funzione h

Operatore binario di risoluzione di visibilità

NomeNameSpace::NomeMembro(...)

#include <stdio.h> 
namespace Stack
{
   const int max_size = 100;
   char v[max_size];
   int top = 0;
   void push(char c) { if (top < max_size) v[top++] = c; }
   char pop() { return ( top==0 ? '\0' : v[--top]); };
}
int main()
{
    char ch;
    printf("Inserisci una stringa: ");
    while ( ch=getchar(), ch != '\n' )
        Stack::push(ch);
    while ( ch = Stack::pop() ) 
        printf("%c",ch);
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

Definizioni esterne

E' auspicabile separare, dove è possibile, le dichiarazioni dalle definizioni (implementazione) ed includere solo le dichiarazioni fra i membri di un namespace, ponendo le seconde al di fuori. Nelle definizioni esterne però, i nomi devono essere qualificati, altrimenti non sarebbero riconoscibili.

namespace [NomeNameSpace]
{
   tipo var1;
   . . .
   tipo varN;
   funzione membro1(tipo11,...);
   . . .
   funzione membroM(tipo1m,...);
};
NomeNameSpace::membro1(tipo11 param11,...); { //implementazione della funzione }
   . . .
NomeNameSpace::membroM(tipo1m param1m,...); { //implementazione della funzione }

#include <stdio.h> 
namespace Stack
{
   const int max_size = 100;
   char v[max_size];
   int top = 0;
   void push(char);
   char pop();
}
void Stack::push(char c) { if (top < max_size) v[top++] = c; }
char Stack::pop() { return ( top==0 ? '\0' : v[--top]); }

int main()
{
    using namespace Stack;
    char ch;
    printf("Inserisci una stringa: ");
    while ( ch=getchar(), ch != '\n' )
        push(ch); // non uso :: per via dell'using
    while ( ch = pop() ) 
        printf("%c",ch);
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

Sinonimi di NameSpace

E' possibile definire un sinonimo "breve" per il nome "vero" "lungo" di un namespace. I sinonimi possono anche essere definiti localmente, a differrenza dei namespace. Per definire un sinonimo si usa la seguente sintassi:

NameSpace AliasNameSpace=NomeNameSpace;

#include <stdio.h> 
namespace Stack
{
   const int max_size = 100;
   char v[max_size];
   int top = 0;
   void push(char c) { if (top < max_size) v[top++] = c; }
   char pop() { return ( top==0 ? '\0' : v[--top]); };
}
int main()
{
    namespace Pila=Stack;
    char ch;
    printf("Inserisci una stringa: ");
    while ( ch=getchar(), ch != '\n' )
        Pila::push(ch);
    while ( ch = Pila::pop() ) 
        printf("%c",ch);
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

Estendibilità della definizione di un namespace

Al contrario delle strutture, i namespace sono costrutti "aperti", nel senso che possono essere definiti più volte con lo stesso nome. Non si tratta però di diverse definizioni, bensì di estensioni della definizione iniziale. E quindi, pur essendovi blocchi diversi di un namespace con lo stesso nome, l'ambito definito dal namespace con quel nome resta unico.
I membri complessivamente definiti in un namespace (anche se frammentato in più blocchi) devono essere tutti diversi (cioè nelle estensioni è consentito aggiungere nuovi membri ma non ridefinire membri definiti precedentemente). La possibilità di suddividere un namespace in blocchi separati consente, da un lato, di racchiudere grandi frammenti di programma in un unico namespace e, dall'altro, di presentare diverse interfacce a diverse categorie di utenti, mostrandone parti differenti. Vediamo un esempio:

#include <stdio.h> 
namespace Stack
{
   const int max_size = 100;
   char v[max_size];
   int top = 0;
   void push(char c) { if (top < max_size) v[top++] = c; }
   char pop() { return ( top==0 ? '\0' : v[--top]); };
}
namespace Stack
{
   // int top=1 questa istruzioni determina un errore di redifinizione
   void reset() { for (int i=0,top=0; i < max_size ; v[i++]='\0'); }
}
int main()
{
    char ch;
    Stack::reset();
    printf("Inserisci una stringa: ");
    while ( ch=getchar(), ch != '\n' )
        Stack::push(ch);
    while ( ch = Stack::pop() ) 
        printf("%c",ch);
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

using

Quando un membro di un namespace viene usato ripetutamente fuori dal suo ambito, esiste la possibilità, aggiungendo una sola istruzione, di evitare il fastidio di qualificarlo ogni volta. La parola chiave using serve a questo scopo e può essere usata in due modi diversi:

• con un'istruzione di "using-declaration" si rende accessibile un membro di un namespace nello stesso ambito in cui è inserita l'istruzione. Tornando all'esempio del namespace Stack, l'istruzione: using Stack::top; permette di accedere al membro top di Stack, senza bisogno di qualificarlo, in tutte le istruzioni che seguono all'interno dello stesso ambito. In sostanza, con la using-declaration, si introduce il sinonimo locale top di Stack::top . In una using-declaration va specificato solo il nome del membro interessato, per cui, in particolare, se il membro è una funzione, l'elenco degli argomenti non va indicato (e neppure le parentesi tonde); nel caso di più funzioni in overload con lo stesso nome, la using-declaration le rende accessibili tutte.
• con un'istruzione di "using-directive" si rendono accessibili tutti i membri di un namespace nello stesso ambito in cui è inserita l'istruzione. Tornando all'esempio, l'istruzione: using namespace Stack; permette di accedere a tutti i membri di Stack, senza bisogno di qualificarli, in tutte le istruzioni che seguono all'interno dello stesso ambito.

#include  
namespace Stack
{
   const int max_size = 100;
   char v[max_size];
   int top = 0;
   void push(char c) { if (top < max_size) v[top++] = c; }
   char pop() { return ( top==0 ? '\0' : v[--top]); };
}
void leggi()
{
    char ch;
    using Stack::push; // using declaration
    while ( ch=getchar(), ch != '\n' )
        push(ch);
}
int main()
{
    using namespace Stack; // using directive - block scope
    char ch;
    printf("Inserisci una stringa: ");
    leggi();
    while ( ch = pop() ) 
        printf("%c",ch);
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

Definizione delle Interfacce

In generale è consigliabile memorizzare in un file la dichiarazione della classe, in un altro file la definizione delle funzioni membro e in un altro file ancora il programma principale. Riprendiamo a questo proposito il nostro esempio iniziale del namespace Stack e mettiamoci "nei panni" sia del progettista del modulo che dell'utente che lo utilizza.

• Il progettista deve individuare con quale strumenti rappresentare la pila (per esempio con un array, ma ci potrebbero essere anche altre soluzioni), quali siano le informazioni da memorizzare e mantenere (l'indice corrispondente all'ultimo dato inserito e la massima dimensione di accrescimento della pila), quali algoritmi applicare per le operazioni di inserimento ed estrazione dei dati, e infine come dare all'utente la possibilità di operare.
   
• L'utente ha bisogno di conoscere solo due cose: il nome della funzione per inserire un dato (in) e il nome della funzione per estrarlo (out). E' quindi opportuno che acceda esclusivamente a tali informazioni (le dichiarazioni delle due funzioni), che costituiranno l'interfaccia comune fra il file sorgente del progettista e quello dell'utente

#include <stdio.h> 
#include "stack.h" 
using namespace Stack; // using directive - global scope
int main()
{
    char ch;
    printf("Inserisci una stringa: ");
    while ( ch=getchar(), ch != '\n' )
        push(ch);
    while ( ch = pop() ) 
        printf("%c",ch);
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

namespace Stack
{
   void push(char);
   char pop();
}

#include "stack.h"
namespace Stack
{
   const int max_size = 100;
   char v[max_size];
   int top = 0;
}
void Stack::push(char c) { if (top < max_size) v[top++] = c; }
char Stack::pop() { return ( top==0 ? '\0' : v[--top]); };

#include <;stdio.h> 
#include "stack.h" 
using namespace Stack; // using directive - global scope
int main()
{
    char ch;
    printf("Inserisci una stringa: ");
    while ( ch=getchar(), ch != '\n' )
        push(ch);
    while ( ch = pop() ) 
        printf("%c",ch);
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

namespace Stack
{
   void push(char);
   char pop();
}

namespace Stack
{
   const int max_size = 100;
   char v[max_size];
   int top = 0;
   void push(char c) { if (top < max_size) v[top++] = c; }
   char pop() { return ( top==0 ? '\0' : v[--top]); };
}

Link utili

Riprendiamo il concetto di strutture dati (struct). Le strutture sono insiemi (aggregati) di tipi di dati diversi che presentano alcuni limiti:

• Non esiste inizializzazione automatica dei membri. Pertanto la valorizzazione dei membri richiede un'esplicita inizializzazione.
• Non esiste un controllo automatico sui valori assegnati ai membri: è possibile che vengano assegnati valori fuori dagli intervalli concettualmente corretti (ad esempio un valore maggiore di 24 in un campo di tipo ora)
• Se si cambia l’implementazione della struttura (ad esempio si decide di utilizzare i secondi dopo la mezzanotte al posto della terna ore,minuti,secondi occorre cambiare qualcosa in tutte le parti del programma in cui si è utilizzata la struttura.
• Non si possono trattare le strutture come oggetti atomici per cui ad esempio il confronto tra due istanze (variabili) richiede un confronto membro per membro. Per lo stesso motivo non si può stampare una struttura con un'unica istruzione ma occorre stampare ogni membro separatamente.

• il nome della Classe;;
• la struttura dati (sequenza di variabili membro);
• i metodi della Classe (funzioni membro della classe).

class NomeClasse
{
public: // Membri e metodi pubblici
   tipo varPub1;
   . . .
   tipo varPubN;
   funzione membroPub1
   . . .
   funzione membroPubM

protected:
   tipo varPro1;
   . . .
   tipo varProH;
   funzione membroPro1;
   . . .
   funzione membroProK;

private:// Membri e metodi privati
   tipo varPri1;
   . . .
   tipo varPriS;
   funzione membroPri1;
   . . .
   funzione membroPriT;
};

#include <stdio.h>
class cContatore
{
    int val; // private per default
    public:
        void reset() { val=0; }
        void inc() { val++; }
        void dec() { val--; }
        void visualizza() { printf("%d\n",val); }
};
int main()
{
    cContatore x;
    x.reset();
    x.inc();
    x.inc();
    x.visualizza();
    x.dec();
    x.visualizza();
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

[inline] TipoRestituito NomeClasse::Funzione(tipo1 parametro1, ...)
{
   //implementazione della funzione
}

#include <stdio.h>
class cContatore
{
    int val; // è private per default
    public:
        // Funzioni di interfaccia
        void reset(); 
        void inc(); 
        void dec();
        void visualizza();
};
void cContatore::reset() { val=0; }
inline void cContatore::inc() { val++; }
inline void cContatore::dec() { val--; }
void cContatore::visualizza() { printf("%d\n",val); }
int main()
{
    cContatore x;
    x.reset();
    x.inc();
    x.inc();
    x.visualizza();
    x.dec();
    x.visualizza();
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

#include <stdio.h> // necessaria per fflush e getchar
#include "counter.h"
int main()
{
    cContatore x;
    x.reset();
    x.inc();
    x.inc();
    x.visualizza();
    x.dec();
    x.visualizza();
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

class cContatore
{
    int val; // è private per default
    public:
        // Funzioni di interfaccia
        void reset(); 
        void inc();
        void dec();
        void visualizza();
};

#include <stdio.h>
#include "counter.h"
void cContatore::reset() { val=0; }
void cContatore::inc() { val++; }
void cContatore::dec() { val--; }
void cContatore::visualizza() { printf("%d\n",val); }

• I metodi di una classe sono implementati mediante funzioni. Tale funzioni appartengono strettamente a quella classe e possono agire solo sui membri di quella classe o su quelle da essa derivate.
• Gli attributi e i metodi (funzioni membro) possono essere dichiarate come:
  • private (predefinito): risultano accessibili solo ai metodi appartenenti alla stessa classe.
  • protected: sono accessibili alle funzioni membro appartenenti alla stessa classe e quelle classi da questa derivate.
  • public: sono accessibili da ogni parte del programma entro il campo di visibilita della classe in esame.
• Overloading delle funzioni: è possibile definire più funzioni/subroutine aventi lo stesso nome, ma con un diverso set di argomenti, ed eventualmente un diverso valore di ritorno
• Incapsulamento: tecnica con la quale si nasconde il funzionamento interno dei metodi di una classe. E' sinonimo di Information Hiding. Per via dell'incapsulamento i dati che definiscono lo stato interno di un oggetto sono accessibili solo ai metodi dell'oggetto stesso ma risultano nascosti ai "moduli client". Per alterare lo stato interno dell'oggetto, è necessario invocare i metodi disponibili. Se gestito opportunamente l'incapsulamento permette di vedere l'oggetto come una black-box, cioè una "scatola nera" di cui, attraverso l'interfaccia, è noto cosa fa, ma non come lo fa.
• Ereditarietà: E’ la possibilità per un oggetto di acquisire le caratteristiche (attributi e metodi) di un altro oggetto.
• Polimorfismo: Il polimorfismo per inclusione permette al programma di fare uso di oggetti che espongono una stessa interfaccia, ma implementazioni diverse. Consente di utilizzare uno stesso identificatore per definire dati (attributi) o operazioni (funzioni membro) diverse (ad esempio: considerando la classe Animale l'azione/metodo spostarsi assume forme diverse a seconda dell'ambiente in cui vivono).  L'overriding dei metodi o delle proprietà permette che gli oggetti appartenenti a sottoclassi di una stessa classe rispondano diversamente agli stessi utilizzi. Ad esempio: supponiamo di avere una gerarchia in cui le classi Cane e Gatto discendono dalla superclasse Animale. Quest'ultima definisce un metodo cosaMangia(), le cui specifiche sono: "Restituisce il nome dell'alimento tipico dell'animale". I due metodi cosaMangia() definiti nelle classi Cane e Gatto si sostituiscono a quello ereditato da Animale e, rispettivamente, restituiscono "osso" e "pesce". In particolare é utile che funzioni che svolgono la stessa azione abbiano lo stesso nome. Non confondiamo l'overload, che implica funzioni con lo stesso nome, ma con diverse liste di argomenti con il polimorfismo che invece implica chei metodi di classi diverse abbiano lo stesso nome e gli stessi argomenti L'attitudine del linguaggio di rispondere in modo diverso allo stesso "messaggio" si chiama appunto "polimorfismo".
  

Specificatori di accesso

In C++, quando definisco una classe, utilizzo gli specificatori di accesso ed esattamente:

- private:
- protected:
- public:

Questi specificatori possono essere inseriti più volte all'interno della definizione di una classe. Tutti i membri dichiarati da quel punto in poi (fino al termine della definizione della classe o fino ad un nuovo specificatore) acquisiscano la connotazione di membri privati,protetti o publici a seconda.
Private: e protected: hanno un significato analogo: la loro differenza riguarda esclusivamente le classi ereditate
Il "data hiding" (occultamento dei dati) consiste nel rendere certe aree del programma invisibili ad altre aree del programma. Mentre l'istanza di una classe (variabile di tipo classe) é regolarmente visibile all'interno del proprio ambito di visibilità i suoi membri dichiarati come private non lo sono: non é possibile, da parte del "modulo cliente" (programma che usa la classe), accedere direttamente ai membri privati di una classe. Esempio:

class Persona
{
	int stipendio ; //private è lo specificatore di default
	public:
		char telefono[20] ;
		char indirizzo[30] ;
} ;
Persona Giuseppe; // istanza della classe Persona 

Specificatori const: funzioni membro a sola lettura

class point
{
   double x;
   double y;
public:
   void set(double, double ) ;
};
void point::get(double& x0, double& y0) const
{
   x0 = x ;
   y0 = y ;
}

Classi Annidate

Una classe può anche essere definita all'interno di un'altra classe (oppure semplicemente dichiarata, e poi definita esternamente: in questo caso però il suo nome deve essere qualificato con il nome della classe di appartenenza). La classe ospitante un'altra classe si dice composta.
Esempio di definizione di un metodo f di una classe B, definita all'interno di un'altra classe A:

   void A::B::f( ) {......}

#include <stdio.h>
class segmento
{
    private:
        class point
        {
           private:
                double x, y;
                void get(double *, double *) const;
           public:
                void set(double, double );
                void show();
        };
    public:
        point A,B;
        void set(double,double,double,double);
        void show();
};
// Implementazioni funzioni-membro classe segmento
void segmento::set(double x1,double y1,double x2,double y2)
{
     A.set(x1,y1);
     B.set(x2,y2);
}
void segmento::show()
{
     printf("A=");
     A.show();
     printf(" -> B=");
     B.show();
}
// Implementazioni funzioni-membro classe annidata point
void segmento::point::get(double *_x, double *_y) const
{
    *_x = x ;
    *_y = y ;
}
void segmento::point::set(double _x, double _y)
{
    x = _x ;
    y = _y ;
}
void segmento::point::show()
{
    double a,b;
    get(&a,&b); // potevo scrivere this->get(&a,&b);
    printf("(%.2f,%.2f)",a,b);
}

int main()
{
    segmento s;
    // questa dichiarazione da un errore in complilazione poichè 
    // point è private (visibile solo nella classe segmento);
    // point p;
    s.set(1.01,2.02,3.03,4.04);
    // Essendo public i metodi set e show di point possono essere usati
    // s.B.set(5.05,6.06);
    // s.B.show();
    // mentre s.B.get(&a,&b); no!
    s.show();
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

Puntatore nascosto this

Come fa il programma a sapere, in esecuzione, su quale oggetto applicare una funzione-membro ?
In realtà il compilatore trasforma la definizione della funzione-membro inserendo il puntatore nascosto this come primo argomento nella funzione. Ogni volta che incontra la chiamata di una funzione-membro invece inserisce il puntatore all'istanza come primo argomento nella funzione. Per le funzione-membro a sola lettura, il compilatore trasforma la sua definizione im modo che this diventi un puntatore costante a costante. Vediamo un esempio:

void myclass::init()
{
	.....
	x = 
	.....
}
int myclass::get() const  { ..... }
ogg.init( ) ;

void init(myclass* const this)
{
	.....
	this->x = 
	.....
}
int get(const myclass* const this) { ..... }
init(&ogg) ;

Costruzione e distruzione di un oggetto

Vediamo le varie circostanze in cui un oggetto può essere costruito o distrutto:

1. Un oggetto locale non statico viene costruito ogni volta che la sua definizione viene incontrata durante l'esecuzione del programma. Viene distrutto ogni volta che il programma esce dall'ambito in cui tale definizione si trova (esempio quando termina la funzione in cui tale oggetto è stato definito).
2. Un oggetto locale statico viene costruito la prima volta che la sua definizione viene incontrata durante l'esecuzione del programma, e distrutto una sola volta, quando il programma termina.
3. Un oggetto allocato nella memoria dinamica (area heap) viene costruito mediante l'operatore new e distrutto mediante l'operatore delete.
4. Un oggetto, membro non statico di una classe, viene costruito ogni volta che (o meglio, immediatamente prima che) venga costruito l'oggetto della classe di cui è membro e distrutto ogni volta che (o meglio, immediatamente dopo che) lo stesso oggetto viene distrutto.
5. Un oggetto, elemento di un array, viene costruito o distrutto ogni volta che l'array di cui fa parte viene costruito o distrutto.
6. Un oggetto globale, un oggetto di un namespace o un membro statico di una classe, viene costruito una sola volta, alla "partenza" del programma e distrutto quando il programma termina.
7. Infine, un oggetto temporaneo viene costruito per memorizzare risultati parziali durante la valutazione di un'espressione, e distrutto alla fine dell'espressione completa in cui compare. Un oggetto temporaneo viene costruito per memorizzare risultati parziali durante la valutazione di un'espressione, e distrutto alla fine dell'espressione completa.
   Per esempio, è possibile ridefinire l'operatore di somma (+) in modo che accetti fra i suoi operandi anche oggetti della classe classe point

   point p = p1 + p2;

   dove p1 e p2 sono istanze già create della stessa classe. In questo caso è costruito l'oggetto temporaneo p1 + p2, che viene distrutto dopo che l'istruzione è stata eseguita.

Costruttori

I costruttori degli oggetti devono sottostare alle seguenti regole:

• devono avere lo stesso nome della classe
  
• non bisogna specificare il tipo di ritorno (neanche void)
  
• ammettono argomenti e valori di defaults; i costruttori senza argomenti (o con tutti gli argomenti con valori di default) sono detti: "costruttori di default". Un esempio di costruttore con un argomento required e l'altro di default è il seguente: point(double x, double y=0);
  
• possono esistere più costruttori, in overloading, in una stessa classe. Il C++ li distingue in base alla lista degli argomenti. Come tutte le funzioni in overload, non sono ammessi costruttori che differiscano negli argomenti solo le valorizzazioni di default.
  
• devono essere sempre dichiarati nella sezione public, in quanto sono sempre chiamati dall'esterno della classe a cui appartengono.
  

class NomeClasse
{
....
public:
   NomeClasse(); // Costruttore di default
   NomeClasse(ListaTipiArgomenti);
....
};
NomeClasse::NomeClasse() { .... } // implementazione costruttore default
NomeClasse::NomeClasse(ListaArgomenti) { .... }

    point *pP, *pPa;
    pP=new point(3);
    pPa=new point[5];
    pP->show();
    delete [] pPa; // deallocazione per un array
    delete pP;

point::point(double x0=0, double y0=0) { x=x0 ; y=y0 ;} // nell'esempio ho dei valori di default
point p(3.5, 2.1);
point p=point(3.5, 2.1);

La prima forma è più concisa, ma la seconda è più chiara, in quanto ha proprio l'aspetto di una inizializzazione tramite chiamata esplicita di una funzione.
Anche i tipi nativi hanno i loro costruttori di default, che però, quando servono, vanno esplicitamente chiamati (esempio int i = int();). I costruttori di default dei tipi nativi inizializzano le variabili con zero (in modo appropriato al tipo). Sono utili quando si ha a che fare con tipi parametrizzati (come nei template), in cui non è noto a priori se al parametro verrà sostituito un tipo nativo o un tipo astratto.

CONVERSIONE IMPLICITA

Un'attenzione particolare merita il costruttore con un solo argomento. In questo caso, infatti, il costruttore definisce anche una conversione implicita di tipo dal tipo dell'argomento a quello della classe. Esempio

point::point(double x0) { x=x0;}
point p = point(3);
// Equivale a:
point p=3;

#include <stdio.h>
// -----------------------------------------------
// Classe senza costruttore
class pointNC
{
    public:
        double x;
        void show();
};
void pointNC::show() { printf("[%.2f]\n",x); }
// -----------------------------------------------
// Classe senza costruttore di default
class pointNDC
{
   public:
        double x;
        explicit pointNDC(double);
        void show();
};
pointNDC::pointNDC(double d) { x=d; }
void pointNDC::show() { printf("[%.2f]\n",x); }
// -----------------------------------------------
// Classe con costruttore di default
class point
{
   public:
        double x;
        point();
        point(double);
        void show();
};
point::point() { x=-10; }
point::point(double d) { x=d; }
void point::show() { printf("[%.2f]\n",x); }
// -----------------------------------------------
int main()
{
    // -----------------------------------------------
    // Esempio senza costruttore
    // -----------------------------------------------
    pointNC p;
    p.x=1; // devo valorizzarlo altrimenti l'output è imprevedibile
    p.show();
    // -----------------------------------------------
    // Esempio senza costruttore di default
    // -----------------------------------------------
    pointNDC q(2);
    // - potevo scrivere anche in questo modo:
    // pointNDC q=pointNDC(2);
    // - Non posso dichiarare q nel seguente modo  
    //   poichè manca il costruttore di default
    // pointNDC q;
    // - Non posso dichiarare q nel seguente modo 
    //   poichè a fianco del costruttore ho explicit
    // pointNDC q=2;
    // - ma potevo usare il casting:
    // pointNDC q=(pointNDC)2;
    q.show();
    // -----------------------------------------------
    // Esempio con costruttore di default
    // -----------------------------------------------
    point r;
    r.x=3;
    // - La dichiarazione seguente (equivalente) non genera un errore 
    //   poichè non ho la parola explicit a fianco del costruttore
    // point r=3;
    // - oppure potevo scrivere:
    // point r=point(3);
    // point r(3);
    r.show();
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

Distruttori

I distruttori degli oggetti devono sottostare alle seguenti regole

• devono avere lo stesso nome della classe preceduto da una tilde (~);
  
• non bisogna specificare il tipo di ritorno (neanche void)
  
• non ammettono argomenti
  
• ciascuna classe può avere al massimo un distruttore
  
• devono essere dichiarati come funzioni-membro pubbliche, in quanto sono sempre chiamati dall'esterno della classe a cui appartengono.
  
  

class NomeClasse
{
....
public:
   ~NomeClasse(); // Distruttore
....
};
NomeClasse::~NomeClasse() { .... } // implementazione distruttore

class Persona 
{ 	
        char *nome;
        char *cognome;
    public:
        Persona::Persona(int); 	
        Persona::~Persona();
};
Persona::Persona(int n=20)
{
    nome = new char [n];
    cognome = new char [n];
}
Persona::~Persona()
{
    delete [] nome;
    delete [] cognome;
}

Costruttori di copia

I costruttori di copia sono particolari costruttori che vengono eseguiti quando un oggetto é creato per copia. Ricordiamo brevemente in quali casi ciò si verifica:
 
- definizione di un oggetto e sua inizializzazione tramite un oggetto esistente dello stesso tipo;
- passaggio by value di un argomento a una funzione;
- restituzione by value del valore di ritorno di una funzione;
- passaggio di un'eccezione al costrutto catch.

Un costruttore di copia deve avere un solo argomento, dello stesso tipo dell'oggetto da costruire; l'argomento (che rappresenta l'oggetto esistente) deve essere dichiarato const (per sicurezza) e passato by reference (altrimenti si creerebbe una copia della copia!).
Il costruttore di copia della classe verrà chiamato automaticamente ogni volta che si verifica una delle quattro circostanze sopraelencate (esempio NomeClasse IstanzaNew=IstanzaOld). questa istruzione aziona il costruttore di copia, a cui é trasmesso IstanzaOld come argomento (byRef).

class NomeClasse
{
....
public:
   NomeClasse(const NomeClasse&); // Costruttore di copia
....
};
NomeClasse::NomeClasse(const NomeClasse *A) { .... } // implementazione costruttore di copia

#include <stdio.h>
class point
{
      double x,y;
    public:
        point();
        point(double, double);
        void show();
};
point::point() { x=0; y=0; }
point::point(double a, double b) { x=a; y=b; }
void point::show() { printf("(%.2f,%.2f)\n",x,y); }
int main()
{
    point p(3,4);
    point q=p; // Qui il costruttore di copia non serve.
    q.show();
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

#include <stdio.h>
class point
{
    double *x,*y;
    public:
        point();
        point(double, double);
        ~point();
        void azzera();
        void show();
};
point::point() { x=new double; y=new double; *x=0; *y=0; }
point::point(double a, double b) {  x=new double; y=new double; *x=a; *y=b; }
point::~point(){ delete x, delete y; }
void point::azzera(){ *x=0 ; *y=0 ; delete x, delete y; }
void point::show() { printf("(%.2f,%.2f)\n",*x,*y); }

int main()
{
    point p(3,4);
    point q=p;
    p.azzera(); // libero l'area di memoria
    q.show();   // stampa 0,0 invece di 3,4 
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

#include 
class point
{
      double *x,*y;
    public:
        point();
        point(double, double);
        point(const point&);
        ~point();
        void show();
        void azzera();
};
point::point() { x=new double; y=new double; *x=0; *y=0; }
point::point(double a, double b) { x=new double; y=new double; *x=a; *y=b; }
point::~point(){ delete x, delete y; }
point::point(const point& a)
{
    x=new double; y=new double; 
    *x=*(a.x); *y=*(a.y);
}
void point::show() { printf("(%.2f,%.2f)\n",*x,*y); }
void point::azzera(){ *x=0 ; *y=0 ; delete x, delete y; }

int main()
{
    point p(3,4);
    point q=p;
    p.azzera();
    q.show(); // stampa correttamente (3,4)
    // metto in stop il programma prima della sua chiusura
    fflush(stdin);
    getchar();
    return 0;
}

point::point(const point *a)
{
    x=new double; y=new double; 
    *x=*(a->x); *y=*(a->y);
}
...
point q=point(&p);

Liste di inizializzazione

Quando un costruttore deve, fra l'altro, inizializzare i membri della propria classe, lo può fare tramite una lista di inizializzazione (introdotta dal segno ":" e inserita nella definizione del costruttore dopo la lista degli argomenti). Quindi il costruttore:

point::point(double a, double b) { x=a; y=b; }

point::point(double a, double b): y(b),x(a) {};

Inizializzazione array

Gli elementi di un array di oggetti (caso 5. dell'elenco iniziale) vengono inizializzati, tramite il costruttore della classe comune di appartenenza, non appena l'array è definito. Con questa istruzione viene utilizzato il costruttore di default:

point pt[5];

int valori[] = {32, 53, 28, 85, 21};

point pt[] = {2.3, -1.2, 0.0, 1.4, 0.5};

point pt[] = {p0, p1, p2, p3, p4};

Link utili

Il linguaggio C non contiene alcuna istruzione di Input/Output. Tali operazioni vengono svolte mediante chiamate a funzioni definite nella libreria standard contenute nel file stdio.h. Tali funzioni rendono possibile la lettura/scrittura in modo indipendente dalle caratteristiche proprie dei dispositivi di Input/Output. Le stesse funzioni possono essere utilizzate, ad esempio, sia per leggere un valore dalla tastiera sia per leggere un valore da un dispositivo di memoria di massa. Lo stesso vale per le funzioni di scrittura: le stesse operazioni possono essere utilizzate sia per la visualizzazione sullo schermo sia per scrivere un valore su un disco o una stampante. Ciò è possibile poichè il sistema di I/O C è caratterizzato da un’interfaccia indipendente dal dispositivo effettivo che si interpone tra il programmatore e il dispositivo. Tale interfaccia è chiamata flusso, mentre il dispositivo effettivo è chiamato file.

Il sistema di I/O C associa ad ogni dispositivo fisico un dispositivo logico chiamato flusso. Poichè tutti i flussi si comportano alla stessa maniera, possono essere utilizzate le stesse funzioni per la loro gestione. Esistono due tipi di flussi: flussi binari e di testo.
Un flusso binario è formato da una sequenza di byte con una corrispondenza uno ad uno con i byte presenti sul dispositivo fisico.
Un flusso di testo è una sequenza di caratteri generalmente suddivisa in linee terminate da un carattere di newline.

Un File è un qualsiasi dispositivo, da un disco a un monitor a una stampante. Per associare un flusso a un file è necessario un’operazione di apertura.
Una volta aperto un file sarà possibile scambiare informazioni tra il file e il programma. Per eliminare l’associazione tra flusso e file è necessaria un’operazione di chiusura.
Nel caso un file aperto in scrittura, l’eventuale contenuto del flusso viene scritto sul dispositivo fisico.

Ogni flusso ha associato una struttura chiamata FILE contenente i seguenti campi:

- Modalità di utilizzo del file (lettura, scrittura o lettura e scrittura);
- Posizione corrente su file (indicante il prossimo byte da leggere o scrivere su file);
- Un indicatore di errore di lettura/scrittura;
- Un indicatore di end-of-file, indicante il raggiungimento della fine del file.

Ogni operazione di apertura a file restituisce un puntatore a una variabile di tipo FILE. Per potere leggere o scrivere i file è necessario usare delle variabili di tipo puntatore a FILE, dichiarate nel seguente modo:

FILE *fp;

L’apertura di un file viene realizzata mediante la funzione fopen() avente il seguente prototipo:

FILE * fopen ( const char * nomefile, const char * mode );

dove nomefile è una stringa di caratteri indicante il nome del file da aprire e mode è la modalità che indica il modo in cui il file deve essere aperto. Il parametro mode assume i seguenti valori:

Modalità file testuali
mode	significato
r	Apre un file di testo in lettura
w	Crea un file di testo in scrittura
a	Apre un file di testo in modalità append
r+	Apre un file di testo in lettura/scrittura
w+	Crea un file di testo in lettura/scrittura
a+	Crea o apre un file di testo in modalità append per lettura/scrittura

Modalità file binari
mode	significato
rb	Apre un file binario in lettura
wb	Crea un file di binario in scrittura
ab	Apre un file di binario in modalità append
r+b	Apre un file di binario in lettura/scrittura
w+b	Crea un file di binario in lettura/scrittura
a+b	Crea o apre un file di binario in modalità append per lettura/scrittura

Se si verifica un errore in apertura del file, la fopen() restituisce un puntatore nullo.

La chiusura di un file viene realizzata mediante la funzione fclose avente il seguente prototipo:

int fclose ( FILE *fp );

dove fp è il puntatore restituito dalla fopen().

La funzione feof() restituisce un valore logico vero nel caso in cui è raggiunta la fine del file e zero in tutti gli altri casi. Il prototipo della feof è il seguente:

int feof ( FILE *fp );

dove fp è il puntatore restituito dalla fopen().

La funzione fprintf() è utilizzata per la scrittura su file testuali. Il suo comportamento è lo stesso della funzione printf(). Il suo prototipo è il seguente:

int fprintf ( FILE *fp, const char *formato, ... );

dove fp è il puntatore restituito dalla fopen(). La funzione restituisce il numero di caratteri scritti. Se si verifica un errore di scrittura la funzione restituisce un numero negativo corrispondente all'errore che viene rilevato con la funzione ferror().

La funzione fscanf() è utilizzata per la lettura di file testuali. Il suo comportamento è lo stesso della funzione scanf(). Il suo prototipo è il seguente:

int fscanf ( FILE *fp, const char *formato, ... );

dove fp è il puntatore restituito dalla fopen(). In caso di successo la funzione restituisce il numero di elementi della lista degli argomenti che sono stati correttamente letti. Questo conteggio potrebbe essere inferiore a causa di: - una non corrispondenza dei parametri rispetto alla maschera indicata in formato.

- un errore di lettura
- il raggiungimento della fine del file

Quando arrivo in fondo al file feof() ritorna true.

Link utili