Variables, Types et Opérateurs
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 Define 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 !Note: les noms de variables ne peuvent pas commencer avec un chiffre (0, 1, etc.) et ne peuvent pas contenir d'opérateurs (+, -, etc.) ni de caractères spéciaux(é, à, ß, ä, ö, ü, etc.).
Si le contenu d'une variable ne change pas tout au long de l'exécution du programme (utilisation d'une valeur fixe), il est préférable d'utiliser une constante.
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 chaînes de caractères. Voici la liste des types natifs supportés:
Nom | Extension | Taille en mémoire | Plage -------------+--------------+-------------------+---------------------------------------------- Byte | .b | 1 octet | -128 à +127 Ascii | .a | 1 octet | 0 à +255 Caractere | .c | 1 octet (ascii) | 0 à +255 Caractere | .c | 2 octets (unicode)| 0 à +65535 Unicode | .u | 2 octets | 0 à +65535 Word | .w | 2 octets | -32768 à +32767 Long | .l | 4 octets | -2147483648 à +2147483647 Integer | .i | 4 octets (32 bits)| -2147483648 à +2147483647 Integer | .i | 8 octets (64 bits)| -9223372036854775808 à +9223372036854775807 Float | .f | 4 octets | illimité (voir ci-dessous) Quad | .q | 8 octets | -9223372036854775808 à +9223372036854775807 Double | .d | 8 octets | illimité (voir ci-dessous) String | .s | longueur string+1 | illimité String Fixe | .s{Longueur} | longueur string | illimité
Types non-signés: Purebasic offre le support natif des types non-signés pour les variables de type 'byte' et 'word' au travers des types 'ascii' (.a) and 'unicode' (.u). Le type 'character'(.c) (qui est un 'byte' non-signé en mode ascii, et un 'word' non-signé en mode unicode) peut aussi être utilisé comme un type non-signé.
Notation des variables chaîne de caractères: Il est possible d'utiliser '$' comme dernier caractère d'une variable pour indiquer qu'il s'agit d'une chaîne de caractères. De cette façon vous pouvez utiliser 'a$' et 'a.s' , ce sont deux variables différentes.
Note: Vous devrez conserver le '$' à la fin de la variable a$, contrairement au '.s' de la variable a.s, qui n'est nécessaire que la première fois pour la déclarer.a.s = "Une chaîne" a$ = "Une autre chaîne" Debug a ; Affichera "Une chaîne" Debug a$ ; Affichera "Une autre chaîne"
Note: Les nombres flottants (Simples ou doubles) peuvent être écrits sous la forme: 123.5e-20valeur.d = 123.5e-20 Debug valeur ; affichera 0.000000000000000001235
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 = (Egal)
Peut être utilisé suivant 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 ; Teste si les valeurs de abc et def sont identiques et utilise le résultat dans la commande If
Opérateur + (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"
Opérateur - (Moins)
Soustrait la valeur de l'expression RHS de la valeur de l'expression LHS. S'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 chaîne.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"
Opérateur * (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"
Opérateur / (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"
Opérateur & (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 chaîne.LHS | RHS |Résultat ------------------ 0 | 0 | 0 0 | 1 | 0 1 | 0 | 0 1 | 1 | 1Exemple:
; La représentation binaire des valeurs est utilisée pour une présentation plus claire et lisible 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"
Opérateur | (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 chaîne.LHS | RHS |Résultat ------------------ 0 | 0 | 0 0 | 1 | 1 1 | 0 | 1 1 | 1 | 1Exemple:
; La représentation binaire des valeurs est utilisée pour une présentation claire et lisible 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"
Opérateur ! (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 chaîne.LHS | RHS |Résultat ------------------ 0 | 0 | 0 0 | 1 | 1 1 | 0 | 1 1 | 1 | 0Exemple:
; La représentation binaire des valeurs est utilisée pour une présentation claire et lisible 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"
Opérateur ~ (NON 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 chaîne.RHS |Résultat ---------- 0 | 1 1 | 0Exemple:
; La représentation binaire des valeurs est utilisée pour une présentation claire et lisible 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ésultat 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 ------------------------- faux | faux | faux faux | vrai | vrai vrai | faux | vrai vrai | vrai | vrai
Operator XOr (OU exclusif 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 | vrai vrai | faux | vrai vrai | vrai | faux
Operator Not (NON logique)
Le résultat de cet opérateur sera la négation de l'expression RHS. Cet opérateur ne fonctionne pas avec les strings.RHS | Résultat ---------------- faux | vrai vrai | faux
Opérateur << (Décalage à gauche)
Décale vers la gauche les bits du nombre LHS de RHS places. Décaler 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.
Opérateur >> (Décalage à droite)
Décale vers la droite les bits du nombre LHS de RHS places. Décaler 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).
Opérateur % (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
--------------------+---------------------
8 (haute) | ~
7 | <<, >>, %, !
6 | |, &
5 | *, /
4 | +, -
3 | >, >=, <, <=, =, <>
2 | Not
1 (basse) | And, Or, XOr
Types structurés
Les types structurés peuvent être définis avec les options propres aux structures. Voyez le chapitre structures pour plus d'informations.
Informations 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.11 ou 0.10999999. 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.
Comme leur nom l'indique, les 'doubles' sont des flottants 'double-precision' (64 bits) comparativement aux flottants 'simple-precision' que sont les floats (32 bits). Donc, pour avoir plus de précision dans la manipulation des nombres à virgule, il est préférable d'utiliser les 'doubles'.
Pour plus d'information sur le format 'IEEE 754', consulter l'article Wikipedia.