Inkrement- und Dekrementoperatoren sind unäre Operatoren , die ihren Operanden um eins erhöhen bzw. verringern .

Sie sind häufig in imperativen Programmiersprachen anzutreffen . C -ähnliche Sprachen verfügen über zwei Versionen (Prä- und Post-) jedes Operators mit leicht unterschiedlicher Semantik.

In Sprachen, die syntaktisch von B abgeleitet sind (einschließlich C und seinen verschiedenen Ableitungen), wird der Inkrementoperator als ++und der Dekrementoperator als geschrieben --. Mehrere andere Sprachen verwenden die Funktionen inc(x) und dec(x).

Der Inkrementoperator erhöht, der Dekrementoperator verringert den Wert seines Operanden um 1. Der Operand muss vom Datentyp arithmetisch oder ein Zeiger sein und auf ein veränderbares Datenobjekt verweisen . Zeigerwerte werden um einen Betrag erhöht (oder verringert), der sie auf das nächste (oder vorherige) benachbarte Element im Speicher zeigt.

In Sprachen, die beide Versionen der Operatoren unterstützen:

  • Die Präinkrement- und Prädekrementoperatoren erhöhen (erhöhen) bzw. verringern ihren Operanden um 1, und der Wert des Ausdrucks ist der resultierende erhöhte (bzw. verringerte) Wert.
  • Die Postinkrement- und Postdekrementoperatoren erhöhen (bzw. verringern) den Wert ihres Operanden um 1, der Wert des Ausdrucks ist jedoch der Wert des Operanden vor der Inkrement- (bzw. Dekrement-)Operation.

In Sprachen, in denen Inkrement/Dekrement kein Ausdruck ist (z. B. Go ), ist nur eine Version erforderlich (im Fall von Go nur Post-Operatoren).

Da der Inkrement-/Dekrementoperator seinen Operanden verändert, kann die mehrfache Verwendung eines solchen Operanden innerhalb desselben Ausdrucks zu undefinierten Ergebnissen führen. Beispielsweise x - ++xist in Ausdrücken wie „subtrahieren“ nicht klar, in welcher Reihenfolge die Subtraktions- und Inkrementierungsoperationen ausgeführt werden sollen. Solche Ausdrücke rufen im Allgemeinen undefiniertes Verhalten hervor und sollten vermieden werden.

In Sprachen mit typisierten Zeigern wie C erhöht der Inkrementoperator den Zeiger auf das nächste Element desselben Typs – sein Wert wird also um die Größe des Typs erhöht. Zeigt ein Zeiger (des richtigen Typs) auf ein Element eines Arrays, so bewirkt das Inkrementieren (oder Dekrementieren), dass er auf das „nächste“ (bzw. „vorherige“) Element des Arrays zeigt. So zeigt ein Zeiger auf eine Ganzzahl durch Inkrementieren auf die nächste Ganzzahl (typischerweise wird der Zeigerwert um 4 erhöht); [ 1 ] ein Zeiger auf eine Struktur der Größe 106 Byte zeigt durch Inkrementieren auf die nächste Struktur, indem der Zeigerwert um 106 erhöht wird. [ 2 ]

Beispiele

Das folgende C-Codefragment veranschaulicht den Unterschied zwischen den Prä- und Postinkrement- und Dekrementoperatoren: 

int x ; int y ;// Inkrementoperatoren // Präinkrement: x wird um 1 erhöht, dann wird y der Wert von x zugewiesen. x = 1 ; y = ++ x ; // x ist jetzt 2, y ist ebenfalls 2// Nachinkrementierung: y wird der Wert von x zugewiesen, dann wird x um 1 erhöht. x = 1 ; y = x ++ ; // y ist 1, x ist jetzt 2// Dekrementoperatoren // Vordekrement: x wird um 1 dekrementiert, dann wird y der Wert von x zugewiesen. x = 1 ; y = -- x ; // x ist jetzt 0, y ist ebenfalls 0// Nachdekrementierung: y wird der Wert von x zugewiesen, dann wird x um 1 dekrementiert. x = 1 ; y = x -- ; // y ist 1, x ist jetzt 0

In Sprachen, denen diese Operatoren fehlen, ist für äquivalente Ergebnisse eine zusätzliche Codezeile erforderlich: 

# Vorinkrement: y = ++x x = 1 x = x + 1 # x ist jetzt 2 (kann in Python als "x += 1" geschrieben werden) y = x # y ist ebenfalls 2# Nachinkrement: y = x++ x = 1 y = x # y ist 1 x = x + 1 # x ist jetzt 2

Der Postinkrementoperator wird häufig bei Array- Indizes verwendet. Zum Beispiel: 

// Die Elemente eines Arrays addieren float sum_elements ( float arr [], int n ) { float sum = 0.0 ; int i = 0 ;while ( i < n ) sum += arr [ i ++ ]; // Nachinkrementierung von i, die // n Elemente des Arrays durchläuft return sum ; }

Der Postinkrementoperator wird auch häufig mit Zeigern verwendet : 

// Kopiert ein Array in ein anderes void copy_array ( float * src , float * dst , int n ) { while ( n -- > 0 ) // Schleife, die von n bis null herunterzählt * dst ++ = * src ++ ; // Kopiert das Element *(src) nach *(dst) und inkrementiert anschließend beide Zeiger }

Diese Beispiele funktionieren auch in anderen C-ähnlichen Sprachen wie C++ , Java und C# .

  • Der Inkrementoperator lässt sich anhand eines Beispiels veranschaulichen:
    #include <stdio.h> int main () { int c = 2 ; printf ( "%d \n " , c ++ ); // Diese Anweisung gibt 2 aus, dann wird c um 1 auf 3 erhöht. printf ( "%d" , ++ c ); // Diese Anweisung erhöht c um 1, dann wird c ausgegeben. return 0 ; }
    • Ausgabe:
      2 4

Unterstützte Sprachen

Die folgende Liste, die jedoch weder vollständig noch alle Aspekte umfasst, führt einige der wichtigsten Programmiersprachen auf, die die Inkrement- und Dekrementoperatoren unterstützen.

Apples Swift unterstützte diese Operatoren einst, sie gelten jedoch seit Version 2.2 als veraltet [ 13 ] und wurden mit Version 3.0 entfernt. [ 14 ] [ 15 ]

Pascal , Delphi , Modula-2 und Oberon verwenden Funktionen ( inc(x)und dec(x)) anstelle von Operatoren. Tcl verwendet den incrBefehl.

Insbesondere Python , Ruby und Rust unterstützen diese Operatoren nicht.

Geschichte

Das Konzept wurde um 1969 von Ken Thompson in der Programmiersprache B eingeführt . [ 16 ]

Thompson ging noch einen Schritt weiter und erfand die Operatoren ++ und --, die inkrementieren bzw. dekrementieren. Ihre Position als Präfix oder Postfix bestimmt, ob die Änderung vor oder nach der Wertfestlegung des Operanden erfolgt. Sie waren in den frühen Versionen von B nicht enthalten, kamen aber im Laufe der Entwicklung hinzu. Oft wird vermutet, dass sie für die Nutzung der automatischen Inkrementierungs- und Dekrementierungs-Adressierungsmodi des DEC PDP-11 entwickelt wurden, auf dem C und Unix erstmals populär wurden. Dies ist historisch unmöglich, da es zum Zeitpunkt der Entwicklung von B noch keinen PDP-11 gab. Der PDP-7 besaß jedoch einige „automatisch inkrementierende“ Speicherzellen, deren indirekter Speicherzugriff durch diese Zellen den Wert inkrementierte. Dieses Merkmal inspirierte Thompson wahrscheinlich zu solchen Operatoren; die Verallgemeinerung, sie sowohl als Präfix- als auch als Postfix-Operatoren zu verwenden, stammte von ihm. Tatsächlich wurden die automatisch inkrementierenden Zellen bei der Implementierung der Operatoren nicht direkt verwendet, und ein wichtigerer Anstoß für die Innovation war vermutlich seine Beobachtung, dass die Übersetzung von ++x kleiner war als die von x=x+1.

Siehe auch

Referenzen

  1. ^ Richard M. Reese. „Understanding and Using C Pointers“ . „Kapitel 4. Pointers and Arrays“ . O’Reilly Media, Inc. 2013. ISBN 9781449344184
  2. ^ Richard Petersen. „Einführung in C mit C++“ . 2019. Abbildung 12-12.
  3. ^ „GNU Awk's User Guide“ . Free Software Foundation.
  4. ^ „8.3. Die Konstruktion mit doppelten Klammern“ . Das Linux-Dokumentationsprojekt.
  5. ^ Ritchie, Brian W. Kernighan ; Dennis M.; Ritchie, Dennis (1988). Die Programmiersprache C (2. Aufl., [Nachdr.] Hrsg.). Englewood Cliffs, NJ: Prentice Hall. S.  18. ISBN 0-13-110362-8Die{{cite book}}: CS1 Wartung: Mehrere Namen: Autorenliste ( Link )
  6. ^ "Inkrement-/Dekrementoperatoren" . cppreference.com.
  7. ^ "++ Operator (C# Reference)" . Microsoft Developer Network. 8. April 2023.
  8. ^ „Operatorüberladung“ . dlang.org.
  9. ^ "GP-Betreiber und ihre Prioritäten" .
  10. ^ „Über Zuweisungsoperatoren“ . 19. Januar 2024.
  11. ^ „Wolfram Language Symbol erhöhen“ . Wolfram Language Documentation Center.
  12. ^ „Wolfram-Sprachsymbol verringern“ . Wolfram Language Documentation Center.
  13. ^ „Neue Funktionen in Swift 2.2“ . Offizielle Swift-Website. 30. März 2016.
  14. ^ „Swift 3.0 veröffentlicht!“ . Offizielle Swift-Website. 13. September 2016.
  15. ^ „Entferne die and- Operatoren“ . Swift-Evolution .++--
  16. ^ Ritchie, Dennis M. (März 1993). „Die Entwicklung der Programmiersprache C“ . ACM SIGPLAN Notices . 28 (3): 5. doi : 10.1145/155360.155580 .