PureBasic:Variables Types
PureBasic:Manuel
<< Précédent | Sommaire | Suivant >>
Variables et Types
[modifier] Déclaration des variables
La déclaration d'une variable en PureBasic se fait en la nommant. Vous pouvez également spécifier le type que vous souhaitez pour cette variable. Les variables n'ont pas besoin d'être explicitement déclarées et peuvent être utilisées "à la volée". Le mot clef 'DefType' peut être utilisé pour déclarer plusieurs variables sur une même ligne. Exemple:
a.b ; Déclare une variable 'a' du type byte (.b). c.l = a*d.w ; 'd' est déclarée ici au milieu d'une expression !
Types basiques
PureBasic autorise la définition des types de variables. Ces types sont signés et peuvent être des entiers standards, des nombres flottants ou des chaines de caractères. Voici la liste des types natifs supportés:
Nom Extension Encombrement en mémoire Plage
- Byte .b 1 octet en mémoire -128 à +127
- Word .w 2 octets en mémoire -32768 à +32767
- Long .l 4 octets en mémoire -2147483648 à +2147483647
- Float .f 4 octets en mémoire illimité (voir informations plus bas)
- String .s longueur de la chaine + 1 illimité
Opérateurs
Les opérateurs peuvent être intégrés aux expressions pour combiner les variables, constantes et tout ce qui est nécessaire. La table ci-dessous montre tous les opérateurs utilisables en PureBasic. (LHS = Left Hand Side ou partie gauche, RHS = Right Hand Side ou partie droite).
| Opérateur | Description / Exemple |
| = | Egal. Peut être utilisé selon deux acceptions. La première est pour l'affectation de la variable LHS à la valeur résultat de l'expression RHS. La seconde signification est l'utilisation dans une expression de comparaison entre LHS et RHS. Si le résultat de LHS est identique au résultat de RHS la valeur 'vrai' sera retournée sinon se sera la valeur 'faux'.
Exemple: a=b+c ; Affecte la valeur de "b+c" à la variable "a" If abc=def ; Test si les valeurs de abc et def sont identiques et utilise le résultat dans la commande If |
| + | Plus. Donne le résultat de la valeur de l'expression RHS ajoutée à la valeur de l'expression LHS. Si le résultat de cet opérateur n'est pas utilisé et qu'il y a une variable LHS, alors la valeur de l'expression RHS sera directement ajoutée à la valeur LHS.
Exemple: nombre=mavaleur+2 ; Ajoute la valeur 2 à "mavaleur" et utilise le résultat avec l'opérateur = variable+expression ; La valeur de "expression" est directement ajoutée à "variable" |
| - | Moins. Soustrait la valeur de l'expression RHS de la valeur de l'expression LHS. Si il n'y a pas d'expression LHS l'opérateur prend la valeur négative de la valeur RHS. Si le résultat de l'opérateur n'est pas utilisé et qu'il n'y a pas de variable LHS, alors la valeur de RHS est directement soustraite à la valeur de la variable LHS. Cet opérateur ne peut être utilisé avec les variables de type chaine.
Exemple: var=#MaConstante-chose; Soustrait la valeur de "chose" de "#MyConstant" et utilise le résultat avec l'opérateur égal. uneautre=uneautre+ -var ; Calcule la valeur négative de "var" et utilise le résultat avec l'opérateur +. variable-expression ; La valeur "expression" est directement soustraite à "variable" |
| * | Multiplication. Multiplie la valeur de l'expression LHS par la valeur de RHS. Si le résultat de l'opérateur n'est pas utilisé et qu'il y a une variable LHS, alors la valeur de la variable est directement multipliée par la valeur de l'expression RHS. Cet opérateur ne peut être utilisé dans une variable de type chaine.
Exemple: total=prix*quantite ; Multiplie la valeur de "prix" par la valeur de "quantite" et utilise le résultat avec l'opérateur = variable*expression ; "variable" est multiplé directement par la valeur de "expression" |
| / | Division. Divise la valeur de l'expression LHS par la valeur de l'expression RHS. Si le résultat de l'opérateur n'est pas utilisé et qu'il y a une variable LHS, alors la valeur de la variable est directement divisée par la valeur de l'expression RHS. Cet opérateur ne peut être utilisé dans les variables de type chaine.
Exemple: quantite=total/prix ; Divise la valeur "total" par la valeur "prix" et utilise le résultat avec l'opérateur = variable/expression ; "variable" est directement divisé par la valeur "expression" |
| & | AND est un ET logique (binaire). Il vous faut être familiarisé avec les nombres binaires pour utiliser cet opérateur. Le résultat de cet opérateur est le résultat d'un ET logique entre les valeurs des expressions LHS et RHS, bit à bit. La valeur de chaque bit résultant est fixée comme indiqué dans la table ci-dessous. De plus, si le résultat de l'opérateur n'est pas utilisé et qu'il y a une variable LHS, alors le résultat sera directement stocké dans cette variable. Cet opérateur ne peut être utilisé avec une variable de type chaine.
LHS | RHS |Résultat 0 | 0 | 0 0 | 1 | 0 1 | 0 | 0 1 | 1 | 1 Exemple:
a.w = %1000 & %0101 ; Le résultat sera 0 b.w = %1100 & %1010 ; Le résutlat sera %1000 bits = a & b ; Effectue un ET bit à bit entre a et b et utilise le résultat avec l'opérateur = a & b ; Effectue un ET bit à bit entre a et b et place le résultat directement dans la variable "a" |
| OR est un OU logique. (binaire). Vous devez être familiarisé avec les nombres binaires pour utiliser cet opérateur. Le résultat de cet opérateur est le résultat d'un OU logique entre les valeurs des expressions LHS et RHS bit à bit. La valeur de chaque bit résultant est fixée comme indiqué dans la table ci-dessous. De plus, si le résultat de l'opérateur n'est pas utilisé et qu'il et qu'il y a une variable LHS alors le résultat est directement stocké dans cette variable. Cet opérateur ne peut être utilisé avec une variable de type chaine.
LHS | RHS |Résultat 0 | 0 | 0 0 | 1 | 1 1 | 0 | 1 1 | 1 | 1 Exemple:
a.w = %1000 | %0101 ; Le résultat sera %1101 b.w = %1100 | %1010 ; Le résultat sera %1110 bits = a | b ; Effectue un OU bit à bit entre a et b et utilise le résultat avec l'opérateur = a | b ; Effectue un OU bit à bit entre a et b et place le résultat directement dans la variable "a" | |
| ! | XOR est un OU Exclusif logique (binaire). Vous devez être familiarisé avec les nombres binaires pour utiliser cet opérateur. Le résultat de cet opérateur est le résultat d'un OU Exclusif entre les valeurs LHS et RHS bit à bit. La valeur de chaque bit résultant est fixée comme indiqué dans la table ci-dessous. De plus, si le résultat de l'opérateur n'est pas utilisé et qu'il y a une variable LHS alors le résultat est directement stocké dans cette variable. Cet opérateur ne peut être utilisé avec une variable de type chaine.
LHS | RHS |Résultat 0 | 0 | 0 0 | 1 | 1 1 | 0 | 1 1 | 1 | 0 Exemple:
a.w = %1000 ! %0101 ; Le résultat sera %1101 b.w = %1100 ! %1010 ; Le résultat sera %0110 bits = a ! b ; Effectue un OU Exclusif bit à bit entre a et b et utilise le résultat avec l'opérateur = a ! b ; Effectue un OU Exclusif bit à bit entre a et b et place le résultat directement dans "a" |
| ~ | NOT est une inversion logique (binaire). Vous devez être familiarisé avec les nombres binaires pour utiliser cet opérateur. Le résultat de cet opérateur est une inversion bit à bit de la valeur RHS. La valeur de chaque bit est fixée comme indiqué dans la table ci-dessous. Cet opérateur ne peut être utilisé avec une variable de type chaine.
RHS |Résultat 0 | 1 1 | 0 Exemple:
a.w = ~%1000 ; Le résultat sera %0111 b.w = ~%1010 ; Le résultat sera %0101 |
| () | Parenthèses. Vous pouvez utiliser les parenthèses pour forcer l'évaluation prioritaire d'une partie d'une expression ou modifier l'ordre d'évaluation.
Exemple: a = (5 + 6) * 3 ; Le résultat est 33 car 5+6 est évalué en premier b = 4 * (2 - (3 - 4)) ; Le résutlat est 12 car 3-4 est évalué en premier, ensuite 2-résultat puis la mutiplication pour finir |
| < | Inférieur à. Utilisé pour comparer les valeurs des expressions LHS et RHS. Si la valeur de LHS est plus petite que la valeur de RHS cet opérateur rend un résultat vrai, sinon le résultat est faux. |
| > | Supérieur à. Utilisé pour comparer les valeurs des expressions LHS et RHS. Si la valeur de LHS est plus grande que la valeur de RHS cet opérateur rend un résultat vrai, sinon le résultat est faux. |
| <= | Inférieur ou égal à. Utilisé pour comparer les valeurs des expressions LHS et RHS. Si la valeur de LHS est plus petite ou égale à la valeur de RHS cet opérateur rend un résultat vrai, sinon le résultat est faux. |
| >= | SUpérieur ou égal à. Utilisé pour comparer les valeurs des expressions LHS et RHS. Si la valeur de LHS est plus grande ou égale à la valeur de RHS cet opérateur rend un résultat vrai, sinon le résultat est faux. |
| <> | Différent. Utilisé pour comparer les valeurs des expressions LHS et RHS. Si la valeur de LHS est différente de la valeur de RHS cet opérateur rend un résultat vrai, sinon le résultat est faux. |
| And | ET logique. Peut être utilisé pour combiner les résultats vrais ou faux des opérateurs de comparaison en donnant un résultat fixé comme indiqué dans la table ci-dessous.
LHS | RHS |Résultat faux | faux | faux faux | vrai | faux vrai | faux | faux vrai | vrai | vrai |
| Or | OU logique. Peut être utilisé pour combiner les résultats vrais ou faux des opérateurs de comparaison en donnant un résultat fixé comme indiqué dans la table ci-dessous.
LHS | RHS |Résultat vrai | faux | faux faux | vrai | vrai vrai | faux | vrai vrai | vrai | vrai |
| << | Décalage à gauche. Décale vers la gauche les bits du nombre LHS de RHS places. Decaler les bits vers la gauche revient à faire une multiplication par un multiple de 2. Il est conseillé de bien comprendre les opérations binaires avant d'utiliser cet opérateur.
Exemple: a=%1011 << 1 ; La valeur de 'a' sera %10110. (en decimal: %1011=11 et %10110=22) b=%111 << 4 ; La valeur de 'b' sera %1110000. (en decimal: %111=7 et %1110000=208) c.l=$8000000 << 1 ; La valeur de 'c' sera 0. Les bits supérieurs sont perdus car ils dépassent la capacité du type. |
| >> | Décalage à droite. Décale vers la droite les bits du nombre LHS de RHS places. Decaler les bits vers la droite revient à faire une division par un multiple de 2. Il est conseillé de bien comprendre les opérations binaires avant d'utiliser cet opérateur.
Exemple: d=16 >> 1 ; La valeur de 'd' sera 8. (en binaire: 16=%10000 et 8=%1000) e.w=%10101010 >> 4 ; La valeur de 'e' sera %1010. (en décimal: %10101010=170 et %1010=10). f.b=-128 >> 1 ; La valeur de 'f' sera -64. -128=%10000000, -64=%11000000. Lors du décalage, le bit le plus fort reste (conservation du signe). |
| % | Modulo. Calcule le reste de la division entière de RHS par LHS.
Exemple: a=16 % 2 ; La valeur sera 0 car 16/2 = 8 (aucun reste) b=17 % 2 ; La valeur sera 1 car 17/2 = 8*2+1 (reste 1) |
Priorité des opérateurs
Niveau de priorité | Opérateurs
--------------------+---------------------
7 (maximum) | ~
6 | <<, >>, %, ^
5 | |, &
4 | *, /
3 | +, -
2 | >, >=, <, <=, =, <>
1 (minimum) | And, Or
Types structurés
Les types structurés peuvent être définis avec les options propres aux structures. Voyez le chapitre structures pour plus d'information. Information concernant les nombres flottants
Un nombre flottant est stocké de telle manière que la 'virgule flotte' autour de la partie réelle. De la sorte, il est possible d'avoir des nombres dont la valeur peut être aussi bien grande que petite. Toutefois vous ne pouvez pas stocker de grands nombres avec une précision aussi élevée que des petits nombres. Une autre limitation concernant les nombres flottants est qu'ils restent concrètement représentés sous une forme binaire. Ainsi, ils ne peuvent être restitués qu'à partir de multiples et de divisions en base 2. Celà est important pour comprendre que la représentation décimale lors de l'affichage ou du calcul n'est pas tout à fait identique à ce que l'on peut attendre dans une représentation humaine. Représenter 0.5 ou 0.125 est simple car ce sont des divisions parfaites de 2, cela est plus complexe pour des nombres comme 0.1 ou 0.9996125. L'affichage approché de la valeur est toujours correct à un nombre limité de décimales, mais ne soyez pas surpris si au-delà le nombre affiché s'écarte de la valeur que vous attendez!
Ces remarques s'appliquent aux nombres flottants traités par ordinateur d'une manière générale et non spécifiquement à Purebasic.
