C++ Operatori unari


Esempio

Puoi sovraccaricare i 2 operatori unari:

  • ++foo e foo++
  • --foo e foo--

Il sovraccarico è uguale per entrambi i tipi ( ++ e -- ). Scorri verso il basso per la spiegazione

Sovraccarico al di fuori della class / struct :

//Prefix operator ++foo
T& operator++(T& lhs)
{
    //Perform addition
    return lhs;
}

//Postfix operator foo++ (int argument is used to separate pre- and postfix) 
//Should be implemented in terms of ++foo (prefix operator)
T operator++(T& lhs, int)
{
    T t(lhs);
    ++lhs;
    return t;
}

Sovraccarico all'interno di class / struct :

//Prefix operator ++foo
T& operator++()
{
    //Perform addition
    return *this;
}

//Postfix operator foo++ (int argument is used to separate pre- and postfix) 
//Should be implemented in terms of ++foo (prefix operator)
T operator++(int)
{
    T t(*this);
    ++(*this);
    return t;
}

Nota: l'operatore del prefisso restituisce un riferimento a se stesso, in modo da poter continuare le operazioni su di esso. Il primo argomento è un riferimento, poiché l'operatore del prefisso modifica l'oggetto, che è anche il motivo per cui non è const (non sarebbe possibile modificarlo in altro modo).


L'operatore postfisso restituisce di valore un valore temporaneo (il valore precedente) e quindi non può essere un riferimento, in quanto sarebbe un riferimento a un valore temporaneo, che sarebbe un valore immondizia alla fine della funzione, poiché la variabile temporanea si spegne di scopo). Inoltre non può essere const , perché dovresti essere in grado di modificarlo direttamente.

Il primo argomento è un riferimento non const all'oggetto "calling", perché se fosse const , non sarebbe possibile modificarlo e, se non fosse un riferimento, non si cambierebbe il valore originale.

È a causa della copia necessaria nei sovraccarichi dell'operatore postfisso che è meglio prendere l'abitudine di usare prefisso ++ anziché postfix ++ in cicli for . Dalla for prospettiva di ciclo, sono di solito funzionalmente equivalenti, ma ci potrebbe essere un leggero vantaggio delle prestazioni di utilizzare il prefisso ++, in particolare con le classi di "grasso" con un sacco di membri da copiare. Esempio di utilizzo del prefisso ++ in un ciclo for:

for (list<string>::const_iterator it = tokens.begin();
     it != tokens.end();
     ++it) { // Don't use it++
    ...
}