PureBasic

Bonjour tout le monde, je voudrais juste savoir si quelqu'un avais un tutorial sur la gestion de la memoire.
Un tut qui explique donc le moyen de modifier un block de memoire aloué en y plaçant différentes valeures à différentes positions du block, cela impliquerai certainement l'explication de l'utilisation des Poke, des Peek et des pointeurs.
J'ai beaucoup de mal à cerner la logique des pointeurs et visiblement je ne suis pas le seul... mais qui serra notre sauveur ?

Salut jenova, le monde est petit

http://pureproject.reelmedia.org/downlo ... nters.html

oui, ça ressemble beaucoup aux explications fourni avec PureBasic dans l'aide, mais comment se balader librement dans un block de memoire aloué ?

Je ne comprends pas trop ta question mais voici un exemple extrait d'un code dispo sur mon site ( matrice et vague si tu veux voir ce que ça fait concrètement )

Code : Tout sélectionner

   adresse=UseMemory(#PointID) 
   For b=0 To FZ 
      For a=0 To FX 
         PokeF(adresse, a - FX/2) : PokeF(adresse + 4, 0 ) : PokeF(adresse + 8, b - FZ/2)  
         ;PokeF(adresse, a ) : PokeF(adresse + 4, 0 ) : PokeF(adresse + 8, b ) 
         adresse + 12 
      Next a 
   Next b

ça serait pour ton image ? , alors peut-être un truc de ce genre

Code : Tout sélectionner

   
AllocateMemory(#PointID    , largeur_image * hauteur_image) 
adresse=UseMemory(#PointID) 
   For b=0 To hauteur_image -1
      For a=0 To largeur_image - 1
         Pokeb(adresse, couleur_image) 
         adresse + 1  
      Next a 
   Next b

Je pense que ce petit programme pourra t'éclairer sur les blocks mémoire

Code : Tout sélectionner

*mem =AllocateMemory(#0,100,0)
; Cette commande reserve un bloc de 100 d'octets dont l'adresse mémoire du premier octet est rangée 
; dans le pointeur *mem, elle attribue aussi la valeur 0 à chacun de ces 100 octets 

PokeS(*mem,"toto")
; PokeS permet d'écrire une chaine de 4 caractères depuis l'adresse spécifiée ici *mem c'est à dire au tout debut du bloc

PokeB(*mem+5,Asc("à"))
; PokeB permet d'écrire un octet à l'adresse spécifiée ici *mem+5 c'est à dire dans le sixième octet du bloc (*mem+0 étant le premier)
PokeS(*mem+6," deux amis")
; PokeS permet d'écrire une autre chaine de caractère depuis l'adresse spécifiée ici *mem+6

For n=0 To 15
  Debug Str(PeekB(*mem+n))+" soit : "+Chr(PeekB(*mem+n))
Next
; Cette boucle permet de lire un à un les 16 premiers octets du bloc 


Debug PeekS(*mem,16)
; Cette commande devrait afficher les 16 premier caractères du bloc, mais comme l'octet *mem+4 n'a pas été défini.
; la valeur initiale 0 est donc restée telle quelle et comme l'instruction PeekS s'arrête au premier caractère 0 il ne renvoie
; que "toto" 

PokeB(*mem+4,32)
; ici nous attribuons un caractère blanc à cette fameuse *mem+4

Debug PeekS(*mem,16)
; maintenant nous pouvons bien lire la chaine complète !

Ai-je réussi ici à te rendre plus accéssible l'utilisation des blocs mémoires ?

Toutes les autres commandes de style Peek, Poke te seront certainement facilement assimilables

Merci tout le monde, tout est bien plus clair maintenant grace à vous

Oups, G de nouveau oublié de me conecter, c'était moi pour le dernier post

Merci brossden, je n'ai pas encore "joué" avec les pointeurs mais ton explication défriche le terrain.

Pour vraiment jouer avec les pointeurs, il faut utiliser une structure. Et ca donne ceci:

Code : Tout sélectionner

Structure MonOctet
  Octet.b
EndStructure

Dim Tableau.b(45)

Tableau.b(0) = 1
Tableau.b(1) = 2
Tableau.b(2) = 3
Tableau.b(3) = 4


; on affiche le tableau original

For k=0 To 4
  Debug Tableau(k)
Next

Debug "-----------------"

; et maintenant, les choses serieuses
;
*Pointeur.MonOctet = @Tableau() ; Adresse de debut du tableau

*Pointeur\Octet = 4  ; Ca correspond a la case 0 du tableau
*Pointeur+1  ; On se deplace de 1 octet
*Pointeur\Octet = 5 ; Ca correspond a la case 1 du tableau
*Pointeur+2
*Pointeur\Octet = 6 ; Ca correspond a la case 3 du tableau

; et on le prouve

For k=0 To 4
  Debug Tableau(k)
Next

L'avantage de cette methode par rapport a peek/poke, c'est sa rapidité. Amusez-vous bien

et par extension on peut obtenir un caractère dans une chaine sans passer
par left, right et mid.

Code : Tout sélectionner

Structure MonOctet
  Octet.b
EndStructure

chaine.s

chaine = "patrick"

*Pointeur.MonOctet = @chaine

For i=1 To Len(chaine)
Debug Chr(*Pointeur\Octet)
*Pointeur+1
Next

Bonjour à tous

Sincèrement Patrick88 je ne vois pas l'interet de passer par un bloc mémoire pour évité d'utiliser Mid Left ou Right qui sont trés performants !

Le code de Patrick88 avec Mid deviendrait

Code : Tout sélectionner


Chaine.s = "Patrick"
For n = 1 to Len(chaine)
  Debug Mid(Chaine,n,1)
Next

Mais pour remplacer la commande Right je pense que le code utilisant un bloc mémoire le plus optimisé serait encore beaucoup plus long que :

Code : Tout sélectionner

Chaine.s = "Patrick"
For n = 1 to Len(chaine)
  Debug Right(Chaine,n)
Next

Je pense que les deux points de vue se défendent, alors voilà mon avis, puisque personne ne me l'a demandé

C'est vrai que, dans le cas ou tu peux mettre ton texte dans un string, Mid(), Left(), et Right(), sont beaucoup plus simple à utiliser.

Mais dans le cas ou ta chaine dépasse les 64 Ko, je trouve qu'il est plus facile d'utiliser un bloc mémoire, surout lorsque tu as plusieurs valeurs à récupérer, et qu'elles sont réparties dans tout le texte.

Chris

c'est juste parce que j'adapte du code c en pb.

et que cette construction revient sans arrêt.. alors c'est plus facile à convertir, mais rien ne m'interdit de revenir au traitement standard des chaine de caractères lorsque ça marchera....

pat

et ça sert dans quoi et a quoi les pointeurs?
(je les ai jamais utilisés)

vous étonnez pas, c'est une question de gros débutant

:

pourquoi on utilise des pointeurs alors qu'il y a des variables, des tableaux...?
et on utilise ça dans quel programme par exemple?

j'y connais rien du tout, j'ai jamais touché aux pointeurs, a la mémoire.

PureBasic

Tuto sur l'allocation de memoire, les Poke et les Peek

Tuto sur l'allocation de memoire, les Poke et les Peek