Chaine de caractère et HEAPALLOC

mad · **Inscription:** Mar 24/Nov/2009 10:34 **Messages:** 31

Bonjour à tous,

Je n'ai pas trouvé de post parlant de mon problème. En effet je chercher à gagner du temp machine.

Mais j'ai remarqué que pour créer une chaine de caractère de longueur fixe ou variable, il était toujours utilisé des HeapAlloc() provenant de la librairie MSVCRT.dll

Ma question est ... Comment utiliser des variables automatique (comme en C) ?

Merci d'avance de votre aide et des vos réponses .

Dobro · **Inscription:** Lun 26/Avr/2004 0:40 **Messages:** 12954

mad a écrit:

Bonjour à tous,

Je n'ai pas trouvé de post parlant de mon problème. En effet je chercher à gagner du temp machine.

Mais j'ai remarqué que pour créer une chaine de caractère de longueur fixe ou variable, il était toujours utilisé des HeapAlloc() provenant de la librairie MSVCRT.dll

Ma question est ... Comment utiliser des variables automatique (comme en C) ?

Merci d'avance de votre aide et des vos réponses .

heu ...
d'apres Wikipedia :

Citation:

dans le corps d'une fonction : la variable est dite automatique : sa portée est limitée au bloc où elle est définie et aux blocs inclus. Son espace mémoire de stockage n'est pas préservé au dehors.

en clair ça ressemble a ce que nous on appel Variable Locale ...

toute variable Déclarée ou utilisée dans une Procedure (fonction ) est Locale ..

Code:

procedure toto()
je_suis_une_variable_locale =1
procedurereturn je_suis_une_variable_locale
endprocedure


debug je_suis_une_variable_locale   ; affiche  0 

debug toto()  ; affiche  1 ... lecontenue de la variable local est renvoyé

quand a 'HeapAlloc() ' hum... ça se soigne ?

djes

En C aussi les variables de type chaîne sont allouées sur le tas, non ? Si tu veux un espace mémoire fixe (comme les autres types de variables, ou les variables auto en C), tu peux utiliser un pointeur sur une datasection.

mad · **Inscription:** Mar 24/Nov/2009 10:34 **Messages:** 31

Bonjour à tous, bon en conclusion, je vais donc répondre a ma question ... :lol:

Dès que l'on utilise la syntaxe

Code:

Procedure titi()
     Define toto.s
     Define toto$
Endprocedure

Il fait automatiquement de variable en HeapAlloc() a redimensionnement.
Ce qui est bien sûr très couteux.

Par contre Si vous désirez utilisez des "variables automatiques", il faut bien sûr forcément définir une taille donc il faut écrire dans cette syntaxe.

Code:

Procedure titi()
     Define toto.s{255}
Endprocedure

Dans cette syntaxe pas de HeapAlloc(), mais une "allocation" sur la pile directement, ce qui est bien sûr moins couteux.

Pour ma part je pensais que toto$ est un dimensionnement automatique par rapport au texte écrit dedans et que le compilateur fixait ensuite lui même la taille ... Bref...

Voilà :lol:

djes

Ah oui, j'oublie toujours cette syntaxe ! Pourtant je m'en sers de temps en temps dans les structures... :oops:

Dobro · **Inscription:** Lun 26/Avr/2004 0:40 **Messages:** 12954

mad a écrit:

Dès que l'on utilise la syntaxe

Code:

Procedure titi()
     Define toto.s
     Define toto$
Endprocedure

je crois qu'il y a une petite ambiguité , pour rappel en Purebasic
le mot clef "Define" , ne sert pas a definir une Variable au sens declaration , mais juste a Definir son Type

donc dans tes 2 exemple , le mot clef "Define" n'est pas utile je pense ..

il sert par exemple a definir le type '.s' en debut de listing , pour éviter de l'ecrire a chaque fois ..
mais il se trouve qu'en Purebasic le simple fait de commencer a ecrire une variable avec un Type , la défini automatiquement ..

bref le mot clef "Define" , ne sert pas a grand chose de toute façon ...

c'est de toutes façon plus clair d'ecrire le type de la variable a chaque fois

<--j'ai rééditer juste pour grossir cette phrase

dayvid

Citation:

c'est de toutes façon plus clair d'ecrire le type de la variable a chaque fois

Suis tout à fait d'accord avec toi dobro

, on gagne aussi en temps et en lisibilité aussi ! :wink:

Moi par exemple, j'essaie une fois définie une variable, exemple "Abc.l"
de garder la même syntax pour le reste du code, exemple:

Code:

Abc.l = 25

While Abc.l > 0
  Debug Abc.l
  Abc.l - 1
Wend

mad · **Inscription:** Mar 24/Nov/2009 10:34 **Messages:** 31

Bon, c'était pas le sujet, mais ...

En fait pour ma part j'utilise toujours l'option

Code:

EnableExplicit

Il est plus pratique je trouve d'utiliser du code strict.

je m'explique ....

Dans une procédure qui fait trois lignes, vous n'en verrez pas l'utilité, mais, dans une procédure qui fait 1000 lignes, et que vous utilisez par exemple, une variable "type.b" plusieurs fois dans la procédure, le jour où vous devez, pour une raison ou pour une autre, modifier le typage, en .a par exemple, il faut vous retaper le code complet. Alors que le "define" ou autre ... , permet de s’appliquer sur un type de données et de ne pas en sortir.

Par exemple, voici comment je fais une fonction...

Code:

Procedure.b MaFonction() ; Descriptif de ma fonction
      
           Protected.b REF,toto,zizi
           Protected.s{120} MonTerxte,MaLigneInjection
           Protected.l roro,tata,IdFichier

          .............. DEBUT DE MON CODE ..............

          .............. FIN DE MON CODE ..............

     ProcedureReturn REF
Endprocedure

Dans cet exemple, il est donc plus lisible de lire le type de données que vous utilisez, ainsi mieux analysé le poids de votre fonction dans le reste du programme.

Chacun sa méthode.

Pour ma part je trouve anormale de ne pas utiliser du code "non strict"... C'est potentiellement du memory leak a gogo !

@+

Dobro · **Inscription:** Lun 26/Avr/2004 0:40 **Messages:** 12954

mad a écrit:

Dans une procédure qui fait trois lignes, vous n'en verrez pas l'utilité, mais, dans une procédure qui fait 1000 lignes,

hum

heu 1000 lignes ... y aurai pas comme un soucis la ?
une procedure se doit de rester le plus court possible ... sinon ça s’appelle un prg a part entiere ... :roll:

Citation:

et que vous utilisez par exemple, une variable "type.b" plusieurs fois dans la procédure, le jour où vous devez, pour une raison ou pour une autre, modifier le typage, en .a par exemple, il faut vous retaper le code complet.

ha bon ? t'as pas de Chercher/Remplacer dans ton editeur ?

Citation:

Dans cet exemple, il est donc plus lisible de lire le type de données que vous utilisez, ainsi mieux analysé le poids de votre fonction dans le reste du programme.

Chacun sa méthode.

@+

tu cite "Protected" , je parlais de "Define" , c'est pas pareil ...

Define NE SERT QU'A DEFINIR LE TYPE D'UNE VARIABLE ! pas une Variable

il se trouve qu'en Purebasic le fait d'utiliser une première fois une variable avec son type ... la définie , sans l'utilisation de "Define" ...

Define comme tu l'utilise ne sert a rien ... ça servirai si tu voulais changer le type de la variable ... et encore
je ne sais pas pourquoi Fred garde ce "Define"

lepiaf31

mad a écrit:

En fait pour ma part j'utilise toujours l'option

Code:

EnableExplicit

+1

Citation:

Define NE SERT QU'A DEFINIR LE TYPE D'UNE VARIABLE ! pas une Variable

Es-tu sûr de ca ? Est ce que le compilateur n'alloue pas automatiquement de la mémoire dès qu'il y a un Define et même si la variable n'est pas utilisée ? (simple question)

mad · **Inscription:** Mar 24/Nov/2009 10:34 **Messages:** 31

Alors ... c'est là que ça se gatte ...

Tout d'abord, effectivement, je voulais dire 100 lignes... A savoir que j'ai toute de même des fonctions qui pas loin de 200 lignes aussi ... et non 2000 hein ...

Par contre... Ne jouons pas sur les mots ...

Chacun à sa méthode de travail, perso, je fait du define pour la lisibilité du code, car je le lit mieux comme ça ne se discute pas.

Pour ma part, je n'ai pas la prétention de critiquer l'ajout de Define, sur le code, je ne serais sans doute pas moi faire un langage compilé, donc juste par respect je m’abstiens... Que cela soit dit.

Si il à été mis a un moment donnée c'est qu'il y avait une raison.

Le code le permet, je l'utilise. Il ne faut jamais critiquer, mais plutôt envisagé une solution concrète pour des changements si il y a besoin...

Reprenons l'exemple ...

Code:

Procedure.b MaFonction() ; Descriptif de ma fonction
     
           Protected.b REF,toto,zizi
           Protected.s{120} MonTerxte,MaLigneInjection
           Protected.l roro,tata,IdFichier
           Define.s{255} MonChemin
           Define.i taille = -1, tailleMax = 255
    
          .............. DEBUT DE MON CODE ..............

          .............. FIN DE MON CODE ..............

     ProcedureReturn REF
Endprocedure

Voilà... ça va mieux, la encore, je parlais de la lisibilité du langage... et non de l'utilisation du mot ...

De plus ...

Ce topic n'était en rien une discutions absurde sur le mot clef Define, car nous ne serons jamais d'accord sur ce sujet, mais plutôt une question sur le dimensionnement des variables automatique sur la pile...

J'ai répondu par moi même... je l'ai marqué sur le site.

J'aurais très bien pus le garder pour moi.

Citation:

Dobro : quand a 'HeapAlloc() ' hum... ça se soigne ?

Je suis sûr que par exemple Dobro, qui ma fait une remarque sur sa méthode de travail .. copier/coller, ne sait pas trop a quoi sert heapalloc() au quel moment il est utilisé, qui l'utilise, une fois son programme compilé... D’ailleurs rien à voir avec la porté de la variable local ou non ...

Et si tu le savais pourquoi me prendre la tête sur le mot Define, plutôt que sur la vrai discution ... ?

Dobro · **Inscription:** Lun 26/Avr/2004 0:40 **Messages:** 12954

lepiaf31 a écrit:

mad a écrit:

En fait pour ma part j'utilise toujours l'option

Code:

EnableExplicit

+1

Citation:

Define NE SERT QU'A DEFINIR LE TYPE D'UNE VARIABLE ! pas une Variable

Es-tu sûr de ca ? Est ce que le compilateur n'alloue pas automatiquement de la mémoire dès qu'il y a un Define et même si la variable n'est pas utilisée ? (simple question)

le code

Code:

; define a.l

donne en assembleur :

Code:

; 
; PureBasic 4.60 (Windows - x86) generated code
; 
; (c) 2011 Fantaisie Software
; 
; The header must remain intact for Re-Assembly
; 
; :System
; KERNEL32
; :Import
; 
format MS COFF
; 
; 
extrn _ExitProcess@4
extrn _GetModuleHandleA@4
extrn _HeapCreate@12
extrn _HeapDestroy@4
extrn _memset
public _PB_Instance
public _PB_ExecutableType
public _PB_OpenGLSubsystem
public _PB_MemoryBase
public PB_Instance
public PB_MemoryBase
public _PB_EndFunctions

macro pb_public symbol
{
  public  _#symbol
  public symbol
_#symbol:
symbol:
}

macro    pb_align value { rb (value-1) - ($-_PB_DataSection + value-1) mod value }
macro pb_bssalign value { rb (value-1) - ($-_PB_BSSSection  + value-1) mod value }
public PureBasicStart
; 
section '.code' code readable executable align 8
; 
; 
PureBasicStart:
; 
  PUSH   dword I_BSSEnd-I_BSSStart
  PUSH   dword 0
  PUSH   dword I_BSSStart
  CALL  _memset
  ADD    esp,12
  PUSH   dword 0
  CALL  _GetModuleHandleA@4
  MOV    [_PB_Instance],eax
  PUSH   dword 0
  PUSH   dword 4096
  PUSH   dword 0
  CALL  _HeapCreate@12
  MOV    [PB_MemoryBase],eax
; 
; Define a.l
; 
; 
; 
; EPB 
; 
_PB_EOP_NoValue:
  PUSH   dword 0
_PB_EOP:
  CALL  _PB_EndFunctions
  PUSH   dword [PB_MemoryBase]
  CALL  _HeapDestroy@4
  CALL  _ExitProcess@4
_PB_EndFunctions:
  RET
; 
; 
section '.data' data readable writeable
; 
_PB_DataSection:
_PB_OpenGLSubsystem: db 0
pb_public PB_DEBUGGER_LineNumber
  dd     -1
pb_public PB_DEBUGGER_IncludedFiles
  dd     0
pb_public PB_DEBUGGER_FileName
  db     0
_PB_ExecutableType: dd 0
align 4
align 4
s_s:
  dd     0
  dd     -1
align 4
; 
section '.bss' readable writeable
_PB_BSSSection:
align 4
; 
I_BSSStart:
_PB_MemoryBase:
PB_MemoryBase: rd 1
_PB_Instance:
PB_Instance: rd 1
; 
align 4
PB_DataPointer rd 1
align 4
align 4
align 4
align 4
I_BSSEnd:
section '.data' data readable writeable
SYS_EndDataSection:

alors que le code

Code:

define a.l

donne

Code:

; 
; PureBasic 4.60 (Windows - x86) generated code
; 
; (c) 2011 Fantaisie Software
; 
; The header must remain intact for Re-Assembly
; 
; :System
; KERNEL32
; :Import
; 
format MS COFF
; 
; 
extrn _ExitProcess@4
extrn _GetModuleHandleA@4
extrn _HeapCreate@12
extrn _HeapDestroy@4
extrn _memset
public _PB_Instance
public _PB_ExecutableType
public _PB_OpenGLSubsystem
public _PB_MemoryBase
public PB_Instance
public PB_MemoryBase
public _PB_EndFunctions

macro pb_public symbol
{
  public  _#symbol
  public symbol
_#symbol:
symbol:
}

macro    pb_align value { rb (value-1) - ($-_PB_DataSection + value-1) mod value }
macro pb_bssalign value { rb (value-1) - ($-_PB_BSSSection  + value-1) mod value }
public PureBasicStart
; 
section '.code' code readable executable align 8
; 
; 
PureBasicStart:
; 
  PUSH   dword I_BSSEnd-I_BSSStart
  PUSH   dword 0
  PUSH   dword I_BSSStart
  CALL  _memset
  ADD    esp,12
  PUSH   dword 0
  CALL  _GetModuleHandleA@4
  MOV    [_PB_Instance],eax
  PUSH   dword 0
  PUSH   dword 4096
  PUSH   dword 0
  CALL  _HeapCreate@12
  MOV    [PB_MemoryBase],eax
; 
; Define a.l
; 
; 
; 
; EPB 
; 
_PB_EOP_NoValue:
  PUSH   dword 0
_PB_EOP:
  CALL  _PB_EndFunctions
  PUSH   dword [PB_MemoryBase]
  CALL  _HeapDestroy@4
  CALL  _ExitProcess@4
_PB_EndFunctions:
  RET
; 
; 
section '.data' data readable writeable
; 
_PB_DataSection:
_PB_OpenGLSubsystem: db 0
pb_public PB_DEBUGGER_LineNumber
  dd     -1
pb_public PB_DEBUGGER_IncludedFiles
  dd     0
pb_public PB_DEBUGGER_FileName
  db     0
_PB_ExecutableType: dd 0
align 4
align 4
s_s:
  dd     0
  dd     -1
align 4
; 
section '.bss' readable writeable
_PB_BSSSection:
align 4
; 
I_BSSStart:
_PB_MemoryBase:
PB_MemoryBase: rd 1
_PB_Instance:
PB_Instance: rd 1
; 
align 4
PB_DataPointer rd 1
v_a rd 1
align 4
align 4
align 4
align 4
I_BSSEnd:
section '.data' data readable writeable
SYS_EndDataSection:

c'est a dire la meme chose !!!

si utilité , il y a , ... elle se passe ailleurs que dans le code ( peut etre au linkage )

je vais répété lentement pour les bouchés

en Purebasic , la PREMIERE utilisation d'une d'une variable , avec son type , détermine ce type pour le reste du listing !!

voici la preuve en image :

Code:

toto.l =1
debug toto.a

affichera une erreur indiquant que le type n'est pas le bon !!

donc je repete utiliser Define Ne sert a rien !
cela a été ma remarque Premiere dans l'exemple de Mad

@mad , tu peux tourner les choses comme tu l'entends , mais regarde la réalité en face

le mot clef Define , ne sert qu'a declarer un type pour les variables par defaut , mais pour une seule variable , c'est idiot !
il suffit de spécifier le type a la premiere utilisation !

est-ce que c'est clair là ??

@Fred , si tu passe par là , explique lui

mad · **Inscription:** Mar 24/Nov/2009 10:34 **Messages:** 31

Désolé Dobro d'insister, mais une fois de plus je ne parlais pas du mot Define, mais sur l'allocation mémoire, que provoque

toto$ ou toto.s{1024}

variable automatique sur la pile ou allocation mémoire...

Et comme je l'ai dit aussi avant, dans un cas il utilise HeapAlloc et l'autre non...

Comme tu connais bien l'assembleur, regarde avec IDA ... tu verras...

Dobro · **Inscription:** Lun 26/Avr/2004 0:40 **Messages:** 12954

mad a écrit:

Désolé Dobro d'insister, mais une fois de plus je ne parlais pas du mot Define, mais sur l'allocation mémoire, que provoque

toto$ ou toto.s{1024}

variable automatique sur la pile ou allocation mémoire...

Et comme je l'ai dit aussi avant, dans un cas il utilise HeapAlloc et l'autre non...

Comme tu connais bien l'assembleur, regarde avec IDA ... tu verras...

mais oui , je ne dis rien la dessus :roll:

relis mon deuxieme message , tu verra , que je regarde ton exemple , que je recite
et je dis juste , ( en precission ) inutile d'utiliser Define

voila rien de plus .... parceque tu n'est pas le premier que je vois utiliser Define , comme s'il s'agissait d'une sorte de declaration de variable
ce qui n'est pas le Cas en Purebasic

mad · **Inscription:** Mar 24/Nov/2009 10:34 **Messages:** 31

Comme marqué au dessus, pour ma part, je l'utilise pour la lisibilité du code...

Bien, le topic, comme le titre indique, c'est sur HeapAlloc() et la définition de variable de type string en allocation mémoire ou prise directement en variable automatique sur la pile...

Mais je pense, au vu de tes connaissances en assembleurs, que tu pourrais peut être m'expliquer le fonctionnement de HeapAlloc pour une variable de type string ?

PureBasic

Chaine de caractère et HEAPALLOC

Qui est en ligne