Newsgroup: it.comp.lang.visual-basic
Titolo: [?] Dimensione di una var

Qualcuno sa come ottenere la dimensione di una variabile sapendo solo il suo
puntatore?
Es: ho il puntatore ad una stringa, come faccio a sapere quanti caratteri
contiene, cioč quanta memoria č stata allocata per lei?
E con i tipi definiti dall'utente?
Ciao, grazie

 dimensione della variabile puntata da esso.
:(
Tempo fa qualcuno mi aveva risposto segnalandomi delle funzioni dell'API in
grato di risalire al tipo di variabile puntato.
Ovviamente ho perso il post e trovarlo sull'MSDN è impossibile.
Non risolverebbe il mio problema ma potrebbe essere un punto di partenza.
Ciao

 ha scritto nel messaggio
news:9k16r7$2ej$1...@pegasus.tiscalinet.it...

in linea di massima dovrebbe essere possibile saper la memoria occupata da
una variabile di cui si conosce il puntatore;
tutto dipende dal tipo di allocazione fatta a basso livello; se la memoria
viene allocata con una chiamata a GlobalAlloc/LocalAlloc, esistono le
funzioni GlobalSize/LocalSize che indicano la quantità di memoria allocata;
esistono però alcuni problemi, del tipo
1) se si richiede ad esempio l'allocazione di 32 byte non è detto che win32
allochi _esattamente_ 32 bytes, anzi in genere ne alloca qualcuno in più; in
questo caso GlobalSize/LocalSize è attendibile solo se la variabilòe
allocata è "grossa" (l'incidenza dell'errore dovuto ai bytes extra è
piccola)
2) in genere il runtime dei vari linguaggi di programmazione esegue una
unica allocazione che poi divide per tutte le variabili statiche (quelle
cioè la cui allocazione è già nota a compile time); in questa caso
GlobalSize/LocalSize non sono utilizzabili;
3) le variabili locali vengono tutte allocate nello stack, per cui anche in
questo caso GlobalSize/LocalSize non sono utilizzabili;
4) potrebbe essere possibile utilizzare GlobalSize/LocalSize per oggetti
instaziati dinamicamente, del tipo array o oggetti COM; nel primo caso
dovrebbe valere quanto detto al punto 1, mentre nel secondo caso bisogna
fare i conti con le modalità di apartment.... in altre parole si rischia di
ottenere la dimensione del blocco di memoria contenente il proxy
dell'oggetto COM, piuttosto che la dimensione dell'oggetto stesso;
quindi riassumendo... è un gran bel casino ;))
ciao


Ma... allora, da profano, la mia app come fa a sapere quando una stringa è
terminata?
Ci deve essere un modo per sapere quanto è grande (poi magari non è
utilizzabile da programma, ma deve esistere il modo!)
Ciao

 programma, ma deve esistere il modo!)
Se hai un puntatore ad una stringa C null-terminated (ad esempio un
puntatore restituito da una funzione dell'API) puoi utilizzare
lstrlen per conoscerne le dimensioni, se e' un puntatore ad una
stringa VB (ottenuto con StrPtr) devi utilizzare SysStringByteLen
(sotto le due dichiarazioni).
Declare Function lstrlen Lib "kernel32" Alias "lstrlenA" (ByVal
lpString As Long) As Long
Declare Function SysStringByteLen Lib "Oleaut32" (ByVal bstr As
Long) As Long
Queste due funzioni per convertire un puntatore ad una stringa C ed
un puntatore ad una stringa VB, in una stringa VB:
Function StrFromPtr(ByVal lAddress As Long) As String
    StrFromPtr = String(lstrlen(lAddress), 0)
    CopyMemory ByVal StrFromPtr, ByVal lAddress, Len(StrFromPtr)
End Function
Function StrFromBSTRPtr(ByVal lAddress As Long) As String
    StrFromBSTRPtr = String(SysStringByteLen(lAddress), 0)
    CopyMemory ByVal StrFromBSTRPtr, ByVal lAddress,
Len(StrFromBSTRPtr)
    StrFromBSTRPtr = StrConv(StrFromBSTRPtr, vbFromUnicode)
End Function
Ciao.

dovuto ai bytes extra è piccola)
mi risulta infatti che malloc usi VirtualAlloc :) che su x86 ha una 
granularità di 64kb, mica noccioline :)
E i byte in più di cui parli, beh, credo che se allochi come fixed non 
dovrebbe succedere...

> dovuto ai bytes extra è piccola)
K:H> mi risulta infatti che malloc usi VirtualAlloc :) che su x86 ha una 
K:H> granularità di 64kb, mica noccioline :)
Leggi meglio la documentazione. 
VirtualAlloc() Hai una  granularità di 4k o 8K  (dipende dalla "pagina
della cpu"  [1]) di  memoria allocata mentre  è *l'indirizzo_iniziale*
del- l'area  allocata ad essere  allineato ai 64Kbyte nello  spazio di
indirizzamento  virtuale (ovvero  ti trovi  con  un uso  a macchia  di
leopardo degli  indirizzi di memoria  virtuale, ma dato che  le pagine
hanno  la  dimensione  della  pagina   di  swap  non  c'è  perdita  di
efficenza).
[1] J Richter,"Programmazione avanzata in Windows
--
Gian Uberto| main(){printf(&unix["\021%six\012\0"],(unix)["have"]+"fun"-0x60);}
Lauri      |                        David Korn, 1987 ioccc best one liner 
(aka saint)|-------------------------------------------------------------------
em@ail: 
sa...@eng.it
 ( vedere X-nospam nello header - see X-nospam in header )