_MEM - QB64 Wiki


From QB64 Wiki

Jump to: navigation, search

The _MEM variable type can be used when working with memory blocks. It has no variable type suffix. Effective version .954.



Variable TYPE:

  • Memory DOT values are actually part of the built in memory variable type in QB64. The following TYPE is built in:

TYPE memory_type OFFSET AS _OFFSET 'start location of block(changes with byte position) SIZE AS _OFFSET 'size of block remaining at offset(changes with position) TYPE AS LONG 'type description of variable used(never changes) ELEMENTSIZE AS _OFFSET 'byte size of values inside the block(never changes) IMAGE AS LONG 'the image handle used when _MEMIMAGE(handle) is used END TYPE The above TYPE is for clarification purposes only. It is not required to use _MEM!


  • The _MEM type contains the following read only DOT elements where name is the _MEM variable name:
name.OFFSET is the current start position in the memory block AS _OFFSET. Add bytes to change position.
name.SIZE is the remaining size of the block at current position in bytes AS _OFFSET
name.TYPE is the type (represented as bits combined to form a value) AS LONG:
Supported from QB64 version .975 Onwards (Version .954 returns different values!)
  • [bit 0] 1* byte types (_BYTE)
  • [bit 1] 2* byte types (INTEGER)
  • [bit 2] 4* byte types (LONG or SINGLE)
  • [bit 3] 8* byte types (DOUBLE or _INTEGER64)
  • [bit 4] 16* byte types (reserved for future use)
  • [bit 5] 32* byte types (_FLOAT)
  • [bit 6] 64* byte types (reserved for future use)
  • [bit 7] 128 = integer types (_BYTE, INTEGER, LONG, _INTEGER64) (added to *)
  • [bit 8] 256 = floating point types (SINGLE, DOUBLE, _FLOAT) (added to *)
  • [bit 9] 512 = STRING types (fixed length or variable length)
  • [bit 10] 1024 = _UNSIGNED types (added to *+128)
  • [bit 11] 2048 = pixel data (added to 1+128+1024 or 4+128+1024)
  • [bit 12] 4096 = _MEM TYPE structure (NOT added to 32768)
  • [bit 13] 8192 = _OFFSET type (added to 4+128+[1024] or 8+128+[1024] or future_size+128+[1024])
  • [bit 14] 16384 = data created/defined by _MEMNEW(size) or _MEMNEW(offset,size)
  • [bit 15] 32768 = a custom, user defined type (ie. created with TYPE name ... END TYPE)
  • [bit 16] 65536 = an array of data (added to other type values defining the array's data type)
If a future QB64 variable type has a size larger than 64 bytes no lower bits will be set.
name.ELEMENTSIZE is the _BYTE size of the elements within the block AS _OFFSET
  • 1 = _BYTE or unfixed STRING values have a size of 1 byte.
  • 2 = INTEGER values have an element size of 2 bytes
  • 4 = LONG integer and SINGLE float values have an element size of 4 bytes
  • 8 = DOUBLE float and _INTEGER64 values have an element size of 8 bytes
  • 32 = _FLOAT values have an element size of 32 bytes
  • LEN = _OFFSET and fixed length STRING byte sizes vary so use LEN for the number of bytes.
name.IMAGE is the handle used if _MEMIMAGE(handle) was used to initialize the _MEM block
  • Note: _OFFSET values cannot be cast to other variable types reliably! _MEM is a reserved custom variable type!
  • _MEM cannot reference variable length STRING variable values! String values must be designated as a fixed LEN.

Example 1: Demonstration of .IMAGE to determine an image's dimensions, .TYPE to verify the type and _MEMEXISTS to check image has not been freed

SCREEN _NEWIMAGE(500, 500, 32) i = _LOADIMAGE("qb64_trans.png", 32) _PUTIMAGE (0, 0), i DIM m AS _MEM m = _MEMIMAGE(i) 'try uncommenting the following line and see what happens '_MEMFREE m t = m.TYPE IF t AND 2048 THEN PRINT "this is/was an image" IF _MEMEXISTS(m) THEN 'check if memory m is still available PRINT t AND 7; "bytes per pixel" PRINT "image handle "; m.IMAGE PRINT "image width"; _WIDTH(m.IMAGE) PRINT "image height"; _HEIGHT(m.IMAGE) ELSE PRINT "Memory already freed!" END IF END IF

Example 2: Converts the current destination SCREEN 13 image memory altered by PSET to a STRING value. SCREEN 13 only!

SCREEN 13 PSET (0, 0), ASC("H") 'top left corner of screen PSET (1, 0), ASC("E") PSET (2, 0), ASC("L") PSET (3, 0), ASC("L") PSET (4, 0), ASC("O") DIM m AS _MEM m = _MEMIMAGE(0) 'copy the screen memory to m x1$ = _MEMGET(m, m.OFFSET, STRING * 5) 'get at block start position LOCATE 2, 1:PRINT LEN(x1$) 'prints 5 bytes as size is STRING * 5 PRINT x1$ 'prints HELLO as ASCII character values PRINT m.OFFSET; m.SIZE; m.ELEMENTSIZE _MEMFREE m

5 HELLO 5448320 6400 1

Explanation: When a numerical _BYTE value is converted to a STRING, each byte is converted to an ASCII character. The QB64 IDE will capitalize _MEM dot values.

m.SIZE = 320 * 200 = 6400 bytes m.ELEMENTSIZE = 1 byte

See also:

Go to Keyword Reference - Alphabetical
Go to Keyword Reference - By usage
Go to Main WIKI Page
Personal tools