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 integer (.i) !
  Define.b a0, b0 = 10, c0 = b0*2, d0 

Exemple

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
Plage
Byte .b 1 octet -128 à +127
Ascii .a 1 octet 0 à +255
Caractère .c 1 octet (en mode ascii et seulement avec les compilateurs 5.4x et antérieurs) 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.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 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.

LHS

RHS

 

Résultat

0

0

 

0

0

1

 

0

1

0

 

0

1

1

 

1

Exemple:
; 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.

LHS

RHS

 

Résultat

0

0

 

0

0

1

 

1

1

0

 

1

1

1

 

1

Exemple:
; 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.

LHS

RHS

 

Résultat

0

0

 

0

0

1

 

1

1

0

 

1

1

1

 

0

Exemple:
; 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.

RHS

 

Résultat

0

 

1

1

 

0

Exemple:
; 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.
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

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. 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

Not
NOTLe 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 << 1
Note: 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