Les tableaux

[Anonyme2]

2 choses qui ne vont pas (peut-être déjà signalé, je n'en sait rien)

Le premier, on dimensionne un tableau à 3 éléments et en fait le tableau en a 4.

Code : Tout sélectionner

Structure MonEssai
  Element1.l
  Element2.l
EndStructure


Dim Variable.MonEssai(3) ; Tableau à 3 éléments de de type MonEssai

;on rempli avec des valeurs quelquonques

For i=0 To 2
   Variable(i)\Element1 = 2*i
   Variable(i)\Element2 = 5*i
Next i

For i=0 To 3
   Debug "Variable("+Str(i)+")\Element1 = "+ Str(Variable(i)\Element1)
   Debug "Variable("+Str(i)+")\Element2 = "+ Str(Variable(i)\Element2)
   Debug ""
Next i

Le deuxième , ça ne marche pas avec des pointeurs dans la structure

Code : Tout sélectionner

Structure MonEssai1
  Element1.l
  Element2.l
  *ElementSuivant.l
EndStructure

Dim Variable1.MonEssai1(3) ; Tableau à 3 éléments de de type MonEssai1

; on rempli avec des valeurs quelquonques

 For i=0 To 2
    Variable1(i)\Element1 = 2*i
    Variable1(i)\Element2 = 5*i
    Variable1(i)\*ElementSuivant = 0
 Next i
 
 For i=0 To 2
    Debug "Variable1("+Str(i)+")\Element1 = "+ Str(Variable1(i)\Element1)
    Debug "Variable1("+Str(i)+")\Element2 = "+ Str(Variable1(i)\Element2)
    Debug "Variable1("+Str(i)+")\*ElementSuivant = "+ Str(Variable1(i)\*ElementSuivant)
    Debug ""
 Next i
 

[nico]

Pour les pointeurs, il n'y a pas d'erreur inconnue, j'en avais fait la remarque à Fred et il avait expliqué que c'était un bug du compilateur.

Pour accéder aux pointeurs dans une structure il faut supprimer l'étoile devant le nom comme chacun sait.

[Anonyme2]

Oui c'est bien un bug,

Je l'ai découvert aujourd'hui pour les tableaux et il y a quelques mois pour les listes chainées.

Pour accéder aux pointeurs dans une structure il faut supprimer l'étoile devant le nom comme chacun sait.

C'est pas suffisant de supprimer l'étoile.

Un pointeur occupera 4 octets dans la structure, quelque soit le type sur lequel il pointe
Struc\*Pt.b occupe autant de mémoire que Struc\*Pt.l
Dans le 1er cas il faut supprimer l'étoile et changer le type en long sinon ça marchera pas

[nico]

Non Denis, un pointeur contenant une adresse sur 32 bits sera donc toujours définit sur 4 Octets (je sais que tu sais). La déclaration du type de pointeur est différent de celle des variables. Pour déclarer un type de pointeur, il faut lui associer une structure.

En résumé: *pointeur.w l'écriture est fausse car le pointeur est implicitemet déclaré de type long et ne sert pas pour la déclaration du type.
*pointeur.word l'écriture est bonne, ici le pointeur est associé à une structure.

[Anonyme2]

J'ai pas testé si c'est vraiment déclaré long dans le cas des structures ou tableau même si tu laisse le type byte

Je vais regarder demain.

Merci Nico de l'info

[nico]

Comme je te l'ai indiqué, cela n'a aucun effet et n'a aucun sens pour le pointeur.

[filperj]

Le premier, on dimensionne un tableau à 3 éléments et en fait le tableau en a 4.

C'est le comportement standart en basic:

Code : Tout sélectionner

Dim Tableau(n); le tableau a n+1 éléments numérotés de 0 à n
Dim Tableau(0); le tableau a 1 élément

Le problème, c'est que PB n'a pas de "UnDim"...

[filperj]

Et je suis d'accord avec Nico, "*Pointeur.l" n'a pas de sens parceque ".l" n'est pas une structure.
Ça devrai être considéré comme une erreur de synthaxe.

[Anonyme2]

Le premier, on dimensionne un tableau à 3 éléments et en fait le tableau en a 4.

C'est le comportement standart en basic:

Code : Tout sélectionner

Dim Tableau(n); le tableau a n+1 éléments numérotés de 0 à n
Dim Tableau(0); le tableau a 1 élément

Le problème, c'est que PB n'a pas de "UnDim"...

J'ai fait du basic il y a longtemps mais je ne me souviens pas si c'était ou non comme ça.

Si c'est pas un bug, c'est à préciser dans la doc.

[Anonyme2]

En résumé: *pointeur.w l'écriture est fausse car le pointeur est implicitemet déclaré de type long et ne sert pas pour la déclaration du type.
*pointeur.word l'écriture est bonne, ici le pointeur est associé à une structure.

Après avoir réfléchi, je ne partage pas ton avis Nico

Pour moi (mais je me trompe peut-être) *pointeur.w est parfaitement valide et défini un espace mémoire de 4 octets (32 bits) qui stockera l'adresse d'un élément de 2 octets.

C'est au compilateur de vérifier lorsque l'on utilise le pointeur, si on charge bien un valeur sur 16 bits. Le type ne sert qu'à cela en fin de compte

La doc PB indique que les pointeurs sont utilisés généralement avec les structutres. Mais la doc ne dit pas que les pointeurs ne s'utilisent qu'avec les structures. Et heureusement.

Sur le fond, *pt.b et *pt. byte fond la même chose (voir le code asm généré par PB). Alors pourquoi se limiter uniquement aux structures ?

Ce n'est que trop limitatif.

Regarde ces quelques exemples

Celui-ci est Ok

Code : Tout sélectionner

 *pt.b = 3
  
;  1er exemple 
 s.b = *pt
  Debug s

Le 2eme donne une erreur du compilateur, ce qui est normal,
le type est donc bien pris en compte

Code : Tout sélectionner

;  2eme exemple 
 *pt2.s = "25"
  s.b = *pt2
 
 Debug s

 

La le compilateur est permissif
On récupère bien l'octet de poids faible, le type est donc bien pris en compte

Code : Tout sélectionner

 ; 3eme exemple 
  *pt3.l = 8000
  s.b = *pt3
  
  Debug s

[nico]

Manifestement, pour moi, tu as une incompréhension sur l'utilisation des pointeurs et ne voit aucun mal dans mes propos; moi-même je m'y perd aussi comme le montre un de mes derniers posts.

D'abord je reprend ton premier exemple.

Code : Tout sélectionner

 *pt.b = 3 
  
;  1er exemple 
 s.b = *pt 
  Debug s

Il faut savoir avant d'utiliser un pointeur qu'il faut l'initialiser. C'est à dire lui assigner une adresse afin de pouvoir lire ou écrire dans cette adresse.
Cette adresse pouvant être l'adresse d'une structure,d'une varible,d'un tableau etc....

Dans ton exemple, tu donne l'adresse 3 à ton pointeur alors que normalement tu devrais lui assigner une adresse de variable par exemple.
Bien que l'on puisse l'accepter dans ce cas, dans les exemples qui vont suivrent, cela n'a plus aucun sens.


Ton deuxième exemple:

Code : Tout sélectionner

;  2eme exemple 
 *pt2.s = "25" 
  s.b = *pt2 
  
 Debug s 

Voilà maintenant que tu assignes une chaine à un pointeur comme adresse, chose aberrante.
Pour reprendre ton exemple, tu aurais du l'écrire ainsi:

Code : Tout sélectionner

;  2eme exemple 
chaine.s="pure"
*pt2 = @chaine 
Debug PeekS(*pt2)
s.b = *pt2 
; ici s va récupérer l'octet de poid faible
; de l'adresse contenu dans *pt2
Debug s

Bien entendu j'ai supprimé le ".s" du pointeur car normal ou pas le type d'un pointeur ne se définit pas de cette façon avec Pure.

La doc PB indique que les pointeurs sont utilisés généralement avec les structutres. Mais la doc ne dit pas que les pointeurs ne s'utilisent qu'avec les structures. Et heureusement.

Rien ne t'oblige à utiliser les pointeurs avec les stuctures.
exemple: *pointeur -->ici le pointeur est non typé et peut pointer vers n'importe quelle variable simple ou structurelle.

Mais de toute façon que le pointeur soit typé ou non, il peut pointer vers ce qu'il veut; c'est ainsi avec Pure.

[Backup]

J'ai fait du basic il y a longtemps mais je ne me souviens pas si c'était ou non comme ça.

pour les tableaux , il me semble qu'avant (dans les ancien basic)
on utilisai "option base (0 ou 1)
pour specifier si l'on part de zero ou de l'indice 1
en pure par defaut c'est bien de zero (qui compte comme un element du tableau )

donc dim (3) fait bien 4 elements dans le tableau (de 0 a 3 )

[nico]

On dirait qu'un mot de huit bits peut contenir 256 valeurs donc de 0 à 255

De la même façon, la déclaration d'un tableau devrait être:

Dim tableau(Nb d'éléments)
dim a$(5) contient 5 éléments de a$(0) à a$(4), cela fonctionne comme cela en C et je trouve cela perturbant d'écrire 5 et d'avoir 6 éléments au final.

Pour en revenir au pointeur, c'est vrai que le compilateur permet d'écrire plusieurs choses incorrectes dont un gros problème que le Dr Dri a signalé sur les structures.

[Backup]

c'est pourquoi "optionbase" avait ete inventé !!

mais lorsque tu dit :

On dirait qu'un mot de huit bits peut contenir 256 valeurs donc de 0 à 255

je suis pas tout a fait d'accord mem si je comprent ton resonement !

car pour un tableau il sagit d'indice d'emplacement memoire , pas d'une valeur !!

apres avoir crée les cases memoire du tableau tu leur donne un indice pour les reperer
Fred a choisi de partir de zero , c'est un choix
je pense qu'une otion base serai bienvenu , car permetrais a chacun de choisir son style de tableau !!


ps :
optionbase 1
dim (5)
fait partir le tableau de l'indice 1 a 5 (5 elements)
optionbase 0
dim(5)
fait partir le tableau de l'indice 0 a 5 ; comme pour le pure (6 elements ) !!

c'est donc a priori different du C

[Anonyme2]

Manifestement, pour moi, tu as une incompréhension sur l'utilisation des pointeurs et ne voit aucun mal dans mes propos; moi-même je m'y perd aussi comme le montre un de mes derniers posts.

D'abord je reprend ton premier exemple.

Code : Tout sélectionner

 *pt.b = 3 
  
;  1er exemple 
 s.b = *pt 
  Debug s

Il faut savoir avant d'utiliser un pointeur qu'il faut l'initialiser. C'est à dire lui assigner une adresse afin de pouvoir lire ou écrire dans cette adresse.
Cette adresse pouvant être l'adresse d'une structure,d'une varible,d'un tableau etc....

Peut que j'ai une incompréhension

Sur la dernière phrase tu as raison, c'est un mauvais exemple, un très mauvais.
Je n'utilise d'ailleurs pas les pointeurs comme les exemples que j'ai écrits (voir le code que j'ai posté sur la lecture des residents), car ces exemples sont à mon sens ambigües mais parfaitement fonctionnels.

Dans plusieurs langages, les pointeurs ont obligatoirement un type, ce qui évite les erreurs; c'est le cas du turbopascal (si je me souvient bien), du C, C++. En TurboPascal, il existe un type de pointeur "sans type" qui permet de "jongler" avec des types de pointeurs différents, peut-être est-ce le cas en C, C++ mais je ne connais pas assez ces langages.

Il est donc parfaitement normal de pouvoir utiliser des pointeurs en PB avec un type comme s, l, w, ça ne me choque pas.

Dans Mon esprit, la syntaxe suivante est correcte

*var.s

ou le pointeur pointe sur une donnée de type chaine dont la longueur est inconnue.

L'instruction suivante donne le bon résultat

Code : Tout sélectionner

*Pt.s = "Pure"
Debug PeekS(*Pt)

et regarde le code suivant, il fonctionne également

Code : Tout sélectionner

*Pt.s = "Pure"
Debug PeekS(*Pt)
Debug *Pt.s

raison pour laquelle je pense qu'un pointeur doit avoir un type et il doit y avoir un type de pointeur "sans type" afin de pouvoir jongler avec les données.

Dans Debug PeekS(*Pt) *pt est considéré comme une adresse (même si le type est s) car le résultat est correct, le type pointeur de chaine est donc valide.

Dans Debug *Pt.s *pt est considéré comme une chaine bien que soit une pointeur mais PB interprete comme une chaine puisque le type est une chaine alors que juste avant il est considéré comme une adresse (ambigüe tout ça, on devrait plutot avoir l'adresse).


Cette écriture sans type

*pt

correspond à ça

*pt.l

car Deftype intervient également sur le type des pointeurs (là encore, PB permet de déclarer un pointeur ayant un type).

Code : Tout sélectionner

DefType .s
*Pt = "Pure"
Debug  PeekS(*Pt)
Debug *Pt

Si on supprime le deftype, ça ne compile plus à la 2eme ligne.

Ce débat permet de soulever des points obscurs sur comment les pointeurs sont gérés en PB.

Je continue à penser que les pointeurs doivent avoir un type et que l'on doit pouvoir définir un pointeur "sans type"

Si on regarde le code asm (je suis toujours curieux) le code généré pour un pointeur avec un type défini comme par exemple *pt.s, cela correspond bien à une variable de type pointeur utilisé par PB.

Sinon, Nico, je ne prend pas mal tes remarques, au contraire , ça oblige à la réflexion; comme je l'ai dit à Dobro dans un post, il faut limiter l'utilisation des pointeurs car c'est source d'erreurs

et puis moi je comprend vite mais faut expliquer longtemps