avant-propos
Les entiers sont généralement plus utilisés, et l'existence d'entiers se verra dans divers contrats, donc ce type est également indispensable sur la route de l'apprentissage
alentours:
Le compilateur de remix me clique pour sauter
texte
Nous rencontrons de nombreux types de données entières dans sol, donc notre sol fournit deux types de données entières :
Entier signé (entier) : Ici on peut le comprendre comme un entier positif et négatif
Entier non signé (uint) : entier non signé, où seuls les nombres positifs et 0 existent
Afin d'avoir un meilleur contrôle de la mémoire, sol fournit, int8, int16, int32, etc., des types entiers non signés jusqu'à int256
Il en va de même pour nos entiers non signés, uint8, uint16, uint32...uint256
Donc, ce à quoi nous devons faire attention dans la sélection, c'est que pour 0 ~ 256 bits de données, nous pouvons utiliser uint8, puis nous utilisons int8 pour stocker les nombres négatifs signés en nombres positifs -128 ~ 127. Selon la situation réelle, nous va monter.
Certains étudiants seront curieux, que signifie ce 8, 16, 32...256 ?
Voici notre binaire, car notre ordinateur est composé de code 0101, donc la logique de stockage sous-jacente est binaire, alors ici 00000000 représente 0 en binaire, 11111111 représente 256 en binaire, les étudiants attentifs trouveront ce nombre Le nombre est huit, c'est tout, donc notre stockage est stocké comme ça
int et opérateur
Il existe trois types d'opérateurs pris en charge par les types entiers : les opérateurs de comparaison, les opérateurs au niveau du bit et les opérateurs arithmétiques.
opérateur de comparaison
| <= (inférieur ou égal à) | < (Inférieur à) | == (égal à) | != (non égal) | >= (supérieur ou égal à) | > (supérieur à) |
opérateurs au niveau du bit
| &&(et) | || (ou) | ^ (ou exclusif) | ~ (inversion de bits) |
opérateurs arithmétiques
| + | - | Opérateur unaire "-" | Opérateur unaire "+" | * | / | % | ** | << | >> |
Après l'avoir revu, on estime qu'il y a un problème avec le fonctionnement du shift gauche et droit, voici une explication.
Décalage à gauche : a << b peut être compris comme a multiplié par 2 à la puissance b
Décalage vers la droite : a >> b peut être compris comme a divisé par 2 à la puissance b
L'opérateur s'utilise comme suit :
uint256 public _uintNum = 12345; //Résultat entier : 12345
uint256 public _uintNum1 = _uintNum + 1 ; // résultat de l'addition : 12346
uint256 public _uintNum2 = 2**2 ; // résultat de l'exposant : 4
uint256 public _uintNum3 = 7 % 2; // Résultat restant : 1
bool public _boolnum = _ uintNum2 > _uintNum3;//Résultat du jugement : vrai
Précautions
Méthode de déclaration
int8 a = -1 ;
uint16 b = 1 ;
uint c ;
int d ;
Dans les opérations sur les nombres entiers, si une constante est rencontrée, elle sera tronquée. S'il s'agit d'une constante, elle ne le sera pas. Une constante est une quantité qui a une valeur lorsqu'elle est définie et ne change pas. Si elle rencontre 0, elle est illégal et une erreur sera signalée.
Le déplacement à gauche et à droite consiste à déplacer la position binaire. Maintenant, nous avons un nombre binaire tel que 10000, qui est 32 en décimal. Ensuite, nous nous déplaçons vers la droite jusqu'à 1000, et il en va de même pour le décalage vers la gauche.
Tu ne peux pas penser négativement, tu ne peux pas devenir négatif
Les nombres négatifs ne peuvent pas être exponentiels, c'est-à-dire "**"
pragma solidity ^0.4.23; //表示编译器的版本，^代表大版本为4即可
contract UintTest{ //创建一个合约 自定义合约名为UintTest
uint a = 10; // 定义一个变量a为10
uint b = 2; // 定义一个变量b为2
function getUint() public view returns(uint){// 定义一个函数 函数名为getUint 权限为公共 只读 返回一个uint类型
uint sum = a ** b + 3 % 2;// 定义一个uint类型使用运算符a的b次方加3取余2最后的结果为101
return sum;// 返回sum
}
}