Address of a variable

Demonstrate how to get the address of a variable and how to set the address of a variable.

Ada

Get The Address

<ada> The_Address : System.Address;

I : Integer;
The_Address := I'Address;</ada>

Set The Address

Set the address of a variable to address A100 in hexadecimal <ada>I : Integer; for I'Address use 16#A100#;</ada> Set the address of one variable to the address of another variable, creating an overlay. <ada>I : Integer; J : Integer; for I'Address use J'Address;</ada>

ALGOL 68

Basically ALGOL 68 refuses to let the programmer access the memory directly. The language does allow "references" any variables. These references are effectively the address a particular variable. But the value of the actual address is not available for printing or any arithmetic.

[4]INT test := (222,444,666,888);
REF INT reference := test[3];
REF INT(reference) := reference + 111;
print(("test value is now: ",test))

Output:

test value is now:        +222       +444       +777       +888

The other reason specific addresses are using in languages like C to manipulate devices. For this purpose site are expected to implement channels for their programmers to use. To quote the ALGOL 68 Revised Report: A "channel" corresponds to one or more physical devices (e.g., a card reader, a card punch or a line printer, or even to a set up in nuclear physics the results of which are collected by the computer), or to a filestore maintained by the operating system.

To establish a channel with such a device there is a special standard procedure:

PROC establish = (REF FILE file, STRING idf, CHANNEL chan, INT p, l, c) INT: ~

Where the idf string is text describing which device to open, and possibly options. And chan is the actual device type. Standard CHANNEL in ALGOL 68 are stand in chan, stand out chan, and stand back chan. Site would be expected to implement their own CHANNELS for database queries and particle accelerators etc.

C#

Platform: .NET

Works with: Visual C# version 2.0+

Get the address

Note that void* is a "pure" address which doesn't carry the type information anymore. If you need the type information (e.g. to recover the variable itself in a type safe manner), use a pointer to the appropriate type instead; in this case int*.

unsafe
{
  int i = 5;
  void* address_of_i = &i;
}

C / C++

Works with: gcc

/ g++

Get the address

Note that void* is a "pure" address which doesn't carry the type information anymore. If you need the type information (e.g. to recover the variable itself in a type safe manner), use a pointer to the appropriate type instead; in this case int*.

int i;
void* address_of_i = &i;

Set the address

While C++ doesn't directly support putting a variable at a given address, the same effect can be achieved by creating a reference to that address:

int& i = *(int*)0xA100;

Overlaying of variables is done with anonymous unions; however at global/namespace scope such variables have to be static (i.e. local to the current file):

static union
{
  int i;
  int j;
};

C++ only: An alternative (and cleaner) solution is to use references:

int i;
int& j = i;

Note that in this case, the variables can be non-static.

Delphi

Turbo/Borland Pascal and Delphi (Object Pascal) support the @ ( address of ) operator and the var : [type] absolute declaration.

To get the address of any variable, structure, procedure or function use the @ operator.

 var
   Int : integer ;
   p   : ^integer ;
 begin
   P := @int ;
   writeln(p^);
 end;

A variable can be declared as absolute ie: to reside at a specific address.

 Var
   CrtMode : integer absolute $0040 ;
   Str     : string[100] ;
   StrLen  : byte absolute Str ;

Forth

Variables and created memory blocks return their address when referenced. The "fetch" operator @ could also be pronounced "dereference".

variable foo
foo .  \ some large number, an address
8 foo !
foo @ .  \ 8

You can define a constant or value with an address, which then acts like a variable. This can be used to refer to fixed addresses (such as I/O ports), graphics buffers, or allocated memory.

$3F8 constant LPT1:
8 LPT1: !

100 cells allocate throw value buffer
42 buffer 20 cells + !

Oberon-2

Get Address

VAR a: LONGINT;
VAR b: INTEGER;

b := 10;
a := SYSTEM.ADR(b); (* Sets variable a to the address of variable b *)

Set Address

SYSTEM.PUT(a, b); (* Sets the address of b to the address of a *)

Perl

To get the address, stringify the reference to a variable. Also see Devel::Peek.

print \my $v;  # SCALAR(0x8167cf4)

Use Devel::Pointer::PP if you want to dereference a certain address in memory.

Changing the address of a variable is not easily possible, but see perlapi. Wanting to go against the automatic memory management is a sign that this is only used to hack around the deficiencies of dafter languages. I can imagine address munging is commonly used to make variable aliasing possible, but Perl already has a higher level syntax for that.

Python

Python traditionally doesn't support low-level operations on memory addresses, except in the limited sense that one can use the mmap module where it's available, and manipulate offsets into memory map objects...including serializing other objects into and out of the memory mapping. New versions of Python support a ctypes module which permits some low level address operations on C-type objects (see C-types Reference for details).

The Python id() function returns a unique ID for any object. This just happens to be implemented as the base address of the object in C Python; but that is not guaranteed by the semantics of the language and should not be considered a standard, nor used as such.

foo = object()  # Create (instantiate) an empty object
address = id(foo)

In addition some folks have written binary Python modules which implement "peek" and "poke" operations, but these are non-standard.

Toka

Get the Address

The default behaviour of a data element in Toka is to return its address. This makes obtaining the address trivial:

variable foo
foo .

Set the Address

You can manually assign a name to any memory address (or other number), but you should make sure it's part of allocated memory first.

 hex abcdef is-data foo
 foo .