Variable size/Set: Difference between revisions

Demonstrate how to specify the minimum size of a variable or a data type.

<br><br>

 

=={{header|360 Assembly}}==

The 360 architecture data specifications are:

* Binary interger (H,F)

I2 DS H half word 2 bytes

A4 DC A(176) 4 bytes but only 3 bytes used

* (24 bits => 16 MB of storage)

 

=={{header|Ada}}==

 

=={{header|AutoHotkey}}==

Variable sizes are in chunks relating to the type of data that they contain. There may also be additional bytes of storage in the variable table that do not show in the dimensions. Typically, strings are allocated in single characters (bytes), so C$(12) in the following example is stored as 12 bytes + additional bytes used for the header in the variable table. In some implementations of basic (such as those that support the storage of variable length strings in arrays), additional terminator characters (such as a trailing Ascii NUL) may also be included. In traditional basic, integers are typically 2 bytes each, so A%(10) contains 10 lots of 2 bytes (20 bytes in total) + additional bytes used for header data in the variable table. Floating point values are typically 8 bytes each, so B(10) holds 10 lots of 8 bytes (80 bytes in total) + additional bytes for header in the variable table:

 

20 DIM B(10): REM the array will hold 10 floating point values

 

{{works with|BBC BASIC for Windows}}

The only way to 'set' the size of a scalar numeric variable is to declare it with the appropriate type suffix:

var% = 1 : REM Variable occupies 32 bits

var = 1 : REM Variable occupies 40 bits

If the task is talking about setting the size of a variable ''at run time'' that is only possible with strings, arrays and structures.

 

=={{header|C}}==

{{works with|C99}}

 

 

Here <var>foo</var> is a signed integer with at least 32 bits. [[wp:stdint.h#Minimum-width integer types|stdint.h]] also defines minimum-width types for at least 8, 16, 32, and 64 bits, as well as unsigned integer types.

 

int i;

long l;

double d;

/* ... */

 

Here the use of <code>union</code> results in a datatype which is at least as large as the largest type. Unions are sometimes exploited to just meet a minimum size:

 

int interesting_datum;

char padding[512];

 

Here, the application will never access <code>padding</code> nor store anything; the padding is there to make the type large enough to meet some requirement. For instance, so that some third party API function which fills in the object, doesn't write past the end of the memory, when the program is only interested in <code>interesting_datum</code>.

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

{{works with|C++11}} or {{works with|Boost}}

 

 

=={{header|D}}==

In D, any variables of static array of zero length has a size of zero. But such data is useless, as no base type element can be accessed.

NOTE: a dynamic array variable's size is always 8 bytes, 4(32-bit) for length and 4 for a reference pointer of the actual storage somewhere in runtime memory.<br>

The proper candidates of minimum size variable are empty structure, 1-byte size data type variable (include <tt>byte, ubyte, char and bool</tt>), and void, they all occupy 1 byte.

ubyte ub ;

char c ;

<tt>bool</tt> is logically 1-bit size, but it actually occupy 1 byte.<br>

<tt>void</tt> can't be declared alone, but <tt>void.sizeof</tt> gives 1.<br>

An empty structure is logically zero size, but still occupy 1 byte.

 

=={{header|Erlang}}==

Variable sizes are in chunks relating to the type of data that they contain. There may also be additional bytes of storage in the variable table that do not show in the dimensions. Typically, in ERRE strings are allocated in single characters (bytes), so C$[12] in the following example is stored as 12 bytes + additional bytes used for the header in the variable table. Integers are typically 2 bytes each, so A%[10] contains 10 numbers of 2 bytes (20 bytes in total) + additional bytes used for header data in the variable table. Floating point values are typically 4 bytes each, so B[10] holds 10 numbers of 4 bytes (40 bytes in total) + additional bytes for header in the variable table:

 

 

DIM B[10] ! the array will hold 10 floating point values

 

 

There is also "double" floating point values (8 bytes). Variables of this type use the suffix #.

 

=={{header|Fortran}}==

'''selected_int_kind(R)''', where R is the required decimal exponent range. The return value is the kind type parameter for integer values n such that -10^R < n < 10^R. A value of -1 is returned if R is out of range.

 

implicit none

 

write(*, form) "iprec4", kind(n7), r6, range(n7)

 

Output

<pre>KIND NAME KIND NUMBER PRECISION RANGE

iprec3 3 8 9

iprec4 4 16 18</pre>

 

=={{header|FreeBASIC}}==

{{trans|Ada}}

For task interpretation this follows the spirit of the Ada example included by the task author. In it, an enumeration type is defined from enumeration values, then a storage size--smaller than the default--is specified for the type. A similar situation exists within Go. Defining types from values is called duck-typing, and the situation where a type smaller than the default can be specified exists when a variable is duck-typed from a numeric literal.

 

import (

fmt.Println("fMin:", unsafe.Sizeof(fMin), "bytes")

fmt.Println("cMin:", unsafe.Sizeof(cMin), "bytes")

Output:

<pre>

cMin: 8 bytes

</pre>

=={{header|Haskell}}==

import Data.Int

import Foreign.Storable

task "Int64" i64

task "Int" int

{{out}}

<pre>

* lists can be specified with a minimum size (see below):

 

 

=={{header|J}}==

 

 

Here, v is specified to have a minimum size. In this case, the minimum size of the content is zero, though the size of the representation is somewhat larger.

 

=={{header|Julia}}==

 

for t in types

 

println("\nFor the 24-bit user defined type MyInt24, size is ", sizeof(MyInt24), " bytes.")

For type Bool size is 1 8-bit bytes, or 8 bits.

For type Char size is 4 8-bit bytes, or 32 bits.

 

The following program shows the range of numbers which the primitive numeric types can accomodate to enable one to choose the appropriate type:

 

fun main(args: Array<String>) {

println("A Float variable has a range of : ${Float.MIN_VALUE} to ${Float.MAX_VALUE}")

println("A Double variable has a range of : ${Double.MIN_VALUE} to ${Double.MAX_VALUE}")

 

{{out}}

</pre>

 

Mathematica stores variables in symbols : e.g. variable 'A' containing integer 0 requires 24 bytes under Windows.

 

=={{header|Modula-3}}==

Note that this only works for records, arrays, and objects. Also note that the size in bits must be large enough to hold the entire range (in this case, 8 bits is the correct amount for the range 0 to 255) or the compiler will error.

 

=={{header|Nim}}==

 

=={{header|ooRexx}}==

 

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

Alternately, in the gp interpreter,

 

=={{header|Pascal}}==

 

 

=={{header|Perl}}==

 

In Perl, memory is readily and happily traded for expressiveness and ease of use.

 

=={{header|Phix}}==

When using mprf.e (aka gmp), variables can have any precision required, up to available memory.<br>

mpz (integer) variables automatically grow as needed but can optionally be initialised with a minimum bitcount to avoid later reallocations.<br>

 

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

declare i fixed binary (7), /* occupies 1 byte */

j fixed binary (15), /* occupies 2 bytes */

y float decimal (16), /* occupies 8 bytes */

z float decimal (33); /* occupies 16 bytes */

 

=={{header|PureBasic}}==

EnableExplicit

 

EndIf

 

 

{{out}}

=={{header|Racket}}==

Like many other highlevel languages, Racket doesn't have direct control on object sizes. More than that, objects are almost always references, so holding a vector or a list still starts from some object with pointers to the rest. It is possible, however, to create random ffi structs with some given length, by using something like <tt>(_array _byte N)</tt> and it's possible to add that to some other ffi type by wrapping it with such an array in a struct. But to create and manage chunks of memory, it's much better to just use <tt>malloc</tt> (which is also available via the ffi).

 

=={{header|REXX}}==

<br><br>There's effectively no limit for the precision [or length] for REXX numbers (except for memory),

<br>but eight million is probably the practical limit.

numeric digits 100 /*default: 9 (decimal digs) for numbers*/

 

 

/* [↑] these #'s are stored as coded. */

 

=={{header|Scala}}==

println(s"A Byte variable has a range of : ${Byte.MinValue} to ${Byte.MaxValue}")

println(s"A Short variable has a range of : ${Short.MinValue} to ${Short.MaxValue}")

println(s"A Long variable has a range of : ${Long.MinValue} to ${Long.MaxValue}")

println(s"A Float variable has a range of : ${Float.MinValue} to ${Float.MaxValue}")

 

See it running in your browser by [https://scastie.scala-lang.org/dX0sTLz5Q1ShT8mLL0cv1g Scastie (JVM)].

In Tcl, most values are (Unicode) strings. Their size is measured in characters, and the minimum size of a string is of course 0.

However, one can arrange, via write traces, that the value of a variable is reformatted to bigger size. Examples, from an interactive [[tclsh]] session:

 

% trace var foo w {format_trace %10s}

% trace var grill w {format_trace %-10s}

% puts "/[set grill bar]/"

 

% trace var baz w {range_trace 2}

% set baz Frankfurt

 

=={{header|TXR}}==

Here, the buffer holds eight zero bytes, but 4096 bytes is allocated to it:

 

 

Another situation, in the context of FFI, is that some structure needs to achieve some size, but we don't care about all of its members. We can add anonymous padding to ensure that it meets the minimum size. For instance, suppose we want to call <code>uname</code>, and we only care about retrieving the <code>sysname</code>:

The last feature eliminates the need for explicitly setting the precision of numbers having exact

representations, albeit contrary to the convention in physical sciences.

 

x = mpfr..grow(1.0E+0,1000) # 160 default precision, grown to 1160

a = # 180 bits (not the default 160) because of more digits in the constant

 

 

=={{header|XPL0}}==

string 0; \use zero-terminated strings

char S,

I:= I & ~(1<<29); \stores a 0 bit into bit 29 of the integer

IntOut(0, I>>3 & 1); \displays value of bit 3

 

Other than arrays and strings, variables are a fixed size. Integers are

four bytes and reals are eight bytes.

 

=={{header|zkl}}==

=={{header|ZX Spectrum Basic}}==

 

20 DIM b(10): REM this will hold a set of numbers. The fixed number of bytes per number is implementation specific

 

{{omit from|AWK}}

{{omit from|NetRexx}}

{{omit from|PlainTeX}}

{{omit from|PureBasic}}

{{omit from|Ruby}}