Variable size/Get: Difference between revisions

{{task|Type System}}

 

Demonstrate how to get the size of a variable.

 

See also: [[Host introspection]]

 

=={{header|ActionScript}}==

Requires the debug Flash Player 9.0.115.0 or higher.

package {

 

}

 

=={{header|Ada}}==

Ada represents the size of a variable in bits, not bytes like many other languages.

 

=={{header|ALGOL 68}}==

 

Also note that the size of a '''byte''' can vary from one [[wp:CPU|CPU]] to another, c.f. [[Host_introspection#ALGOL_68]] for additional details.

STRING s:="DCLXVI", [666]CHAR c;

print((

"UPB STRING s =",UPB s, new line,

"UPB []CHAR c =",UPB c, new line

{{out}}

<pre>

 

=={{header|AutoHotkey}}==

 

=={{header|Babel}}==

In Babel, you can get the raw size with the mu operator and you can also

break this down into its components:

{ (1 2 (3 4) 5 6)

dup mu disp

 

disp! : { %d cr << }

{{out}}

<pre>

You can also take the size of an object by first serializing it:

 

{{out}}

38

 

=={{header|BASIC}}==

 

{{works with|QBasic}}

Many BASICs, especially those compatible with [[QBasic]],

can use <code>LEN</code> to find the size of any variable:

 

{{out}}

Note that when used with a string, <code>LEN</code> reports the length of the string, not its size in memory.

BASIC typically stores information about the string separately from the string itself, usually immediately before the string itself in memory (but some implementations may store such information elsewhere).

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

A variable's size is implied by its type suffix. The easiest way to determine the size is to use a structure:

DIM istruct{i%}

DIM fstruct{f}

PRINT "Size of f is ";DIM(fstruct{})

PRINT "Size of d# is ";DIM(dstruct{})

Here the size given for the string s$ is for its descriptor, not its contents.

 

 

=={{header|C}}==

 

=={{header|C sharp|C#}}==

class Program

{

}

}

 

=={{header|C++}}==

Store the size of an int in bytes:

 

 

Note: sizeof can be used without the header <cstdlib>; the latter is only needed for the type std::size_t, which is an alias for whatever type is used to store sizes for the given compiler.

 

Output the number of bits of an int:

#include <cstdlib>

 

Note: the type char is always 1 byte (which, however, need not be 8 bits).

Get the size of a variable in bytes:

 

int a = 1;

 

Note: Parentheses are needed around types, but not around variables.

Get the size of an expression's type:

 

 

=={{header|COBOL}}==

Directing Facility <code>>>IF P64 IS SET</code>, shown here.

{{works with|GnuCOBOL}}

identification division.

program-id. variable-size-get.

goback.

end program variable-size-get.

 

{{out}}

{{works with|LispWorks}}

 

(b (make-array 10))

(c "a string"))

(list (hcl:find-object-size a)

(hcl:find-object-size b)

returns

 

 

However, note that interesting objects are generally composed of several levels of references, often including references to preexisting objects, so what the size should be considered as is often hard to define after the fact. A robust though non-automatic way to determine the “true” memory utilization of some data is to do something like this:

 

(gc) ; name varies by implementation

(room)

(push (allocate-something-of-interest) items))

(gc)

 

[http://www.lispworks.com/documentation/HyperSpec/Body/f_room.htm room] prints information about current memory usage, but in an implementation-defined format. Take the difference of the relevant numbers, divide by 512, and you have the amount of memory consumed by allocating one additional instance of whatever it is.

=={{header|D}}==

Every type and variable in D has a property <tt>sizeof</tt>, which give the size of the type in bytes. eg.

writefln(i.sizeof) ; // print 4

int[13] ints1 ; // static integer array of length 13

int[] ints2 = new int[13] ; // dynamic integer array, variable length, currently 13

writefln(ints2.sizeof) ; // print 8, all dynamic array has this size

 

=={{header|Delphi}}==

 

=={{header|Elixir}}==

When “counting” the number of elements in a data structure, Elixir also abides by a simple rule: the function is named '''size''' if the operation is in constant time or '''length''' if the operation is linear.

IO.puts length(list) #=> 3

 

 

map = Map.new([{:b, 1}, {:a, 2}])

 

=={{header|Erlang}}==

2

</pre>

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

INTEGER, PARAMETER :: i16 = SELECTED_INT_KIND(4)

INTEGER, PARAMETER :: i32 = SELECTED_INT_KIND(8)

WRITE (*,*) BIT_SIZE(fourbytes), DIGITS(fourbytes) ! prints 32 and 31

WRITE (*,*) BIT_SIZE(eightbytes), DIGITS(eightbytes) ! prints 64 and 63

 

=={{header|FreeBASIC}}==

 

Dim i As Integer

Print "Press any key to quit"

Sleep

 

{{out}}

A single occupies 4 bytes

A double occupies 8 bytes

</pre>

 

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=87f102023bd9ef6dbd52b0158be2c3ee Click this link to run this code]'''

 

Print "Boolean =\t " & SizeOf(gb.Boolean)

Print "Variant =\t " & SizeOf(gb.Variant)

 

Output:

<pre>

 

=={{header|Go}}==

 

More detail:

 

import (

// Some sizes are implementation dependent.

fmt.Println(runtime.Version(), runtime.GOARCH)

{{out}}

<pre>

=={{header|Haskell}}==

only works with types that instance Storable:

 

sizeOf (undefined :: Int) -- size of Int in bytes (4 on mine)

sizeOf (undefined :: Double) -- size of Double in bytes (8 on mine)

sizeOf (undefined :: Bool) -- size of Bool in bytes (4 on mine)

 

=={{header|Icon}} and {{header|Unicon}}==

** This will show 0 for the assignment of program constants such as strings. Manipulation will be required to produce an allocation.

 

record rec4(a,b,c,d)

 

write("type=",type(x)," *x=",*x," bytes allocated=",a1-a0)

}

 

{{out}}

IDL is array based, so its <tt>size()</tt> function is geared towards that:

 

print,size(arr)

;=> prints this:

 

The result means: 2 dimensions in the array, the first dimension has extent 3, the second has extent 4, the elements of the array are 2-byte integers (IDL's default for an "int"), there's a total of 12 elements in the array.

 

For example:

An advantage of <code>7!:5</code> is that it can be used on any name, including functions, operators, etc (i.e. it's not just restricted to variables):

 

=={{header|Julia}}==

1

 

 

julia> sizeof(t)

(The last line returns 4 on a 32-bit machine or when Julia is compiled in 32-bit mode.)

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

println("A Double variable occupies: ${java.lang.Double.SIZE / 8} bytes")

println("A Char variable occupies: ${java.lang.Character.SIZE / 8} bytes")

 

{{out}}

 

=={{header|Lasso}}==

mystring = 'Hello World',

myarray = array('one', 'two', 3),

//#myinteger -> size // will fail

// an integer can however be converted to a string first

->11

 

 

4

 

{{out}}

<pre>64</pre>

BITSIZE and BYTESIZE are built in functions.

 

 

FROM IO IMPORT Put;

Put("Integer in bits: " & Int(BITSIZE(INTEGER)) & "\n");

Put("Integer in bytes: " & Int(BYTESIZE(INTEGER)) & "\n");

 

{{out}}

 

=={{header|Nim}}==

 

=={{header|OCaml}}==

The word size in octet can be found with (Sys.word_size / 8).

(The size of all the datas in OCaml is at least one word, even chars and bools.)

in

fst(rec_size [] (Obj.repr v))

 

testing in the toplevel:

- : int = 1

 

 

# sizeof(Array.init 10 (fun _ -> String.create 20)) ;;

 

=={{header|ooRexx}}==

=={{header|PARI/GP}}==

In GP, this gets the size of the variable x in bytes:

 

In PARI,

returns the length of the variable x in words. <code>gsizebyte</code> and <code>gsizeword</code> are also available.

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

{{libheader|Devel::Size}}

 

my $var = 9384752;

my @arr = (1, 2, 3, 4, 5, 6);

 

=={{header|Phix}}==

See builtins\VM\pHeap.e for the complete low-level details. Because of shared references,

it is often not practical to obtain a meaningful size, and you can often store a "sparse"

 

=={{header|PL/I}}==

put skip list (SIZE(x)); /* gives the number of bytes occupied by X */

/* whatever data type or structure it is. */

/* varying-length string, including its */

/* length field. */

 

=={{header|Pop11}}==

Form user point of view more important is space taken by values (size of values referenced by a single variable typically varies during program execution). The datasize function gives amount (in machine words) of space directly used by given value:

 

datasize(12) =>

;;; Prints 3: 3 character fits into single machine word, 1 word

datasize({1 2 3}) =>

;;; Prints 3 because only first node counts

 

Note that large amount of data my be referenced from given value, but this data is potentially shared, so there is no canonical way to assign it to a single value or variable.

 

=={{header|PureBasic}}==

Debug SizeOf(a)

 

=={{header|Python}}==

This information is only easily available for the array type:

>>> argslist = [('l', []), ('c', 'hello world'), ('u', u'hello \u2641'),

('l', [1, 2, 3, 4, 5]), ('d', [1.0, 2.0, 3.14])]

array('l', [1, 2, 3, 4, 5]) Size = 20

array('d', [1.0, 2.0, 3.1400000000000001]) Size = 24

Also:

{{works with|Python|2.6+}}

 

=={{header|R}}==

object.size gives '''an estimate''' of the amount of memory used to store the variable, in (kilo/Mega/Giga) bytes. See also dim, length and nchar for determining the extent of mulitdimensional variables (such as matrices, lists, etc).

num <- c(1, 3, 6, 10)

object.size(num) # e.g. 56 bytes

 

l2 <- list(num, num2)

 

=={{header|Racket}}==

#lang racket

(require ffi/unsafe)

(begin (printf "sizeof(~a) = ~a\n" 't (ctype-sizeof t)) ...))

(sizes _byte _short _int _long _llong _float _double)

 

=={{header|REXX}}==

In REXX, you simply set a variable to a value (it could be an expression);

<br>the value's length is the size of the variable's value.

/* to find the size (length) of the value of a REXX variable. */

 

│ The "k" loop uses 21,777,792 bytes for the compound variables, │

│ (excluding the DO loop indices [j and k] themselves). │

 

=={{header|Ring}}==

list1 = list(2)

list2 = list(4)

see "Size of list4 is : " + len(list4) + nl

see "Size of list5 is : " + len(list5) + nl

Output:

<pre>

Size of list4 is : 7

Size of list5 is : 5

</pre>

 

Almost all objects in Ruby (MRI) take 40 bytes (on a x64 machine) initially. Sometimes this is enough to store the entire object, sometimes additional memory has to be allocated. For strings that is the case if they are longer than 23 chars. The additional memory can be retrieved using 'ObjectSpace':

 

require 'objspace'

 

p ObjectSpace.memsize_of("a"*24) #=> 25

p ObjectSpace.memsize_of("a"*1000) #=> 1001

 

=={{header|Scala}}==

 

val primitives: List[(Any, Long)] =

(Long, Long.MaxValue))

 

{{out}}

<pre>A Scala Byte has 1 bytes

 

=={{header|Swift}}==

More detail:

println(sizeof(Int))

var i: Int = 42

// the same number, the size of the String struct.

println(sizeofValue("Rosetta"))

{{out}}

<pre>

=={{header|Tcl}}==

Since all variables are ultimately strings in Tcl, this is easy:

There is additional overhead per value and per variable, which depends on the architecture that Tcl was built for and the version of Tcl. In 8.5 on a ILP-32 architecture, local variables have an overhead of 8 bytes (without traces) and values have a minimum overhead of 24 bytes (this minimum is achieved for integers that fit in a signed 64-bit integer type or a double-precision float).

 

There are two primary data types in Toka, cells and characters. The size of these can be obtained easily:

 

 

If you load the floating point support, you can also obtain the size of a floating point number:

 

 

All sizes are returned in bytes.

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT,{}

string="somerandomstring"

PRINT "has size: ",size

PRINT "and length: ",length

{{out}}

<pre>

 

=={{header|TXR}}==

All Lisp values are pointer-sized cells, so they have a basic size that is four or eight bytes, depending on whether the processor architecture is 32 or 64 bits. Heap values take up a four-cell record. And some objects have additional dynamically allocated memory. The <code>prof</code> operator can be wrapped around code which constructs and returns an object to calculate the size of the heap part plus dynamically allocated memory:

 

"foobar"</pre>

 

 

In the FFI type system, the <code>sizeof</code> macro operator reports size of types.

The <code>struct</code> size corresponds to the size of the C struct

 

uint32_t x : 17;

uint8_t y : 3;

char z[16];

 

as calculated by the GNU C compiler on the same platform. The `uint32_t` leading bitfield creates a minimum alignment of four bytes. The `y` bitfield is packed into the third byte of the structure, and the `z` array starts on the fourth, ending on the nineteenth. The alignment requirement pads the structure to 20.

The leading bitfield is now deemed to be byte aligned, so the structure is no longer padded for the sake of its alignment.

 

 

Since the task is worded as being about '''variables''' rather than objects, what we can do is explore the memory costs of a lexical environment.

=={{header|UNIX Shell}}==

 

# as for finding the length of a string:

greeting='Hello, world!'

greetinglength=`printf '%s' "$greeting" | wc -c`

 

=={{header|Ursala}}==

and returns the number of bits of precision in the mantissa.

Host memory usage is linear plus a small constant.

 

#cast %nL

 

{{out}}

<pre>

 

=={{header|Vala}}==

 

=={{header|XPL0}}==

for dynamic integer arrays using the Reserve intrinsic.

 

int Size;

int A, B;

Size:= addr Y - addr X;

IntOut(0, Size); CrLf(0);

 

{{out}}

 

=={{header|zkl}}==

(0).MAX.len() //-->8 (bytes), ie the max number of bytes in an int

(1.0).MAX.len() //-->8 (bytes), ie the max number of bytes in an float

Dictionary("1",1, "2",2).len() //-->2 (keys)

Data(0,Int,1,2,3,4).len() //-->4 (bytes)

 

Put the data into a variable, same results: a:=123; a.len() --> 1

 

There is also a size property which returns the size of the underlying [implementation] data structure.