Unäre Operatoren besitzen lediglich ein Argument, sie stehen also nicht wie die Infixoperatoren zwischen zwei Werten, sondern vor (Präfix-Operator) oder nach (Postfix-Operator) einem Argument. Hier einige Beispiele:

int a;
 
int *pa = &a;  // Prefix
int ia = ~a;   // Prefix
++a;           // Prefix
a++;           // Postfix

Es gibt zwei Möglichkeiten einen Prefix-Operator zu überladen:

• Definition innerhalb der betreffenden Klasse
• als globale Definition

Bei der ersten Möglichkeit sehe ich den zusätzlichen Vorteil, dass sich die Operatordefintion leicht in den Quelltexten wiederfinden lässt.

Bei folgendem Beispiel wird der ++ Prefix-Operator überladen.

class Fraction
{
  private:
    int numerator;
    int denumerator;
  public:
    Fraction & operator ++( void );
};
Fraction & Fraction::operator ++( void )
{
  numerator += denumerator;
  return *this;
}

Nun ist es möglich, die Klasse 'Fraction' mittels

Fraction f;
 
++f;

durchzuzählen. Selbstverständlich besteht auch die Möglichkeit, solche einfachen Operatoren direkt inline in die Klassendeklaration ins Headerfile zu schreiben.

Das gleiche Beispiel wie zuvor nun noch einmal. Da wir uns nun nicht mehr innerhalb einer Klasse befinden, können wir den this-Pointer nicht mehr verwenden. Stattdessen lassen wir uns die Referenz auf das Objekt einfach übergeben. Müssen wir auf durch 'privat' oder 'protected' geschützte Daten zugreifen, so muss der Operator als 'friend' definiert werden.

class Fraction
{
  friend Fraction & operator ++( Fraction & );
 
  private:
    int numerator;
    int denumerator;
};
 
Fraction & operator ++( Fraction & f )
{
  f.numerator += f.denumerator;
  return f;
}

Das Resultat ist gleichwertig.

Nach diesem Muster lassen sich alle unären Prefix-Operatoren überladen.

In C++ sind nahezu alle unären Operatoren Präfix-Operatoren, doch keine Regel ohne Ausnahme: Für die Inkrement, bzw. Dekrement-Operatoren gibt es daher eine eigene Seite, die die Besonderheiten der Postfix-Varianten beschreibt.