Variables, Types et Opérateurs
Déclaration des variables
La déclaration d'une variable en PureBasic se fait en la nommant. Les variables n'ont pas besoin d'être explicitement déclarées et peuvent être utilisées "à la volée".
Vous pouvez également spécifier le type que vous souhaitez pour cette variable. Cependant, par défaut, une variable qui est déclarée sans indiquer son type de façon explicite sera considérée comme étant de type INTEGER.
Le mot clef Define peut être utilisé pour déclarer plusieurs variables sur une même ligne.Exemple
vitesse.q ; Déclare une variable 'vitesse' du type quad (.q). c.l = a*d.w ; 'd' est déclarée ici au milieu d'une expression et elle est de type word (.w) ! Define.b a0, b0 = 10, c0 = b0*2, d0Exemple
Arithmetic.pb
Note: Les noms de variables ne peuvent pas commencer par un chiffre (0, 1, etc.), ne peuvent pas contenir de caractères spéciaux(é, à, ß, ä, ö, ü, etc.) ni d'opérateurs (+, -, etc.).
Note: 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 permet de définir des variables de plusieurs types comme les entiers, des nombres à virgule, des caractères (char) et des chaînes de caractères aussi.
Voici la liste des types natifs supportés:
Nom Extension Encombrement en mémoire PlageByte .b 1 octet -128 à +127 Ascii .a 1 octet 0 à +255 Caractère .c 2 octets (unicode) 0 à +65535 Word .w 2 octets -32768 à +32767 Unicode .u 2 octets 0 à +65535 Long .l 4 octets -2147483648 à +2147483647 Integer .i 4 octets (avec compilateur 32-bit) -2147483648 à +2147483647 Integer .i 8 octets (avec compilateur 64-bit) -9223372036854775808 à +9223372036854775807 Float .f 4 octets Environ ±1.175494e-38 à ±3.402823e+38, 6 Chiffres significatifs (voir tout en bas) Quad .q 8 octets -9223372036854775808 à +9223372036854775807 Double .d 8 octets Environ ±2.2250738585072013e-308 à ±1.7976931348623157e+308, 15 Chiffres significatifs (voir tout en bas) String .s longueur de la chaine + 1 illimité String Fixe .s{Longueur} longueur de la chaine illimité
> Types non-signés (.a, .u et .c):
Purebasic offre des types non-signés pour les variables de type 'byte' et 'word' au travers des types 'ascii' (.a) et 'unicode' (.u).
Le type 'character'(.c) est 'word' non-signé en mode unicode.
> Notation des variables de type chaîne de caractères ($ et .s): Généralement une chaîne de caractère se définie avec le type '.s' mais 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' qui sont alors deux variables différentes.
Vous devrez conserver le '$' à la fin de la variable a$ contrairement au '.s' de la variable a.s qui n'est nécessaire que pour sa déclaration.a.s = "Une chaîne" a$ = "Une autre chaîne" Debug a ; Affichera "Une chaîne" Debug a$ ; Affichera "Une autre chaîne"> Notation scientifique exponentielle (Ae+-B): Les nombres à virgules (Float ou Double) peuvent être écrits sous la forme exponentielle:valeur.d = 123.5e-20 Debug valeur ; affichera 0.000000000000000001235Opé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 de l'équation.
RHS = Right Hand Side ou partie droite de l'équation.
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 renvoyé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.
Avec les chaînes, '=' est utilisé aussi bien pour affecter une chaîne que pour comparer deux chaînes.
Note: La comparaison entre deux chaînes est sensible à la casse.
Exemple:
a$ = b$ ; Affecte le contenu de la chaîne "b$" à la chaîne "a$"
If a$ = b$ ; Teste si les chaînes a$ et b$ sont identiques. +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 affecte le résultat à "nombre"
variable+expression ; La valeur de "expression" est directement ajoutée à "variable"
Avec les chaînes, '+' permet aussi de combiner le contenu de deux chaînes, le résultat sera affecté à la chaîne à gauche de l'opérateur '=' ou sera directement affecté à la chaîne de gauche. Les valeurs numériques sont également acceptées combiné avec une chaîne. Cela se comporte comme Str, StrF ou StrD avec leurs valeurs par défaut dans les paramètres optionnels.
Example:
a$ = b$ + " plus" ; Combine le contenu de la chaîne "b$" avec la chaîne " plus" et affecte le tout à la chaîne "a$"
a$ + b$ ; Ajoute le contenu de la chaîne b$ directement à la chaîne a$.
a$ = b$ + 123 ; Ici le 123 sera concaténé en tant que chaîne de caractères.
-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 le résultat est affecté à "var".
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 le résultat est affecté à "quantite"
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.
Exemple:
LHS
RHS
Résultat
0
0
0
0
1
0
1
0
0
1
1
1
; 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 %0000, soit 0
b.w = %1100 & %1010 ; Le résutlat sera %1000, soit 1*2^4 + 0*2^2 + 0*2^1 + 0*2^0 = 8
bits = a & b ; Effectue un ET bit à bit entre a et b et le résultat est affecté à "bits"
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.
Exemple:
LHS
RHS
Résultat
0
0
0
0
1
1
1
0
1
1
1
1
; 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, soit 1*2^4 + 1*2^2 + 0*2^1 + 1*2^0 = 13
b.w = %1100 | %1010 ; Le résultat sera %1110, soit 14
bits = a | b ; Effectue un OU bit à bit entre a et b et place le résultat directement dans la variable "bits"
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.
Exemple:
LHS
RHS
Résultat
0
0
0
0
1
1
1
0
1
1
1
0
; 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, soit 1*2^4 + 1*2^2 + 0*2^1 + 1*2^0 = 13
b.w = %1100 ! %1010 ; Le résultat sera %0110, soit 6
bits = a ! b ; Effectue un OU Exclusif bit à bit entre a et b et place le résultat dans "bits"
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.
Exemple:
RHS
Résultat
0
1
1
0
; La représentation binaire des valeurs est utilisée pour une présentation claire et lisible
a.b = ~%1000 ; En théorie le résultat sera %0111 mais en réalité il sera %11110111 (= -9 car le 'byte' est signé)
b.b = ~%1010 ; En théorie le résultat sera %0101 mais en réalité il sera %11110101 (= -11 car le 'byte' est signé)
c.b = ~%0000 ; Le résultat sera %11111111, soit -1 car c'est un nombre signé
d.a=%11111111
e.a=~d ; Affiche 0 car c'est un nombre non signé
()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.
Exemple:
If a < b ; Teste si la valeur de a est plus petite que la valeur de b, et utilise le résultat dans la commande If
Note: La comparaison entre deux chaînes est sensible à la casse. >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.
Exemple:
If a > b ; Teste si la valeur de a est plus grande que la valeur de b, et utilise le résultat dans la commande If
Note: La comparaison entre deux chaînes est sensible à la casse. <=
=<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.
AndET 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
OrOU 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
XOrOU 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. Cet opérateur ne peut pas être utilisé avec des chaînes de caractères.
LHS
RHS
Résultat
Faux
Faux
Faux
Faux
Vrai
Vrai
Vrai
Faux
Vrai
Vrai
Vrai
Faux
NotNOTLe 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
<<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=112)
c.l=$80000000 << 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. 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).
%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)
Opérateurs raccourcis
Tous les opérateurs mathématiques peuvent être utilisés sous une forme abrégée.Exemple
Valeur + 1 ; Equivaut à : Valeur = Valeur + 1 Valeur * 2 ; Equivaut à : Valeur = Valeur * 2 Valeur << 1 ; Equivaut à : Valeur = Valeur << 1Note: Cela peut conduire à des résultats "imprévus" dans quelques rares cas, si l'assignement est modifiée avant l'affection.Exemple
Dim MonTableau(10) MonTableau(Random(10)) + 1 ; Equivaut à: MonTableau(Random(10)) = MonTableau(Random(10)) + 1, mais ici Random() ne renverra pas la même valeur à chaque appel.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.Types Pointeur
Les pointeurs sont déclarés avec un '*' devant le nom de la variable. Plus d'informations peuvent être trouvées dans le chapitre pointeurs.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-bit) comparativement aux flottants 'simple-precision' que sont les floats (32-bit). Donc, pour avoir plus de précision dans la manipulation des nombres à virgule, il est préférable d'utiliser les 'doubles'.
Float : De +- 1.175494e-38 à +- 3.402823e+38
Double: De +-; 2.2250738585072013e-308 à +- 1.7976931348623157e+308
Pour plus d'information sur le format 'IEEE 754', consulter l'article Wikipedia.Exemple
a.f=0.1 b.f=0.5 c.f=0.9 Debug a ; Affiche 0.10000000149012 Debug b ; Affiche 0.5 Debug c ; Affiche 0.89999997615814