Warum ist n++ schneller als n=n+1?
Nein, Ja (aber), Vielleicht!
Nein: Soweit ich die Antworten meiner Vorredner gelesen haben, gingen die wohl alle davon aus, dass du einen modernen C (vielleicht auch C++) Compiler verwendest und dass n ein Integer oder artverwandter Typ ist. In dem Fall sollte es ganz eindeutig egal sein was du verwendest, weil der Compiler schlau genug sein sollte für beides den selben Code zu generieren.
Ja (aber): Jetzt begeben wir uns aber mal ins Jahr 1980 zurück, als C als Programmiersprache gerade mal ein paar Jahre auf dem Buckel hatte und optimierende Compiler noch SciFi waren. Aus dieser Zeit stammt wohl noch die Aussage in deiner Frage. In diesem Falle würde ich dir recht geben, dass n++ schneller ist als n=n+1, weil der Compiler für n++ den INC Befehl des Prozessors verwendet (hatte eigentlich jeder Prozessor) und nur 1 Register braucht, während n=n+1 den ADD Befehl verwendet und u.U. zuerst mal das Carry-Flag rücksetzen muss (manche Prozessoren hatten keine zwei ADDs für mit oder ohne Carry und mussten hier also erstmal das Carry-Flag zurücksetzen) und mindestens 1 Register und die 1 fürs ADD muss ja auch erstmal irgendwo herkommen. Also das sollte mehr Prozessorzyklen brauchen und darum ist n++ schneller als n=n+1.
Und damit kommen wir zum aber: Der Wert des Ausdrucks n++ ist der Wert von n vor dem Inkrement. Was bedeutet, dass der Compiler - nur für den Fall das n vor dem Inkrement noch gebraucht wird - den Wert von n zuerst nochmal irgendwo retten muss, damit er noch vorhanden ist falls er gebraucht wird. Darum hätte ich dir damals geraten über ++n nachzudenken, weil da der Wert des Ausdrucks der Wert von n nach dem Inkrement ist, also nicht zwischengespeichert werden muss und damit die schnellste Variante ist.
Und bevor jetzt nochmal jemand sagt, dass das ja heute egal ist, weil Optimierer und so, dem möchte ich mal etwas zum Nachdenken mit auf dem Weg geben: Was, wenn wir bei C++ sind und n ein Objekt einer Klasse ist? Denn dann wären wir bei meinem
Vielleicht!: Also n ist ein Objekt einer Klasse. Jetzt wird es deutlich komplizierter. Ich will das mal an einer sehr einfachen Klasse X mit den entsprechenden Operatoren so wie sie üblicherweise implementiert werden verdeutlichen:
class X 
{ 
public: 
    // prefix increment 
    X& operator++() 
    { 
        // was auch immer fürs inkrementieren nötig ist 
        return *this; // return new value by reference 
    } 
      // postfix increment 
    X operator++(int) 
    { 
        X old = *this; // copy old value 
        operator++();  // prefix increment 
        return old;    // return old value 
    } 
      X& operator+=(const X& rhs) // könnte auch friend sein, aber da ein private member 
    {                           // modifiziert werden muss ist member function besser 
        // was auch immer für ein += notwendig ist, bitte hierher 
        return *this; // return result by reference 
    } 
       friend X operator+(X lhs,        // passing lhs by value helps optimize chained a+b+c 
                       const X& rhs) // otherwise, both parameters may be const references 
    { 
        lhs += rhs; // reuse compound assignment 
        return lhs; // return the result by value (uses move constructor) 
    } 
}; 
Also, soweit ich das sehe nützt hier auch kein optimierender Compiler mehr:
++n ist schneller als n++ und n += 1 ist schneller als n = n+1 aber ist n++ auch schneller als n=n+1? Dazu müsste man jetzt tatsächlich über die Innereien der Klasse X und der Komplexität der Operationen Bescheid wissen. Kann sein ja, kann sein nein. Also ganz definitiv "Vielleicht!". Mit einer leichten Tendenz zu n++ ist schneller.