PureBasic • Les Variables de type .b

Page 1 sur 2

Les Variables de type .b

Publié : dim. 03/déc./2023 18:51

par Shadow

Coucou,

Petit exercice que j'ai fais, perso j'ai rien compris et Bing non plus (Ce code ne donne rien du tout)

Code : Tout sélectionner

For I.b = 0 To 255
  If I.b
    Debug Str(I.b) + " #True"
  Else
    Debug Str(I.b) + " #False"
  EndIf
Next

BING:
Le code que vous avez fourni devrait normalement afficher une série de messages dans la console de débogage de PureBasic. Cependant, si vous n’obtenez aucun affichage, cela pourrait être dû à plusieurs raisons :

La console de débogage n’est pas activée : Assurez-vous que la console de débogage est activée dans votre environnement de développement PureBasic pour voir les messages Debug.

Erreur dans le code : Vérifiez s’il y a des erreurs de syntaxe ou d’autres erreurs dans le code qui pourraient empêcher son exécution.

Configuration de l’environnement : Il se peut que la configuration de votre environnement de développement PureBasic ne soit pas correctement définie pour afficher les sorties de débogage.

Version de PureBasic : Assurez-vous que vous utilisez une version de PureBasic qui prend en charge les fonctionnalités utilisées dans le code.

Voici le comportement attendu du code que vous avez fourni :

Pour I.b = 0, le code devrait afficher 0 #False.
Pour toutes les autres valeurs de I.b de 1 à 255, le code devrait afficher la valeur de I.b suivie de #True.
Si vous avez suivi toutes ces étapes et que le problème persiste, je vous recommande de consulter la documentation de PureBasic ou de demander de l’aide sur les forums de PureBasic pour obtenir une assistance plus détaillée.

Re: Les Variables de type .b

Publié : dim. 03/déc./2023 18:52

par Shadow

Autre test:

Code : Tout sélectionner

For I.b = -128 To 255
  If I.b
    Debug Str(I.b) + " #True"
  Else
    Debug Str(I.b) + " #False"
  EndIf
Next

Affiche que des #True

Re: Les Variables de type .b

Publié : dim. 03/déc./2023 18:56

par Shadow

BING:
Oui, je comprends parfaitement. En PureBasic, comme dans de nombreux autres langages de programmation, toute valeur numérique autre que 0 est évaluée comme vraie (True) dans une condition If. La valeur 0 est la seule valeur évaluée comme fausse (False). Donc, dans votre boucle For, chaque fois que I.b est différent de 0, la condition If I.b sera évaluée comme vraie et affichera “Vraie”. Lorsque I.b est égal à 0, la condition sera évaluée comme fausse et affichera “Faux”. Voici un exemple simplifié pour illustrer ce comportement :

Code : Tout sélectionner

If 0
  Debug "Ceci n'est pas affiché car 0 est Faux."
EndIf

If 1
  Debug "Ceci est affiché car 1 est Vrai."
EndIf

Dans cet exemple, seul le message “Ceci est affiché car 1 est Vrai.” sera affiché dans la console de débogage.

Re: Les Variables de type .b

Publié : dim. 03/déc./2023 19:00

par Shadow

N'y à t-il pas un soucis donc ici ?:

Code : Tout sélectionner

For I.b = -128 To 255
  If I.b
    Debug Str(I.b) + " #True"
  Else
    Debug Str(I.b) + " #False"
  EndIf
Next

Pourquoi il va de -128 à -1 et qu'il continue pas ?

0
1
2
3
4
5
6...

Re: Les Variables de type .b

Publié : dim. 03/déc./2023 19:59

par Shadow

je pense que je sais ce qui coince:

Code : Tout sélectionner

For I.b = 0 To 255
  If I.b
    Debug Str(I.b) + " #True"
  Else
    Debug Str(I.b) + " #False"
  EndIf
Next

La boucle For augmente toujours de 1 la valeur de la variable, donc +1, pour que ça face -1 il faut le stipuler avec un Step -1.
En faite ici je pense qu'il considère 255 comme -1, donc:

0 en début de boucle et -1 en sortie, donc la boucle ne peu pas entré car elle ne peu pas appliquer +1 a la variable car 0 + 1 = 1 alors que la sortie est a -1, c'est comme écrire:

Code : Tout sélectionner

For I.b = 0 To -1
  If I.b
    Debug Str(I.b) + " #True"
  Else
    Debug Str(I.b) + " #False"
  EndIf
Next

Ou écrire:

Code : Tout sélectionner

For I.b = 1 To -1
  If I.b
    Debug Str(I.b) + " #True"
  Else
    Debug Str(I.b) + " #False"
  EndIf
Next

Ou même:

Code : Tout sélectionner

For I.b = 10 To -1
  If I.b
    Debug Str(I.b) + " #True"
  Else
    Debug Str(I.b) + " #False"
  EndIf
Next

En faite la boucle For a une condition caché, si le nombre à augmenter (ici la variable i.b) est inférieur ou égale au nombre de sortie, ici -1, alors la condition est bonne, sinon elle ne fonctionne pas.

Ici dans les exemples que j'ai donnés:

0 to 255 qui vaut en faite 0 et -1 car la variable est de type .b donc Byte.
La condition n'est pas remplie, la boucle n'entre même pas.

Ensuite: 0 to -1, 1 to -1 ou 10 to -1, c'est pareille, la boucle ne peu pas s'enclencher
parce que le nombre de dépar ici 0, 1 ou 10 est supérieur à -1 en sortie.

---------------------------------

Votre analyse de la boucle For en PureBasic est intéressante. En effet, la boucle For a une condition implicite qui détermine si la boucle doit s’exécuter ou non. Si la valeur de départ est supérieure à la valeur de fin et qu’aucun pas négatif (Step -1) n’est spécifié, la boucle ne s’exécutera pas.

Dans le cas de For I.b = 0 To 255, la variable I.b est de type byte et peut stocker des valeurs de -128 à +127. Lorsque vous essayez de définir I.b à 255, cela provoque un dépassement de capacité, et I.b est interprété comme -1 en raison de la représentation en complément à deux des nombres signés en informatique.

La boucle For ne s’exécute pas car la condition implicite n’est pas remplie : la valeur de départ (0) est inférieure à la valeur de fin (-1 après dépassement de capacité), mais comme aucun Step n’est spécifié, la boucle ne peut pas progresser de manière décroissante.

Pour que la boucle s’exécute correctement avec des valeurs de type byte, vous devriez utiliser une valeur de fin qui est dans la plage valide du type byte, par exemple:

Code : Tout sélectionner

For I.b = 0 To 127
  If I.b
    Debug Str(I.b) + " #True"
  Else
    Debug Str(I.b) + " #False"
  EndIf
Next

Le résultat de ce code sera donc:

; 0 #False
; 1 #True
; 2 #True
; 3 #True
; 4 #True
; 5 #True
; 6 #True
; 7 #True
; 8 #True
; 9 #True
; 10 #True
; 11 #True
; 12 #True
; 13 #True
; 14 #True
; 15 #True
; 16 #True
; 17 #True
; 18 #True
; 19 #True
; 20 #True
; 21 #True
; 22 #True
; 23 #True
; 24 #True
; 25 #True
; 26 #True
; 27 #True
; 28 #True
; 29 #True
; 30 #True
; 31 #True
; 32 #True
; 33 #True
; 34 #True
; 35 #True
; 36 #True
; 37 #True
; 38 #True
; 39 #True
; 40 #True
; 41 #True
; 42 #True
; 43 #True
; 44 #True
; 45 #True
; 46 #True
; 47 #True
; 48 #True
; 49 #True
; 50 #True
; 51 #True
; 52 #True
; 53 #True
; 54 #True
; 55 #True
; 56 #True
; 57 #True
; 58 #True
; 59 #True
; 60 #True
; 61 #True
; 62 #True
; 63 #True
; 64 #True
; 65 #True
; 66 #True
; 67 #True
; 68 #True
; 69 #True
; 70 #True
; 71 #True
; 72 #True
; 73 #True
; 74 #True
; 75 #True
; 76 #True
; 77 #True
; 78 #True
; 79 #True
; 80 #True
; 81 #True
; 82 #True
; 83 #True
; 84 #True
; 85 #True
; 86 #True
; 87 #True
; 88 #True
; 89 #True
; 90 #True
; 91 #True
; 92 #True
; 93 #True
; 94 #True
; 95 #True
; 96 #True
; 97 #True
; 98 #True
; 99 #True
; 100 #True
; 101 #True
; 102 #True
; 103 #True
; 104 #True
; 105 #True
; 106 #True
; 107 #True
; 108 #True
; 109 #True
; 110 #True
; 111 #True
; 112 #True
; 113 #True
; 114 #True
; 115 #True
; 116 #True
; 117 #True
; 118 #True
; 119 #True
; 120 #True
; 121 #True
; 122 #True
; 123 #True
; 124 #True
; 125 #True
; 126 #True
; 127 #True

Re: Les Variables de type .b

Publié : dim. 03/déc./2023 20:04

par Shadow

Pour répondre au premier problème:

Code : Tout sélectionner

For I.b = -128 To 255
  If I.b
    Debug Str(I.b) + " #True"
  Else
    Debug Str(I.b) + " #False"
  EndIf
Next

Ici la condition est donc de -128 à -1 car 255 est un dépassement de capacite de la variable I.b, donc c'est comme écrire:

Code : Tout sélectionner

For I.b = -128 To -1
  If I.b
    Debug Str(I.b) + " #True"
  Else
    Debug Str(I.b) + " #False"
  EndIf
Next

La boucle fonctionne, elle va appliquer +1 à chaque cycle donc: -128 + 1 = -127, ensuite -127 + 1 = -126... etc, -1 + 1 = 0 = Stop = ne fais rien !
Par contre si on avais fait:

Code : Tout sélectionner

For I.b = -128 To 127
  If I.b
    Debug Str(I.b) + " #True"
  Else
    Debug Str(I.b) + " #False"
  EndIf
Next

Alors le résultat aurais été celui attendus:

-128 #True
-127 #True
-126 #True
-125 #True
-124 #True
-123 #True
-122 #True
-121 #True
-120 #True
-119 #True
-118 #True
-117 #True
-116 #True
-115 #True
-114 #True
-113 #True
-112 #True
-111 #True
-110 #True
-109 #True
-108 #True
-107 #True
-106 #True
-105 #True
-104 #True
-103 #True
-102 #True
-101 #True
-100 #True
-99 #True
-98 #True
-97 #True
-96 #True
-95 #True
-94 #True
-93 #True
-92 #True
-91 #True
-90 #True
-89 #True
-88 #True
-87 #True
-86 #True
-85 #True
-84 #True
-83 #True
-82 #True
-81 #True
-80 #True
-79 #True
-78 #True
-77 #True
-76 #True
-75 #True
-74 #True
-73 #True
-72 #True
-71 #True
-70 #True
-69 #True
-68 #True
-67 #True
-66 #True
-65 #True
-64 #True
-63 #True
-62 #True
-61 #True
-60 #True
-59 #True
-58 #True
-57 #True
-56 #True
-55 #True
-54 #True
-53 #True
-52 #True
-51 #True
-50 #True
-49 #True
-48 #True
-47 #True
-46 #True
-45 #True
-44 #True
-43 #True
-42 #True
-41 #True
-40 #True
-39 #True
-38 #True
-37 #True
-36 #True
-35 #True
-34 #True
-33 #True
-32 #True
-31 #True
-30 #True
-29 #True
-28 #True
-27 #True
-26 #True
-25 #True
-24 #True
-23 #True
-22 #True
-21 #True
-20 #True
-19 #True
-18 #True
-17 #True
-16 #True
-15 #True
-14 #True
-13 #True
-12 #True
-11 #True
-10 #True
-9 #True
-8 #True
-7 #True
-6 #True
-5 #True
-4 #True
-3 #True
-2 #True
-1 #True
0 #False
1 #True
2 #True
3 #True
4 #True
5 #True
6 #True
7 #True
8 #True
9 #True
10 #True
11 #True
12 #True
13 #True
14 #True
15 #True
16 #True
17 #True
18 #True
19 #True
20 #True
21 #True
22 #True
23 #True
24 #True
25 #True
26 #True
27 #True
28 #True
29 #True
30 #True
31 #True
32 #True
33 #True
34 #True
35 #True
36 #True
37 #True
38 #True
39 #True
40 #True
41 #True
42 #True
43 #True
44 #True
45 #True
46 #True
47 #True
48 #True
49 #True
50 #True
51 #True
52 #True
53 #True
54 #True
55 #True
56 #True
57 #True
58 #True
59 #True
60 #True
61 #True
62 #True
63 #True
64 #True
65 #True
66 #True
67 #True
68 #True
69 #True
70 #True
71 #True
72 #True
73 #True
74 #True
75 #True
76 #True
77 #True
78 #True
79 #True
80 #True
81 #True
82 #True
83 #True
84 #True
85 #True
86 #True
87 #True
88 #True
89 #True
90 #True
91 #True
92 #True
93 #True
94 #True
95 #True
96 #True
97 #True
98 #True
99 #True
100 #True
101 #True
102 #True
103 #True
104 #True
105 #True
106 #True
107 #True
108 #True
109 #True
110 #True
111 #True
112 #True
113 #True
114 #True
115 #True
116 #True
117 #True
118 #True
119 #True
120 #True
121 #True
122 #True
123 #True
124 #True
125 #True
126 #True
127 #True

Re: Les Variables de type .b

Publié : dim. 03/déc./2023 20:10

par Shadow

Ici seul 0 Vaud donc False.

Re: Les Variables de type .b

Publié : dim. 03/déc./2023 21:17

par Ar-S

Un byte est composé de 8 bits, ce qui donne 2^8 = 256 valeurs uniques pour un byte non signé. Avec un byte signé, le bit le plus à gauche est utilisé pour indiquer le signe, ce qui divise la plage de valeurs en deux parties égales, réservant une partie pour les nombres négatifs et l'autre pour les nombres positifs. Cela donne une plage de -128 à 127, avec 0 compté comme une valeur positive.

La différence entre un byte signé et un byte non signé réside dans la façon dont ces valeurs sont interprétées.

Un byte non signé (unsigned byte) utilise les 8 bits pour représenter des nombres entiers positifs uniquement. Cela signifie que la plage de valeurs d'un byte non signé va de 0 à 255. Chaque combinaison binaire de 8 bits est interprétée comme un nombre positif, et le bit le plus à gauche n'est pas utilisé pour représenter le signe.

D'un autre côté, un byte signé (signed byte) réserve l'un des bits pour représenter le signe. Sur les 8 bits d'un byte signé, 7 bits sont utilisés pour représenter la valeur numérique et le bit restant indique le signe du nombre. Par conséquent, la plage de valeurs pour un byte signé va de -128 à 127. Le bit le plus à gauche est utilisé comme bit de signe (0 pour positif, 1 pour négatif) et les 7 bits restants représentent la magnitude du nombre.

En résumé, un byte non signé peut représenter des entiers positifs de 0 à 255, tandis qu'un byte signé peut représenter à la fois des entiers positifs et négatifs dans la plage de -128 à 127.
(#Résumé par chatGPT)

Re: Les Variables de type .b

Publié : mer. 06/déc./2023 21:00

par Ollivier

Stop watching video [...] (résumé anonyme)

Re: Les Variables de type .b

Publié : dim. 10/déc./2023 11:18

par Shadow

Salut,

Au faite Merci Ar-S ou ChatGPT lol.
Quand à la réponse de Ollivier, rien compris.

Re: Les Variables de type .b

Publié : mer. 20/déc./2023 5:31

par boddhi

@Shadow

1) Comme l'évoquait Ar-S avec les nombres signés/non signés et sans trop entrer dans les détails, il faut aussi comprendre que PB ne génère pas d'erreur d'overflow (dépassement de limites) dans l'assignation de valeurs aux variables. Dans une telle situation, il réinitialise les valeurs quand elles dépassent celles "autorisées" par le typage défini (quel qu'il soit, pas seulement b).

2) Quant à l'instruction For, il faut, pour comprendre son fonctionnement, garder à l'esprit qu'au moment de la compilation elle est traduite en
"For Valeur=X To Valeur=Y" donc avec typage b, cela donne : "For Valeur1.b=X To Valeur1.b=Y" et, de là, tenir absolument compte du point 1.

Quelques exemples permettant de mieux comprendre le comportement de la boucle For au regard des valeurs qui lui sont passées en arguments :

Code : Tout sélectionner

; Type de -128 à 127 (Plage 256 valeurs)
Debug "Exemple 1 : de -128 à 127"
i.b =-255  : Debug "-255 : "+i
i   =-254  : Debug "-254 : "+i
i   =-128  : Debug "-128 : "+i
i   =127   : Debug " 127 : "+i
i   =128   : Debug " 128 : "+i
i   =255   : Debug " 255 : "+i
i   =256   : Debug " 256 : "+i
Debug "Exemple 2 : de 0 à 255"
; Type de 0 à 255 (Plage 256 valeurs)
j.a =-2    : Debug " -2 : "+j
j   =-1    : Debug " -1 : "+j
j   =256   : Debug "256 : "+j
j   =257   : Debug "257 : "+j
Debug "----------------------------"
Debug "1e boucle qui ne fonctionne pas"
For i= -255 To 256 ; Boucle qui ne fonctionne pas car -255 équivaut à 0 et 256 équivaut à -1 en typage b : Donc ça revient à écrire : For i=0 To -1
  Debug i          ; alors qu'on pourrait s'attendre à ce qu'elle fonctionne de -128 à 127
Next
Debug "2e boucle qui fonctionne partiellement"
For i= -255 To 127 ; Boucle qui fonctionne partiellement mais commence seulement à 1 car -255 équivaut à 1 en typage b : Donc ça revient à écrire : For i=1 To 127
  Debug i          ; alors qu'on pourrait s'attendre à ce qu'elle fonctionne de -128 à 127
Next
Debug "3e boucle qui fonctionne partiellement"
For i= -128 To 255 ; Boucle qui fonctionne partiellement et s'arrête à -1 car 255 équivaut à -1 en typage b : Donc ça revient à écrire : For i=-128 To -1
  Debug i          ; alors qu'on pourrait s'attendre à ce qu'elle fonctionne jusqu'à 127
Next
Debug "4e boucle qui ne fonctionne pas"
For i=0 To 255    ; Boucle qui ne fonctionne pas car 255 équivaut à -1 en typage b : Donc ça revient à écrire : For i=0 To -1
  Debug i         ; alors qu'on pourrait s'attendre à ce qu'elle fonctionne de 0 à 127
Next

Re: Les Variables de type .b

Publié : mer. 20/déc./2023 8:19

par Mindphazer

Juste une précision : tes boucles

Code : Tout sélectionner

For i... Next

ne fonctionnent pas correctement car tu as défini i en .b juste au dessus...
Si tu remplaces

Code : Tout sélectionner

For i =

par

Code : Tout sélectionner

For k =

par exemple, vu que k n'est pas défini au préalable, le compilateur l'assigne en integer par défaut (.i), et la boucle affiche des valeurs correctes

Re: Les Variables de type .b

Publié : mer. 20/déc./2023 14:32

par threedslider

Shadow a écrit : dim. 10/déc./2023 11:18 Quand à la réponse de Ollivier, rien compris.

Je crois il prend du pop corn en voyant vos réponse

Re: Les Variables de type .b

Publié : mer. 20/déc./2023 15:28

par SPH

threedslider a écrit : mer. 20/déc./2023 14:32 Je crois il prend du pop corn en voyant vos réponse

Ou alors, il part de très très bas en informatique...

Re: Les Variables de type .b

Publié : sam. 23/déc./2023 18:19

par Shadow

Merci boddhi pour t'es explications, effectivement tu as raison je crois bien.
Par contre ton exemple ne fonctionne pas du tous avec PB 6.00. et d'ailleurs tous court.

PB affiche un message qui dis que tu ne peu pas faire de dépassement de capacité directe comme écris.
Mais par contre en court d'exécution on peu le faire !

De plus t'es boucle "for" sont fausse car tu utilise une variable séparer qui est de type integer donc ici tous va bien lol.
Spécifie le type .b à t'es variable dans t'es boucle si tu veux que sa marche