--Opérateur de post-incrémentation comme un ++: incrémenté après que la valeur est passée à la fonction -Opérateur d'incrémentation du préfixe comme ++ b: incrémenté avant que la valeur ne soit transmise à la fonction
[Incrément \ -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)
En langage C, C ++, Java, JavaScript, etc., l'opérateur d'incrémentation (quantum croissant) "++" est préparé. Il existe deux types, pré-incrémentation et post-incrémentation. La phrase est la même "++", mais la signification est différente selon qu'elle est utilisée comme opérateur de préfixe (exemple: ++ x) ou comme opérateur de suffixe (exemple: x ++). Si la valeur de l'opérande est un entier, elle sera 1, et s'il s'agit d'un pointeur, elle changera d'une cible, mais la valeur en tant qu'expression sera la valeur après incrémentation s'il s'agit d'un préfixe (cela signifie +). = 1), dans le cas de postfix, c'est la valeur avant incrémentation.
Code source de Kotlin.
var a = 1
var b = 1
println(a++)
println(++b)
Résultat de l'exécution. Pour un ++, 1 est émis car il est passé à la fonction avant que la valeur ne soit incrémentée de +1. Dans le cas de ++ b, 2 est émis car la valeur est incrémentée de +1 puis transmise à la fonction.
$ kotlinc -script hello.kts
1
2
L'opérateur d'incrémentation de Kotlin se comporte comme C ou Java.
Code source C.
#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;
}
Résultat de l'exécution.
$ gcc hello.c -o hello
$ ./hello
1
2
Code source Java.
public class Hello {
public static void main(String[] args) {
int a = 1;
int b = 1;
System.out.println(a++);
System.out.println(++b);
}
}
Résultat de l'exécution.
$ javac Hello.java
$ java Hello
1
2
La surcharge des opérateurs d'incrémentation de Kotlin est facile à écrire. Vous pouvez surcharger l'opérateur d'incrémentation avec operator fun inc.
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)
Résultat de l'exécution. Dans le cas d'un ++, la valeur de num est transmise à la fonction avant d'être incrémentée de 1, donc l'état de num = 1 est affiché. Dans le cas de ++ b, la valeur de num est incrémentée de +1 puis transmise à la fonction, donc l'état de num = 2 est affiché.
$ kotlinc -script counter.kts
Counter(num=1)
Counter(num=2)
Écrivons le comportement d'un opérateur d'incrémentation similaire en C ++. En C ++, vous devez écrire des fonctions distinctes pour le suffixe et le préfixe.
#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;
}
Résultat de l'exécution.
$ g++ hello.cpp -o hellocpp
$ ./hellocpp
1
2
Recommended Posts