Pointers and references: Difference between revisions

{{Task|Basic Data Operations}}{{basic data operation}}In this task, the goal is to demonstrate common operations on pointers and references. These examples show pointer operations on the stack, which can be dangerous and is rarely done. Pointers and references are commonly used along with [[Memory allocation]] on the [[heap]].

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

 

 

 

 

 

 

 

 

 

=={{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

 

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

 

 

 

 

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

 

 

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

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

 

 

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

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

 

MOVE.W #$0C,D0

 

 

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

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

 

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

 

 

===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.

 

 

=={{header|Ada}}==

 

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

 

=={{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.

 

=={{header|Julia}}==

 

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>

 

=={{header|Pascal}}==

 

=={{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

 

In addition, Racket has a representation of traditional C pointers as part of its FFI, but this is intended only for dealing with foreign code.

In Raku all non-native values are boxed and accessed via implicit references. (This is like Java or Python, but unlike C or Perl 5, which use explicit referencing and dereferencing.) Variables are references to containers that can contain references to other values. Basic binding (aliasing) of references to names is supported via the <tt>:=</tt> operator, while assignment to mutable containers implies a dereference from the name to the container, followed by copying of values rather than by duplicating pointers. (Assignment of a bare object reference copies the reference as if it were a value, but the receiving container automatically dereferences as necessary, so to all appearances you are putting the object itself into the destination rather than its reference, and we just think the object can be in more than one place at the same time.)

 

$foo++; # deref $foo name, then increment the container's contents to 43

$foo.say; # deref $foo name, then $foo's container, and call a method on 43.

 

@bar := (1,2,3); # bind name directly to a List

References to hashes and functions work more like arrays, insofar as a method call acts directly on the container, not on what the container contains. That is, they don't do the extra dereference implied by calling a method on a scalar variable.

 

 

=={{header|SAS}}==

data _null_;

length a b c $4;

call poke(b,adr_c,1);

put a b c;

 

=={{header|Scala}}==

Shale pointers must point to a Shale object, effected by the pointer assignment operator (&=). Referencing the objected pointed to is done with the dereference operator (->).

 

 

aVariable var // Create aVariable

 

// Shale pointers can point to any Shale object, like numbers, strings, variables

 

{{out}}

=={{header|Sidef}}==

A simple example of passing a variable-reference to a function:

*ref = value;

}

var x = 10;

assign2ref(\x, 20);

 

=={{header|Standard ML}}==

Like OCaml, Standard ML doesn't have pointers but have a "ref" mutable data structure which is the basis of mutability in Standard ML:

 

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

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

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

 

=={{header|Tcl}}==

Tcl does not have pointers, however, if required, a similar level of indirection can be had by storing a variable name in another variable, e.g.:

set pointer var; # assign name "var" not value 3

set pointer; # returns "var"

set $pointer; # returns 3

In practice it's safer and more convenient to use array keys or the <tt>upvar</tt> command, e.g.:

set pointer var

set arr($pointer); # returns 3

set pointer var

upvar 0 $pointer varAlias; # varAlias is now the same variable as var

This second technique is most commonly used between stack levels (i.e., with the first argument to <tt>upvar</tt> being 1) so that a local variable of one procedure can be manipulated in another utility procedure that it calls.

 

=={{header|VBA}}==

Formally VBA does not have pointers or references. Objects are created with the "New" keyword, and assignments require the keyword "Set". Getting the memory address of a pointer is not documented in VBA.

Dim anothervariable as Object

 

=={{header|Wren}}==

 

The following example illustrates the difference by passing both value and reference type parameters to a function. Note that in Wren parameters are always passed by value.

// The value and the reference are copied to their respective parameters.

var f = Fn.new { |s, l|

f.call(s, l)

System.print(l)

 

{{out}}

 

=={{header|XPL0}}==

\This creates a pointer to an integer variable:

int Var, Ptr, V;

V:= Ptr(3); \get third item after Array(1), i.e. Array(4)

V:= Ptr(-1); \get item immediately preceding Array(1), i.e. Array(0)

 

=={{header|zkl}}==

Pointers don't exist and neither do conventional references but mutable containers can act like references: List, Ref (strong reference), GarbageMan.WeakRef (weak reference) and others.

A Ref can hold any value. inc is a special case convenience for numbers.

Weak refs can hold anything the garbage collect can see. You can only look at the value, not change it. If it should hold a Ref or List, you can change those. The contents of a Weak Ref will vaporize sometime after the contents are no longer visible.