struct Complex {
    float Re;
    float Im;
  };

  Complex operator+(const Complex& A, const Complex& B) {
    Complex Result;
    Result.Re = A.Re + B.Re;
    Result.Im = A.Im + B.Im;
    return Result;
  }

Si tratta sicuramente di un caso molto semplice, che fa capire che in fondo un operatore altro non e` che una funzione. Il funzionamento del codice e` chiaro e non mi dilunghero` oltre; si noti solo che i parametri sono passati per riferimento, non e` obligatorio, ma solitamente e` bene passare i parametri in questo modo (eventualmente utilizzando const come nell'esempio).
Definito l'operatore, e` possibile utilizzarlo secondo l'usuale sintassi riservata agli operatori, ovvero come nel seguente esempio:

  Complex A, B;
  /* ... */
  Complex C = A + B;

L'esempio richiede che sia definito su Complex il costruttore di copia, ma come gia` sapete il compilatore e` in grado di fornirne uno di default. Detto questo il precedente esempio viene tradotto (dal compilatore) in

  Complex A, B;
  /* ... */
  Complex C(operator+(A, B));

Volendo potete utilizzare gli operatori come funzioni, esattamente come li traduce il compilatore (cioe` scrivendo Complex C = operator+(A, B) o Complex C(operator+(A, B))), ma non e` una buona pratica in quanto annulla il vantaggio ottenuto ridefinendo l'operatore.
Quando un operatore viene ridefinito come funzione membro il primo parametro e` sempre l'istanza della classe su cui viene eseguito e non bisogna indicarlo nella lista di argomenti, un operatore binario quindi come funzione globale riceve due parametri ma come funzione membro ne riceve solo uno (il secondo operando); analogamente un operatore unario come funzione globale prende un solo argomento, ma come funzione membro ha la lista di argomenti vuota.
Riprendiamo il nostro esempio di prima ampliandolo con nuovi operatori:

  class Complex {
    public:
      Complex(float re, float im);
      Complex operator-() const;    // - unario
      Complex operator+(const Complex& B) const;
      const Complex & operator=(const Complex& B);

    private:
      float Re;
      float Im;
  };

  Complex::Complex(float re, float im = 0.0) {
    Re = re;
    Im = im;
  }

  Complex Complex::operator-() const {
    return Complex(-Re, -Im);
  }

  Complex Complex::operator+(const Complex& B) const {
    return Complex(Re+B.Re, Im+B.Im);
  }

  const Complex& Complex::operator=(const Complex& B) {
    Re = B.Re;
    Im = B.Im;
    return B;
  }

La classe Complex ridefinisce tre operatori. Il primo e` il -(meno) unario, il compilatore capisce che si tratta del meno unario dalla lista di argomenti vuota, il meno binario invece, come funzione membro, deve avere un parametro. Successivamente viene ridefinito l'operatore + (somma), si noti la differenza rispetto alla versione globale. Infine viene ridefinito l'operatore di assegnamento che come detto sopra deve essere una funzione membro non statica; si noti che a differenza dei primi due questo operatore ritorna un riferimento, in tal modo possiamo concatenare piu` assegnamenti evitando la creazione di inutili temporanei, l'uso di const assicura che il risultato non venga utilizzato per modificare l'oggetto. Infine, altra osservazione, l'ultimo operatore non e` dichiarato const in quanto modifica l'oggetto su cui e` applicato (quello cui si assegna), se la semantica che volete attribuirgli consente di dichiararlo const fatelo, ma nel caso dell'operatore di assegnamento (e in generale di tutti) e` consigliabile mantenere la coerenza semantica (cioe` ridefinirlo sempre come operatore di assegnamento, e non ad esempio come operatore di uguaglianza).
Ecco alcuni esempi di applicazione dei precedenti operatori e la loro rispettiva traduzione in chiamate di funzioni (A, B e C sono variabili di tipo Complex):

  B = -A;       // B.operator=(A.operator-());
  C = A+B;      // C.operator=(A.operator+(B));
  C = A+(-B);   // C.operator=(A.operator+(B.operator-()))
  C = A-B;      // errore!
                // complex& Complex::operator-(Complex&)
                // non definito.

L'ultimo esempio e` errato poiche` quello che si vuole utilizzare e` il meno binario, e tale operatore non e` stato definito.
Passiamo ora ad esaminare con maggiore dettaglio alcuni operatori che solitamente svolgono ruoli piu` difficili da capire.



L'operatore di assegnamento

L'assegnamento e` un operatore molto particolare, la sua semantica classica e` quella di modificare il valore dell'oggetto cui e` applicato con quello ricevuto come parametro e restituire poi tale valore al fine di consentire espressioni del tipo

  A = B = C = < Valore >

che e` equivalente a

  A = (B = (C = < Valore >));

Non lo si confonda con il costruttore di copia: il costruttore e` utilizzato per costruire un nuovo oggetto inizializzandolo con il valore di un altro, l'assegnamento viene utilizzato su oggetti gia` costruiti.

  Complex C = B;      // Costruttore di copia
  /* ... */
  C = D;              // Assegnamento

Un'altra particolarita` di questo operatore lo rende simile al costruttore (oltre al fatto che deve essere una funzione membro): se in una classe non ne viene definito uno nella forma X::operator=(X&), il compilatore ne fornisce uno che esegue la copia bit a bit. Lo standard stabilisce che sia il costruttore di copia che l'operatore di assegnamento forniti dal compilatore debbano eseguire non una copia bit a bit, ma una inizializzazione o assegnamento a livello di membri chiamando il costruttore di copia o l'operatore di assegnamento relativi al tipo di quel membro. In ogni caso comunque e necessario definire esplicitamente sia l'operatore di assegnamento che il costruttore di copia ogni qual volta la classe contenga puntatori, onde evitare spiacevoli condivisioni di memoria.
Notate infine che, come per le funzioni, anche per un operatore e` possibile avere piu` versioni overloaded; in particolare una classe puo` dichiarare piu` operatori di assegnamento, ma e` quello di cui sopra che il compilatore fornisce quando manca.



L'operatore di sottoscrizione

Un altro operatore un po' particolare e` quello di sottoscrizione [ ]. Si tratta di un operatore binario il cui primo operando e` l'argomento che appare a sinistra di [, mentre il secondo e` quello che si trova tra le parentesi quadre. La semantica classica associata a questo operatore prevede che il primo argomento sia un puntatore, mentre il secondo argomento deve essere un intero senza segno. Il risultato dell'espressione Arg1[Arg2] e` dato da *(Arg1+Arg2) cioe` il valore contenuto all'indirizzo Arg1+Arg2. Questo operatore puo` essere ridefinito unicamente come funzione membro non statica e ovviamente non e` tenuto a sottostare al significato classico dell'operatore fornito dal linguaggio. Il problema principale che si riscontra nella definizione di questo operatore e` fare in modo che sia possibile utilizzare indici multipli, ovvero poter scrivere Arg1[Arg2][Arg3]; il trucco per riuscire in cio` consiste semplicemente nel restituire un riferimento al tipo di Arg1, ovvero seguire il seguente prototipo:

  X& X::operator[](T Arg2);

dove T puo` essere anche un riferimento o un puntatore.
Restituendo un riferimento l'espressione Arg1[Arg2][Arg3] viene tradotta in Arg1.operator[](Arg2).operator[](Arg3).
Il seguente codice mostra un esempio di overloading di questo operatore:

  class TArray {
    public:
      TArray(unsigned int Size);
      ~TArray();
      int operator[](unsigned int Index);

    private:
      int* Array;
      unsigned int ArraySize;
  };

  TArray::TArray(unsigned int Size) {
    ArraySize = Size;
    Array = new int[Size];
  }

  TArray::~TArray() {
    delete[] Array;
  }

  int TArray::operator[](unsigned int Index) {
    if (Index < Size) return Array[Index];
    else /* Errore */
  }

Si tratta di una classe che incapsula il concetto di array per effettuare dei controlli sull'indice, evitando cosi` accessi fuori limite. La gestione della situazione di errore e` stata appositamente omessa, vedremo meglio come gestire queste situazioni quando parleremo di eccezioni.
Notate che l'operatore di sottoscrizione restituisce un int e non e` pertanto possibile usare indicizzazioni multiple, d'altronde la classe e` stata concepita unicamente per realizzare array monodimensionali di interi; una soluzione migliore, piu` flessibile e generale avrebbe richiesto l'uso dei template che saranno argomento del successivo capitolo.



Pagina precedente - Pagina successiva