--Post-Inkrement-Operator wie ein ++: Inkrementiert, nachdem der Wert an die Funktion übergeben wurde -Prefix-Inkrement-Operator wie ++ b: Inkrementiert, bevor der Wert an die Funktion übergeben wird
[Inkrement \ -Wikipedia](https://ja.wikipedia.org/wiki/%E3%82%A4%E3%83%B3%E3%82%AF%E3%83%AA%E3%83%A1% E3% 83% B3% E3% 83% 88)
In C-Sprache, C ++, Java, JavaScript usw. wird der Inkrementoperator (zunehmendes Quantum) "++" vorbereitet. Es gibt zwei Arten: Pre-Inkrement und Post-Inkrement. Der Ausdruck ist der gleiche "++", aber die Bedeutung ist unterschiedlich, je nachdem, ob er als Präfixoperator (Beispiel: ++ x) oder als Suffixoperator (Beispiel: x ++) verwendet wird. Wenn der Wert des Operanden eine Ganzzahl ist, ist er 1, und wenn es sich um einen Zeiger handelt, ändert er sich um ein Ziel, aber der Wert als Ausdruck ist der Wert nach dem Inkrementieren, wenn es sich um ein Präfix handelt (dies bedeutet +). = 1) Im Fall von Postfix ist dies der Wert vor dem Inkrementieren.
Kotlin Quellcode.
var a = 1
var b = 1
println(a++)
println(++b)
Ausführungsergebnis. Bei einem ++ wird 1 ausgegeben, da es an die Funktion übergeben wird, bevor der Wert um +1 erhöht wird. Im Fall von ++ b wird 2 ausgegeben, da der Wert um +1 erhöht und dann an die Funktion übergeben wird.
$ kotlinc -script hello.kts
1
2
Kotlins Inkrementoperator verhält sich wie C oder Java.
C Quellcode.
#include <stdio.h>
int main(int argc, char *args[]) {
int a = 1;
int b = 1;
printf("%d\n", a++);
printf("%d\n", ++b);
return 0;
}
Ausführungsergebnis.
$ gcc hello.c -o hello
$ ./hello
1
2
Java-Quellcode.
public class Hello {
public static void main(String[] args) {
int a = 1;
int b = 1;
System.out.println(a++);
System.out.println(++b);
}
}
Ausführungsergebnis.
$ javac Hello.java
$ java Hello
1
2
Kotlins Inkrement-Operator-Überladung ist einfach zu schreiben. Sie können den Inkrement-Operator mit operator fun inc überladen.
data class Counter(val num: Int) {
operator fun inc(): Counter {
return Counter(num + 1)
}
}
var a = Counter(1)
var b = Counter(1)
println(a++)
println(++b)
Ausführungsergebnis. Im Fall von ++ wird der Wert von num an die Funktion übergeben, bevor er um 1 erhöht wird, sodass der Status von num = 1 ausgegeben wird. Im Fall von ++ b wird der Wert von num um +1 erhöht und dann an die Funktion übergeben, sodass der Status von num = 2 ausgegeben wird.
$ kotlinc -script counter.kts
Counter(num=1)
Counter(num=2)
Schreiben wir das Verhalten eines ähnlichen Inkrementoperators in C ++. In C ++ müssen Sie separate Funktionen für das Suffix und das Präfix schreiben.
#include <iostream>
class Counter {
private:
int num;
public:
Counter(int num) : num(num) {}
// Prefix increment operator
Counter& operator ++() {
this->num++;
return *this;
}
// Postfix increment operator
Counter operator ++(int) {
Counter c = *this;
this->num++;
return c;
}
friend std::ostream& operator<<(std::ostream& os, const Counter& c) {
os << c.num;
return os;
}
};
int main(int argc, char *argv[]) {
Counter a(1);
Counter b(1);
std::cout << a++ << std::endl;
std::cout << ++b << std::endl;
return 0;
}
Ausführungsergebnis.
$ g++ hello.cpp -o hellocpp
$ ./hellocpp
1
2
Recommended Posts