Pointers and references: Difference between revisions

=={{header|6502 Assembly}}==

6502 Assembly is different from most other assembly languages, in the way constants are specified. When you have a statement like <code>int x = 3</code> in a language like [[C]] or <code>mov eax,3</code> in [[X86 Assembly]], the 3 in both cases is called a ''constant'' or ''immediate'' value, meaning that the value 3 is what gets stored. 6502 Assembly does '''not''' work this way. It uses what is called "Motorola syntax" where an immediate value needs a # in front, or else the number is '''interpreted as a pointer to memory.''' For example:

Pointers in 6502 Assembly can be 8-bit or 16-bit. The 6502 has a 16-bit address space ranging from $0000-$FFFF. An 8-bit pointer assumes the high byte to be zero. These pointers are referred to as pointers to "zero-page RAM" and the CPU is much more efficient at working with them than with 16-bit pointers.

===Pointers on the stack===

{{works with|65c02}}

The 6502's hardware stack is located at memory addresses $0100-$01FF and, unlike most CPU architectures, cannot be relocated to any arbitrary address outside this range. In addition, it uses the empty-stack convention, where the stack pointer points to free space rather than the value on top. Therefore, to create a pointer to the top item of the stack we can do the following:

Note that in a subroutine, the value at <code>$0101,x</code> is typically the low byte of the program counter, plus 1. It may be different depending on how many registers you pushed onto the stack prior to entry as well. In this example, we'll look at a hand-written translation of the following [[C]] function (I'm ignoring 8-bit overflow just to keep things easier to write.)

return a+b+c;

PHA

LDA #arg_B

ADC $0104,X ;ADC #arg_A

;we have the desired value in A, now return.

This can be done as well on the original 6502, but is much more difficult since you don't have <code>PHX/PLX</code>, which means that you can't preserve X or Y without destroying the value in the accumulator. To keep things simple I chose a 65c02 example.

===Pointer arithmetic===

The 6502 can offset pointers up to 255 bytes forwards.

LDA $2000,X ;load the byte stored at $2080

LDY #$FF

Note that when using zero-page addressing, this offsetting is always modulo 256, meaning there is no "carry" when offsetting, unlike with absolute addressing.

=={{header|8086 Assembly}}==

===Pointers===

In most assemblers, an instruction or a numeric value can be given a label.

.stack 1024

.data ; data segment begins here

mov ax, @code

<code>equ</code> directives are flexible in that they can be intended as constants or as memory addresses. In this case, the <code>equ</code> directives involving <code>tempByte</code> and <code>tempWord</code> are used as memory addresses.

We can load to or from memory with the 8086 in a few different ways. In the example below, the value in a memory address is loaded directly from RAM to a register, or vice versa. Assume the code below takes place immediately after the setup above:

mov word ptr [ds:tempWord],ax ;store hexadecimal value FFFF into tempWord

;Note 1:

;UASM doesn't like leading hex digits A-F so a 0 is placed in front.

8086 Assembly doesn't enforce data types that much. While your variables may be intended to be byte or word length, there's nothing actually stopping you from using the "wrong" pointer type, as long as the register you're moving to/from matches the size of the pointer variable.

mov al, word ptr [ds:tempWord] ;assembler will generate an error - operands don't match

mov ax, word ptr [ds:tempByte] ;assembler will allow this even though the intended data size is wrong

mov al, byte ptr [ds:tempWord] ;assembler will allow this even though the intended data size is wrong

You can also define a full double word address like so: <code>UserRamPtr dword UserRam</code>

Then this pointer can be loaded into a segment register and data register with a single command, like so:

===Pointer Arithmetic===

A pointer can be loaded into a register like any other value.

myString db "Hello World!",0 ;the zero is the null terminator

.code

mov bx, seg myString ;load into bx the segment where myString is stored.

mov ds, bx ;load this segment into the data segment register. On the 8086, segment registers can't be loaded directly.

Once we have the pointer to myString in bx, we can perform arithmetic on it like it was an ordinary numerical value. There is no distinction between pointer arithmetic and normal arithmetic in assembly. All arithmetic commands are available for use. If the programmer wishes to use that memory address as a number for some other purpose, that is perfectly legal. However this example will stick to the "proper" uses of pointer arithmetic, i.e. indexing and offsetting.

=={{header|68000 Assembly}}==

In most assemblers, a line of code or a value in work RAM can be given a label.

myData: ; a data table given a label

The <code>LEA</code> instruction can load the address of a given label.

This isn't needed for values in RAM, but it is needed for loading from data tables in ROM.

The address registers <code>A0</code> through <code>A6</code> hold 24-bit addresses. While they can contain 32 bits of data, the top byte is ignored.

68000 Assembly doesn't care about what type of data is being pointed to. It makes no distinction between bytes, words, longs, or executable code. That is up to the opcodes that interact with the data. For the following, assume that the address <code>myData</code> shown above is loaded into <code>A0</code>, and that <code>D0</code> equaled 0x00000000 prior to the code below.

MOVE.W (A0),D0 ;D0 = 0x00008081

Putting a + after <code>(A0)</code> auto-increments the pointer by 1,2,or 4 for <code>MOVE.B</code>,<code>MOVE.W</code>, and <code>MOVE.L</code> respectively. The increment happens after the move.

MOVE.B (A0)+,D0 ;D0 = 00000080

MOVE.B (A0)+,D1 ;D1 = 00000081

Putting a - before <code>(A0)</code> pre-decrements the pointer by 1,2, or 4 for <code>MOVE.B</code>,<code>MOVE.W</code>, and <code>MOVE.L</code> respectively, ''before the move takes place.''

MOVE.B -(A0),D0 ;D0 = 00000083

MOVE.B -(A0),D1 ;D1 = 00000082

<code>LEA</code> can also be used to pre-calculate a complex offset to an address.

MOVE.W #$0C,D0

An address can be offset by an immediate value, a register, or both. Data register offsets are measured at 16 bit word length. Although the second <code>LEA</code> is in brackets, it does NOT dereference the pointer. Let's look at the following example data:

myData: dc.b $80,$81,$82,$83

myData2: dc.b $84,$85,$86,$87

These two code snippets <i>are not the same</i>:

===Pointers on the stack===

If you maintain the stack 32-bit aligned at all times, you can offset the stack by multiples of 4 to get the desired parameters, assuming you pushed them in the reverse order they were declared in your function prototype.

;uint64_t foo (uint16_t a,uint16_t b,uint16_t c){return a+b+c;}

MOVE.L #arg2,-(SP)

ADD.L (8,SP),D0

ADD.L (12,SP),D0

===References===

Labeled memory can be read/written to directly, unlike in ARM Assembly.

Unlike in C, pointers do not have to point to any specific type of data.

There is nothing stopping you from clobbering nearby stored data. In the above example, the byte FF gets written to $100000, EE to $100001, DD to $100002, and CC to $100003. If you intended myVar to be of byte length, you need to make sure you only use MOVE.B to read to/write from myVar.

Create a pool specific access type for an integer

A pool specific access type can be constrained to never be null. For such pointers the compiler can omit checks of being null upon dereferencing.

General access types can deal with objects allocated in any pool as well as ones on the stack. For example, create a pointer to a stack-allocated integer

type Int_Ptr is access all Integer;

Ref : Int_Ptr;

Val : Integer := Var;

begin

The attribute 'Access (and also 'Unchecked_Access) is used to get a pointer to the object. Note that the object has to be declared ''aliased '' when it has to be referenced by a pointer, which is why one cannot write Val'Access. General access types can also be constrained to exclude null:

===Addresses===

Ada does not provide pointer arithmetic, but does allow evaluation of the address

Addresses support operations of comparison, addition, and subtraction. Ada also supports conversion between address types and a predefined subtype of Integer named Integer_Address. This accommodates the conversion to a linear addressing of any hardware address scheme including address:offset used in the 8086 processor.

Ada allows the specification of a starting address for any object

A : Integer;

B : Integer;

for B'Address use A'Address;

===References===

References in Ada are achieved through object renaming declarations. A renaming produces a new view to the object:

for I in Container'Range loop

declare

Do_Something(Item); -- Here Item is a reference to Container (I)

end;

The forthcoming standard (Ada 2012) allows a more direct way to reference all the items in a container or an array:

for Item of Container loop

Do_Something(Item);

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

The following code creates a pointer to an INT variable:

Access the integer variable through the pointer:

Change the pointer to refer to another object:

Change the pointer to not point to any object:

Get a pointer to the first element of an array:

There is no pointer arithmetic, eg no p +:=3

The following code creates a constant reference to an INT variable, effectively an alias:

Access the integer variable through the reference:

Constand references cannot be changed to refer to other objects.

Pointers can be compared, but only for basic equality:

Output: alias IS var!

Get a reference to the first element of an array:

Changing the reference to refer to another object of the array is not possible.

ALGOL 68 also allows pointers to slices of rows and/or columns of arrays:

REF [,]INT middle;

This includes pointers to sliced character arrays:

REF[]CHAR needle = hay stack[13:18];

needle[2:3] := "oo";

Output: straw straw noodle straw straw

Pointers in ARM Assembly are very similar to that on 68000 Assembly. However, ARM Assembly has no address registers. Rather, enclosing a register in brackets treats its value as a memory location.

MOV R1,#0x04000000

MOV R0,#0x403

The <code>STR</code> instruction is unusual in that its source is on the left and its destination on the right.

=={{header|AutoHotkey}}==

The address of the variable structure itself cannot be changed using built in methods.

NumPut(87, var, 0, "Char") ; store 87 at offset 0

MsgBox % NumGet(var, 0, "Char") ; get character at offset 0 (87)

MsgBox % &var ; address of contents pointed to by var structure

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

{{works with|BBC BASIC for Windows}}

pointer_to_varA = ^varA%

!pointer_to_varA = 123456

DEF FNmyfunc

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

The following code creates a pointer to an int variable

Access the integer variable through the pointer:

Change the pointer to refer to another object

Change the pointer to not point to any object

or

or

Get a pointer to the first element of an array:

pointer = array;

/* or alternatively: */

Move the pointer to another object in the array

Access another object in the same array through the pointer

v = pointer[-1]; /* accesses previous object, i.e. array[0] */

/* or alternatively */

v = *(pointer + 3); /* array[4] */

The following code snippet shows a practical example of using pointers in C with structs. Note there are many ways to access to a value using the * operator.

#include <stdlib.h>

}

return i;

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

This example represents usage of Reference and Value.

static void Main(string[] args)

{

Value += 1;

}

Example Result:

C++ specific alternative to "The following code creates a pointer to an int variable":

'''With references:'''

The following code create a reference to an int variable:

int& ref = var;

// or alternatively:

Access the integer variable through the reference

References cannot be changed to refer to other objects, and cannot (legally) made to refer to no object.

Get a reference to the first element of an array:

Changing the reference to refer to another object of the array is not possible.

Accessing another object of the array through the reference:

=={{header|COBOL}}==

===Pointers===

Pointers are declared like so, optionally with the type or program they will point to:

<code>USAGE POINTER</code> data items are used in conjunction with <code>BASED</code> data items, with <code>ALLOCATE</code> optionally giving a pointer the address of the allocated memory. Pointers can also be used to free allocated memory, which will cause the pointer to be set to <code>NULL</code>.

...

<code>USAGE PROGRAM-POINTER</code> data items are used to point to programs and their entry points.

{{works with|OpenCOBOL}}

{{works with|Visual COBOL}}

Both types of pointer support basic pointer arithmetic.

Pointers can also be set to point to where other pointers are pointing or to other pointers themselves.

To alter the value pointed to by a pointer, the <code>SET</code> statement is needed once again and is used to set the address of <code>BASED</code> or <code>LINKAGE SECTION</code> data items, which can then be used to modify the data.

===References===

Object references are declared like so, optionally with the class/interface they will reference:

They contain either a reference to an object or <code>NULL</code>.

They are initialised using by invoking a class constructor, and set using the <code>SET</code> statement.

<code>LINKAGE SECTION</code> data items are essentially references, being passed either the address of an argument (<code>BY REFERENCE</code>), the address of a copy of an argument (<code>BY CONTENT</code>) or the address itself, suitable for using with pointers (<code>BY VALUE</code>).

=={{header|D}}==

// Take the address of 'var' and placing it in a pointer:

int var;

void foo5(T)(ref T t) {} // By reference regardless of what type

// T really is.

=={{header|Delphi}}==

Variable Declaration

Simple pointer to a ''predefined'' type:

Variable Declaration

A pointer to a ''Record''. This is the equivalent to a ''Struct'' in C

Type Defintion

FName : string[20];

LName : string[20];

Variable Declaration

Note that when defining a pointer type, unless otherwise, you may refer to the pointed to type before defining it. For example the following is legal despite tFoo not being defined at the pointer definition:

pFoo = ^tFoo; { allowed despite tFoo not yet being defined }

tFoo = record

value1, value2: integer;

- Dereferencing a Pointer -

Pointers are dereferenced using the caret '^' symbol. Dereferencing will cause the compiler or RTL to reveal the data that the pointer points to:

Dereference with a type cast of an ''untyped'' pointer. It is not legal syntax to simply dereference an untyped pointer, since there is nothing to designate its type. It must therefor be "Type Cast" when the dereference takes place as below.

- Pushing a Pointer -

Many programmers are familiar with C's ability to increment pointers of any type by using the '''++''' or '''--''' operators. The equivalent in Delphi is to use either the Inc or Dec standard procedure:

Inc(PtrVar, 4); //incremement by four elements

C-style array indexing is also supported by default for PByte (a pointer to a byte), PAnsiChar (a pointer to a singlebyte character) and PWideChar (a pointer to a doublebyte character). For any other typed pointer, it can be enabled using a compiler directive:

PrevIntVar := MyIntPtr[-1];

=={{header|E}}==

=={{header|EchoLisp}}==

No pointers in EchoLisp. '''Boxes ''' or vectors can be used to perform call-by-reference operations.

(define B (box 42))

→ B ;; box reference

(unbox B)

→ 666

=={{header|Forth}}==

Since Fortran90, the <tt>pointer</tt> attribute can be given:

A so-declared pointer is in an undetermined state: a pointer should be nullified:

But Fortran 95 allows to initialize pointers to NULL (unassociated):

A pointer can be associated:

The target attribute is needed to say that the ''object'' (the "real" datum) can be referenced through a pointer (it seems it works more like an alias rather than a "true" pointer). The existence of an ''association'' can be tested with <tt>associated</tt> (Fortran 95):

and the association can be nullified as before with <tt>nullify</tt>.

The data a "pointer" points to can be allocated as if the <tt>allocatable</tt> attribute were specified.

That allocate an array of 100 integers; nullifying at this point would give memory leakage; the memory pointed to the array should be deallocated using the <tt>deallocate(array)</tt> code.

The function <tt>associated</tt> (Fortran 95) accepts also the optional argument <tt>target</tt>, to check if the pointer is associated to a particular target (working ''de facto'' like an alias)

integer, pointer :: pi

!... ...

Associating pointer to an array could help accessing the data of the array in a different manner.

real, dimension(20,20), target :: b

real, dimension(:), pointer :: p

! p(1) == a(5), p(2) == a(6) ...

p => b(10,1:20)

Which is different of course from having e.g.

real, dimension(16) :: p

In order to create arrays of pointers, the only way is to define a new type:

integer, pointer :: p

end type intpointer

!...

It declares an array of 100 <tt>intpointer</tt>, i.e. pointers to integer; the <tt>integer, dimension(:), pointer :: pt</tt> says just that pt is a pointer to an array of X integers.

=={{header|FreeBASIC}}==

Type Cat

' print them out

Print "i ="; i, "j ="; j

{{out}}

Short of restrictions though, <tt>*</tt> and <tt>&</tt> are used much as they are in C.

The zero value of a pointer is called nil. Dereferencing a nil pointer, as in the example above, causes a run-time panic.

Some go types contain pointers in their internal representation and are called reference types. For example, slices, maps, and channels are always reference types.

declares m as object of map type, but does not allocate or create anything. It's internal pointer is nil and attempts to store anything in the map will cause a run-time panic. The following short declaration declares m the same as above, but it also initializes the internal representation.

Built-in function make allocates and constructs the internal representation and returns a map object ready to use.

Assignment to a reference type such as a slice, map, or channel does not do a deep copy. It results in two references to the same underlying data. For example

c := b

c[0] = 'H'

Output:

<pre>

Go's garbage collector is aware of references created by taking the address of an object.

i := 3

return &i // valid. no worry, no crash.

Because of this, a common syntax for allocating a struct is to use & with a literal:

x, y int

}

=={{header|Haskell}}==

However, Haskell supports imperative update of variables. To ensure that these side-effects are ordered, that has to happen inside a monad. So the predefined state monad ''ST'' makes it possible to allocate a ''reference'' (a simple mutable data structure with one field; not the same meaning as the "references" in other languages) with an initial value, read from it, and write to it:

import Data.STRef

k <- readSTRef p

writeSTRef p (k+1)

These are all the operations allowed on references. The type system guarantees that a reference can never leave the monad. The IO monad has similar operations ''newIORef'', ''readIORef'', ''writeIORef''. One can also embed the ST monad in the IO monad with 'stToIO'.

If the object that a reference is pointing to is mutable (i.e. it has public fields or it has methods that allows changing of its fields), then it is possible to modify that object's state through the reference; and someone else who has a reference to the same object will see that modification. (Note: this does not change the reference itself, just the object that it points to.) Let us consider a simple class of mutable object:

void somefunction() {

a.x = 5; // this modifies the "x" field of the object pointed to by "a"

System.out.println(b.x); // this prints 5, because "b" points to the same object as "a"

Java is call-by-value. When passing arguments, you are either passing primitives by value or references by value. There is no such thing as "passing an object" as objects are not values in the language. As noted above, if the object that the reference is pointing to is mutable, then it is possible to modify that object's state through the reference. Then if the calling function has a reference to the same object, they will see that modification through the reference. So if you want to reflect changes in an argument back to the caller, one thing that you can do is wrap the argument as a field in an object, then modify the object through the reference.

Julia's C interface pointer functions are considered "unsafe" because, like C pointers, they may cause data corruption if used incorrectly.

parr = pointer(x)

println(xx) # Prints 7

=={{header|Kotlin}}==

The following example may help to make some of this clear. Although the Kotlin types have been specified to help with this, in practice they would usually be omitted and inferred by the compiler.

import kotlinx.cinterop.*

println(intArray[2]) // print the last element

nativeHeap.free(intArray) // free native memory

Sample output:

=={{header|Lua}}==

Lua does not have pointers but it is worth remembering that assigning a table to a new variable creates a reference to that table, not a copy of it.

local table2 = table1

table2[3] = 4

{{out}}

<pre>1 2 4</pre>

Read Statement get a weak reference and make it a normal reference. Variable X can't get new reference. We can't get reference from an item in a container (array, inventory, stack)

A=10

Module Beta {

Beta &A

Print A=11

====Reference for Functions/lambdas====

Module TestFuncRef {

Function Alfa(x) {

}

TestFuncRef

===Weak Reference using Strings===

Every time we use the string as weak reference, interpreter make resolve to reference. See point after $, A weak reference can be change any time. We can pass array items using Weak$() to get the right reference.

A=10

Dim A(10)=1

Beta Weak$(A(2))

Print A(2)=2

===Pointer of Com Object===

We can declare objects (Com type) and we get a pointer, but that pointer leave until the end of module, which we create the pointer. We may declare properties for these objects, and also that properties use smart pointers, so the com object has only one pointer, which deleted at the exit of module (where created). Com objects are internal GUI objects. We use Method to call methods and return values. We can use With to read, set values, and to bound properties to names. In the example below we make Title$ as property "Title" of form Form1. We can use Nothing to delete objects (names can't get another object), it is optional, but has to do with the release of resource, and when happen. For forms it is better to use it as in the example below.

Module ShowModalFormWithCLock {

Declare Form1 Form

}

ShowModalFormWithCLock

===Pointer of Container===

There are three containers, Arrays, Inventories and Stacks. Arrays have two interfaces, the value one and the pointer one. The value one has parenthesis in the name. Containers may have items other containers. Usually containers combined with functions and statements, but because they are COM objects (but pointers inside work different from other Com objects), we can use statemends Method and With as for com objects.

Module CheckArray {

\\ This is a value type array

}

CheckArray

===Pointers of Groups===

Groups are value types, but we can make pointers for them. Assigning a Group to a Group we get a combination, the group at the left get all the members of the group at the right (except the situation we have define a Set function for Group, and handle the assignment as we wish, or not defined it but define a value function so interpreter treat it as read only and throw error).

Module GroupPointers {

Group Zeta {

}

GroupPointers

====Reference of members of Groups====

We can pass reference from group members, if group has a name.

Module CheckGroupRef {

Group TestMe {

}

CheckGroupRef

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

Here is an example of a traced reference to an integer.

VAR intref := NEW(IntRef);

The <tt>^</tt> character is the dereference operator, and is suffixed to the reference variable name.

===REFANY===

The built-in type <tt>REFANY</tt> is of type <tt>REF T</tt>, which is the "root" reference type, and can be a reference of any type.

===TYPECASE===

To determine the type of a variable, you can use <tt>TYPECASE</tt>.

VAR sum := 0.0;

BEGIN

END;

RETURN sum;

=={{header|Nim}}==

Create a safe reference:

x, y: float

var f: Foo

Accessing the reference:

When accessing values the dereference operator [] can be left out:

f[].y = 12

echo f.y

Create an (unsafe) pointer to an int variable:

Access the integer variable through the pointer:

Change the pointer to refer to another object:

Change the pointer to not point to any object:

=={{header|OCaml}}==

If you just want a simple mutable "variable" (since variables in OCaml are immutable), you can allocate a ''reference'' (a simple mutable data structure with one field; not the same meaning as the "references" in other languages) with an initial value, read from it, and write to it:

let p = ref 1;; (* create a new "reference" data structure with initial value 1 *)

let k = !p;; (* "dereference" the reference, returning the value inside *)

p := k + 1;; (* set the value inside to a new value *)

(The OCaml web-site provides this [http://caml.inria.fr/resources/doc/guides/pointers.en.html page] on the subject.)

If the object that a reference is pointing to is mutable (i.e. it has methods that allows changing of its internal variables), then it is possible to modify that object's state through the reference; and someone else who has a reference to the same object will see that modification. (Note: this does not change the reference itself, just the object that it points to.) Let us consider a simple class of mutable object:

::class Foo

::method init

a~x = 5 -- modifies the X variable inside the object pointer to by a

say b~x -- displays "5" because b points to the same object as a

ooRexx is call-by-value. When passing arguments, you are passing object references by value. There is no such thing as "passing an object" as objects are not values in the language. As noted above, if the object that the reference is pointing to is mutable, then it is possible to modify that object's state through the reference. Then if the calling function has a reference to the same object, they will see that modification through the reference. So if you want to reflect changes in an argument back to the caller, one thing that you can do is wrap the argument as an attribute of an object, then modify the object through the reference.

<br>

<br>With the Use Arg instruction, a subroutine get access to the caller's argument object by reference:

a.3=3

Say 'Before Call sub: a.3='a.3

Say 'in sub2: a.='a.

Say 'in sub2: a.3='a.3 -- this changes the local a.

{{out}}

<pre>Before Call sub: a.3=3

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

Some built-in functions like <code>issquare</code> have pointer arguments:

issquare(9,&n);

{{Works with|PARI/GP|2.12.0}}

User functions and certain built-in functions (listput, listpop, mapput, etc.; all those with [http://pari.math.u-bordeaux.fr/dochtml/html-stable/usersch5.html#GP-prototypes-parser-codes parser code] W) can take arguments by reference with the prefix ~ operator:

S=List();

boxit(S,1);

{{out}}

<pre>1</pre>

Pascal does not support pointer operations on the stack.

In fact, Pascal does not even “know” there is a stack.

type

released after `program` termination.

}

Furthermore, <tt>new</tt> and <tt>dispose</tt> accept further parameters if the pointer variable’s domain type is a variant <tt>record</tt> (or, in Extended Pascal, a schema).

This permits the processor to allocate memory merely for the specified variant (or, in Extended Pascal, a discriminant), but also forbids you to change the variant (of a <tt>record</tt>).

It is imperative the selectors in <tt>dispose</tt> match to the corresponding <tt>new</tt>.

type

{ … }

dispose(head, true);

As a special case of pointers, functions and procedures can be passed as parameters to routines.

procedure foo(function f: Boolean);

begin

foo(bar);

=={{header|Perl}}==

Perl has "references" that roughly correspond with "smart pointers" of C-like languages. Due to reference-counting semantics, they can never point to something that does not exist. Any scalar container (which includes array elements and hash values, but not hash keys) can hold a reference to a data structure.

my $scalar = 'aa';

my @array = ('bb', 'cc');

my $scalarref = \$scalar;

my $arrayref = \@array;

Using a reference

print $$scalarref; # 'aa'

print @$arrayref; # 'bbcc'

$$scalarref = 'a new string'; # changes $scalar

$arrayref->[0] = 'foo'; # changes the first value of @array

You may also create anonymous references:

my $arrayref = ['an', 'array'];

=={{header|Phix}}==

Phix does not have pointers, other than for playing with raw allocated memory, typically for interfacing with another language pre-compiled into a dll/so, although for that builtins/cffi.e offers a more grown-up mechanism with seamless 32/64 bit portability. There is no pointer math beyond sizes in bytes.

<span style="color: #004080;">atom</span> <span style="color: #000000;">addr</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">allocate</span><span style="color: #0000FF;">(</span><span style="color: #000000;">8</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (assumes 32 bit)</span>

<span style="color: #7060A8;">poke4</span><span style="color: #0000FF;">(</span><span style="color: #000000;">addr</span><span style="color: #0000FF;">,{</span><span style="color: #004600;">NULL</span><span style="color: #0000FF;">,</span><span style="color: #000000;">SOME_CONSTANT</span><span style="color: #0000FF;">})</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">peek4s</span><span style="color: #0000FF;">({</span><span style="color: #000000;">addr</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">})</span> <span style="color: #000080;font-style:italic;">-- prints {x,y}</span>

<span style="color: #7060A8;">free</span><span style="color: #0000FF;">(</span><span style="color: #000000;">addr</span><span style="color: #0000FF;">)</span>

There are in fact 5 variants of poke: poke1, poke2, poke4, poke8, and pokeN which allows the size to be dynamically specified.

You can, of course use pointers via inline assembly (but only as a last resort/if you are mental enough):

#ilASM{

fldpi

lea rdi,[mypi]

[]

or

#ilASM{

[32]

lea rsi,[rbx+rsi*4] -- byte[rsi] is 'm'

[]

Of course in a reference counted language like Phix, playing directly with the innards like that may have dire unexpected side effects.

Phix does not have references, however everything is passed by reference, with copy-on-write semantics. Unless the source and destination are the same, and it is local, so it cannot possibly be referenced elsewhere, in which case automatic pass-by-reference is used, which for Phix means skipping the reference counting. For example:

<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span>

<span style="color: #0000FF;">...</span>

<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">myfunc</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

It is a general optimisation, applied by the complier whenever and wherever it can, without the programmer having to do anything special.

As an additional note, the "global" keyword, simply references the variable from the $_GLOBALS superglobal array into a variable by the same name in the current scope. This is an important distinction as other functions that you call can actually re-reference the $_GLOBALS value to a different variable, and your function which used the "global" keyword is no longer actually linked to anything in the $_GLOBALS array.

/* Assignment of scalar variables */

$a = 1;

pass_in($tmp); // changes $tmp and prints the length

In most cases, PHP "does the right thing" as pertaining to variables and not duplicating variables in memory that have not been edited. Internally, as variables are copied from one to another, passed in and out of functions, etc, they are Not actually duplicated in memory, but rather referenced until one of these copies is changed (called "copy on write", see debug_zval_dump()). So, in the above functions example, if we took out all the ampersands, it would all work perfectly and not duplicate the big string in memory up until the line where we concatenate and add "EDIT" to the end.

'[http://software-lab.de/doc/refN.html#nth nth]', which advance the pointer to

the next (linked to) location(s).

-> (1 a 2 b 3 c)

: L # Look at the modified list in 'L'

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

* control statements: ALLOCATE, FREE

Simple examples:

dcl i fixed bin(31);

dcl p pointer;

p=addr(i1); t=addr(i2), q=addr(p); s=addr(t);

q->p->j = s->t->k + 3; /* to say i1=i2+3 */

=={{header|Pop11}}==

A pointer's name is preceded by an '*' and are variables of type integer that can hold an address (either 32-bit or 64-bit depending on the OS compiled for), and do not differ from other integer variables in this respect. Pointers can be declared as pointing to structured memory and allow that memory to be de-referenced to allow easier manipulation of its contents.

The following code creates a pointer to an integer variable:

*myInteger = @varA ;set pointer to address of an integer variable

Change pointer to refer to another integer variable:

Change pointer to not point to anything:

Get a pointer to the first element of an array, or any desired element:

*myInteger = myArray()

;Or alternatively:

*myInteger = @myArray(0)

;any specific element

PureBasic does not provide pointer arithmetic but it does allow integer math operations on its pointers. This makes it easy to implement a variety of pointer arithmetic with the help of the compiler function <tt>SizeOf()</tt>.

In a similar manner the compiler function <tt>OffsetOf()</tt> may also be used to obtain the memory offset for an sub-element of a structure if needed:

id.i

name.s

;set a string pointer to the 6th job of the 4th employee

===Addresses of variables or procedure===

Addresses to variables and functions are obtained with the '@' operator.

===Addresses of labels===

To find the address of a label, you put a question mark (?) in front of the label name.

text$="'Lab' is at address "+Str(?lab)

MessageRequester("Info",text$)

Data.i 3,1,4,5,9,2,1,6

lab2:

=={{header|Python}}==

Python does not have pointers and all Python names (variables) are implicitly references to objects. Python is a late-binding dynamic language in which "variables" are untyped bindings to objects. (Thus Pythonistas prefer the term '''name''' instead of "variable" and the term '''bind''' in lieu of "assign").

a = "foo"

# Bind an empty list to another name:

# Call (anymous function object) from inside a list

b[0]("foo") # Note that the function object we original bound to the name "a" continues to exist

[Note: in some ways this task is meaningless for Python given the nature of its "variable" binding semantics].

As in many other functional languages, Racket doesn't have pointers to its own values. Instead, Racket uses "boxes" that are similar to "ref" types in *ML:

#lang racket

(inc! b)

(unbox b) ; => 3