Pattern Singleton e Class Replacement

In uno scorso articolo avevamo introdotto il concetto di pattern nell’ambito della programmazione ed avevamo fatto un esempio concreto con “Iterator“, questa volta continuiamo definendone altri due, “Singleton” e “Class Replacement“. Come avevamo visto la volta scorsa non esistono dei vincoli molto rigidi riguardo al formato della descrizione di un pattern, quindi anche in questo caso utilizzeremo quella vista in precedenza.
I pattern che ormai sono considerati dei veri e propri classici nella programmazione object-oriented e si possono classificare in tre grandi categorie:

• Creazionali – in questo gruppo troviamo Singleton e servono per descrivere vari metodi per creare oggetti, uno dei più noti in questa categoria è Abstract Factory.
• Strutturali – in questa categoria vengono inseriti tutti i pattern che descrivono vari tipi di relazioni tra classi ed oggetti, come Facade e Proxy.
• Comportamentali – in questo gruppo troviamo tutti quelli  legati agli algoritmi ed al controllo del flusso come Iterator, Chain of Responsability, Command e Observer.

Veniamo quindi alla strutturazione del pattern Singleton:

• Nome: Singleton
• Categoria: progettazione software
• Descrizione: esistono molti casi in cui una classe deve essere condivisa da tutti gli oggetti dell’applicazione, come ad esempio la finestra principale di un programma.
• Applicabilità: può essere utilizzato in tutti quei casi in cui non ha senso che esistano più istanze della stessa classe e sfruttare alcune proprietà della programmazione, come ad esempio estendere la classe derivandola in sottoclassi.
• Soluzione: si deve creare una classe con il metodo getInstance che consenta di accedere alla sua unica istanza, che potrà essere creata all’avvio dell’applicazione, oppure la prima volta che tale metodo verrà richiamato.

Ecco un esempio di utilizzo:

class Singleton {
private:
   static pWnd* m_pWnd;
protected:
   Singleton();
public:
   static pWnd* getInstance();
   long f1();
   int f2();
}

Singleton::Singleton() {}
Singleton* Singleton::getInstance()
{
   if (!m_pWnd)
      m_pWnd = CreateWindow(….);
  return m_pWnd;
}

Questo è un esempio di come implementare la finestra principale di un’applicazione. Il prossimo pattern che prenderemo in esame è il Class Replacement, ecco la sua struttura:

• Nome: Class Replacement
• Categoria: progettazione software
• Descrizione: sostituire una classe con un’altra senza modificare il codice del programma. Un esempio potrebbe essere quello della necessità di avere due o più interfacce disponibili per un’applicazione e poter cambiare colori e modello quando si vuole senza modificare il codice; questo si verifica se si inseriscono dei dati in un file esterno al software, ad esempio in un file di configurazione.
• Applicabilità: può essere implementato solo utilizzando un linguaggio che consenta di creare una classe a partire dal suo nome, come Java o Visual Basic; si devono utilizzare classi non tipizzate e questi due linguaggi di programmazione ed altri lo permettono.
• Soluzione: occorre creare una class factory con un metodo create, il nome potrà essere reperito tramite la factory all’esterno dell’applicazione, ad esempio nel registro di sistema.

Un pattern simile a quest’ultimo è Abstract Factory che però non considera il caso in cui il nome della classe debba essere specificato esternamente all’applicazione.
Ho voluto scrivere un altro articolo sui pattern, perché li ritengo molto importanti per l’omogeineità di sviluppo che si deve avere nel mondo della programmazione e questa volta ho voluto più che altro inserire due casi pratici molto importanti.