Gli operatori in cima alla lista sono valutati per primi. Gli operatori all'interno del gruppo hanno la stessa precedenza. Tutti gli operatori hanno asscociazione da sinistra a destra se non scritto diversamente.

Un aspetto importante del C++ in relazione alla precedenza degli operatori è l'ordine di valutazione e l'ordine dei side effect nelle espressioni. In molte circostanze l'ordine di come avvengono le cose non è specificato. Per esempio in f() + g() ,quale fra f() o g() è chiamato prima non è specificato. Se almeno una funzione ha side effect, il risultato può differire in funzione del compilatorem,delle differenti versioni dello stesso compilatore o fra diversi accessi allo stesso compilatore.

In più l'effetto di certe espressioni non è definita. Per esempio, considerando il codice seguente:

    float x = 1;
    x = x / ++x;

Il valore di x e il resto del comportamento del programma dopo la valutazione dell'espressione non è definito. Il programma è semanticamente ill-formed: x è modificato doppiamente fra due punti consecutivi.

Espressioni come quella scritta sopra devono essere evitate. Quando c'è un dubbio, rompere l'espressione più grande in sotto-espressioni per assicurare che la valutazione sia corretta.

L'overloading degli operatori può essere molto utile e molto pericoloso. Da una parte l'overload delgi operatori per una classe creata può aiutare il trasporto e la leggibilità del codice. Dall'altra parte si potrebbe sovraccaricare un operatore in modo da rendere offuscato o rovinare il proprio programma.Fai Attenzione! In particolare mai eseguire l'overload di &&, || o ,. Nel contesto overloaded si perde la garanzia che loperando sinistro sia valutato prima del secondo e che ci sia una sequenza di punti fra di loro.

Ci sono due modi per sovraccaricare un operatore: global function o class member.

Esempio di overloading con una global function:

     ostream& operator <<(ostream& os, const myClass& rhs);

Ma per raggiungere qualsiasi dato private all'interno della classe definita dall'utente, si deve dichiarare la global function come friend all'interno della definizione della classe.

Esempio:

     class myClass {
 
       // Gives the operator << function access to 'myData'
       // (this declaration should not go in public, private or protected)
       friend ostream& operator <<(ostream& lhs, const myClass& rhs);
 
       private:
         int myData;
     }

L'overloading con una classe può essere eseguito come segue:

     class myClass {
 
       public:
         // The left hand side of this operator becomes '*this'.
         int operator +(const myClass& rhs);
 
       private:
         int myData;
     }