Pointer (computer programming)

C pointers

In C, the basic syntax to define a pointer is:^[4]

int *ptr;

This declares a variable ptr that stores a pointer to an object of type int. Other types can be used in place of int; for example, bool *ptr would declare a pointer to an object of type bool.

After a pointer has been declared, it can be assigned an address. In C, the address of a variable can be retrieved with the & unary operator:

// Declare a variable for a pointer to int
int *ptr;
// Declare a variable for an int
int a = 5;
// Assign the address of a to the pointer variable
ptr = &a;

To dereference the pointer, yielding the object it points to, an asterisk (*) can be used:

printf("%d\n", *ptr);
// Prints: 5

There are two styles of declarations of a pointer-to-int named ptr:

• int *ptr;, which emphasises that the expression *ptr has type int.^[5]
• int* ptr;, which emphasises that ptr has type int*. This style is more prevalent in C++ than C.^[6][7]

Both int *x, y; and int* x, y; declare x to be a pointer to int, but declare y to be an int. This is because the * applies only to the variable immediately following it.^[5]

The asterisk can also be used on the left-hand side of an assignment to change the object a without having to be in the same scope.

*ptr = 8;

If a is accessed later, its new value will be 8.

Because the C language does not specify an implicit initialization for objects of automatic storage duration,^[8] pointer variables can sometimes point to unexpected locations, causing undefined behavior. To combat this, pointers are sometimes initialized with a null pointer value, represented in C by the NULL macro;^[9] in C23 and later, nullptr is also available as an alternative, which is of type nullptr_t.^[10]

int *ptr = NULL;
int *ptr = nullptr; // since C23

Dereferencing a null pointer produces undefined behavior,^[11] which can result in unpredictable bugs and results.

This example may be clearer if memory is examined directly. Assume that a is located at address 0x8130 in memory and ptr at 0x8134; also assume this is a 32-bit machine such that an int is 32-bits wide. The following is what would be in memory after the following code snippet is executed:

int a = 5;
int *ptr = NULL;

(The null pointer shown here is 0x00000000.) By assigning the address of a to ptr:

ptr = &a;

yields the following memory values:

Then by dereferencing ptr by coding:

*ptr = 8;

the computer will take the contents of ptr (which is 0x8130), 'locate' that address, and assign 8 to that location yielding the following memory:

Clearly, accessing a will yield the value of 8 because the previous instruction modified the contents of a by way of the pointer ptr.

Use in data structures

When setting up data structures like lists, queues and trees, it is necessary to have pointers to help manage how the structure is implemented and controlled. Typical examples of pointers are start pointers, end pointers, and stack pointers. These pointers can either be absolute (the actual physical address or a virtual address in virtual memory) or relative (an offset from an absolute start address ("base") that typically uses fewer bits than a full address, but will usually require one additional arithmetic operation to resolve).

Relative addresses are a form of manual memory segmentation, and share many of its advantages and disadvantages. A two-byte offset, containing a 16-bit, unsigned integer, can be used to provide relative addressing for up to 64 KiB (2¹⁶ bytes) of a data structure. This can easily be extended to 128, 256 or 512 KiB if the address pointed to is forced to be aligned on a half-word, word or double-word boundary (but, requiring an additional "shift left" bitwise operation—by 1, 2 or 3 bits—in order to adjust the offset by a factor of 2, 4 or 8, before its addition to the base address). Generally, though, such schemes are a lot of trouble, and for convenience to the programmer absolute addresses (and underlying that, a flat address space) is preferred.

A one byte offset, such as the hexadecimal ASCII value of a character (e.g. X'29') can be used to point to an alternative integer value (or index) in an array (e.g., X'01'). In this way, characters can be very efficiently translated from 'raw data' to a usable sequential index and then to an absolute address without a lookup table.

int a[5]; // Declares 5 contiguous integers
int *ptr = a; // Array names in expressions evaluate to pointers in most cases
ptr[0] = 1; // Pointers can be indexed with array syntax
*(a + 1) = 2; // Arrays can be indexed with pointer syntax
*(1 + a) = 2; // Pointer addition is commutative
2[a] = 4; // Subscript operator is commutative (perhaps unusual)

int a[5] = {2, 4, 3, 1, 5};

struct LinkedList {
    void *data; // data of this link
    struct LinkedList *next; // next link; NULL if there is none
};

data LinkedList a
    = Nil
    | Cons a (LinkedList a)

Pass-by-address using pointers

Pointers can be used to pass variables by their address, allowing their value to be changed. For example, consider the following C code:

// a copy of the int n can be changed within the function without affecting the calling code
void passByValue(int n) {
    n = 12;
}

// a pointer m is passed instead. No copy of the value pointed to by m is created
void passByAddress(int *m) {
    *m = 14;
}

int main(void) {
    int x = 3;

    // pass a copy of x's value as the argument
    passByValue(x);
    // the value was changed inside the function, but x is still 3 from here on

    // pass x's address as the argument
    passByAddress(&x);
    // x was actually changed by the function and is now equal to 14 here

    return 0;
}

Dynamic memory allocation

In some programs, the required amount of memory depends on what the user may enter. In such cases the programmer needs to allocate memory dynamically. This is done by allocating memory at the heap rather than on the stack, where variables usually are stored (although variables can also be stored in the CPU registers). Dynamic memory allocation can only be made through pointers, and names – like with common variables – cannot be given.

Pointers are used to store and manage the addresses of dynamically allocated blocks of memory. Such blocks are used to store data objects or arrays of objects. Most structured and object-oriented languages provide an area of memory, called the heap or free store, from which objects are dynamically allocated.

The example C code below illustrates how structure objects are dynamically allocated and referenced. The standard C library provides the function malloc() for allocating memory blocks from the heap. It takes the size of an object to allocate as a parameter and returns a pointer to a newly allocated block of memory suitable for storing the object, or it returns a null pointer if the allocation failed.

// Parts inventory item
typedef struct {
    int id; // Part number
    char *name; // Part name
    float cost; // Cost
} Item;

// Allocate and initialize a new Item object
Item *makeItem(const char *name) {
    Item *item;

    // Allocate a block of memory for a new Item object
    item = malloc(sizeof(*item));
    if (!item) {
        return NULL;
    }

    // Initialize the members of the new Item
    memset(item, 0, sizeof(*item));
    item->id = -1;
    item->name = NULL;
    item->cost = 0.0;

    // Save a copy of the name in the new Item 
    item->name = malloc(strlen(name) + 1);
    if (!item->name) {
        free(item);
        return NULL;
    }
    strcpy(item->name, name);

    // Return the newly created Item object
    return item;
}

The code below illustrates how memory objects are dynamically deallocated, i.e., returned to the heap or free store. The standard C library provides the function free() for deallocating a previously allocated memory block and returning it back to the heap.

// Deallocate an Item object
void destroyItem(Item *item) {
    // Check for a null object pointer
    if (!item) {
        return;
    }

    // Deallocate the name string saved within the Item
    if (item->name) {
        free(item->name);
        item->name = NULL;
    }

    // Deallocate the Item object itself
    free(item);
}

Memory-mapped hardware

On some computing architectures, pointers can be used to directly manipulate memory or memory-mapped devices.

Assigning addresses to pointers is an invaluable tool when programming microcontrollers. Below is a simple example declaring a pointer of type int and initialising it to a hexadecimal address in this example the constant 0x7FFF:

int *hardware_address = (int *)0x7FFF;

In the mid-1980s, using the BIOS to access the video capabilities of PCs was slow. Applications that were display-intensive typically used to access CGA video memory directly by casting the hexadecimal constant 0xB8000 to a pointer to an array of 80 unsigned 16-bit int values. Each value consisted of an ASCII code in the low byte, and a colour in the high byte. Thus, to put the letter 'A' at row 5, column 2 in bright white on blue, one would write code like the following:

#define VID ((unsigned short (*)[80])0xB8000)

void foo(void) {
    VID[4][1] = 0x1F00 | 'A';
}

Use in control tables

Control tables that are used to control program flow usually make extensive use of pointers. The pointers, usually embedded in a table entry, may, for instance, be used to hold the entry points to subroutines to be executed, based on certain conditions defined in the same table entry. The pointers can however be simply indexes to other separate, but associated, tables comprising an array of the actual addresses or the addresses themselves (depending upon the programming language constructs available). They can also be used to point to earlier table entries (as in loop processing) or forward to skip some table entries (as in a switch or "early" exit from a loop). For this latter purpose, the "pointer" may simply be the table entry number itself and can be transformed into an actual address by simple arithmetic.

Value of pointers

In C and C++, even if two pointers compare as equal that doesn't mean they are equivalent. In these languages and LLVM, the rule is interpreted to mean that "just because two pointers point to the same address, does not mean they are equal in the sense that they can be used interchangeably", the difference between the pointers referred to as their provenance.^[15] Casting to an integer type such as uintptr_t is implementation-defined and the comparison it provides does not provide any more insight as to whether the two pointers are interchangeable. In addition, further conversion to bytes and arithmetic will throw off optimizers trying to keep track the use of pointers, a problem still being elucidated in academic research.^[16]

Kinds defined by value

int func(void) {
    char *p1 = malloc(sizeof(char)); // (undefined) value of some place on the heap
    char *p2; // dangling (uninitialized) pointer
    *p1 = 'a'; // This is OK, assuming malloc() has not returned NULL.
    *p2 = 'b'; // This invokes undefined behavior
}

Kinds defined by structure

Kinds defined by use or datatype

typedef struct LinkedList {
    int value;
    struct LinkedList *next;
} LinkedList;

LinkedList *head = NULL;

// Given a sorted list at *head, insert the element item at the first
// location where all earlier elements have lesser or equal value.
void insert(LinkedList **head, LinkedList *item) {
    // p points to a pointer to an element
    LinkedList **p = head;
    while (*p && (*p)->value < item->value) {
        p = &(*p)->next;
    }
    item->next = *p;
    *p = item;
}

// Caller does this:
insert(&head, item);

// Function with two integer parameters returning an integer value
int sum(int n1, int n2) {   
    return n1 + n2;
}

int main(void) {
    int a = 3;
    int b = 5;
    // Function pointer to a function (int, int) -> int
    // and points to function sum
    int (*fp)(int, int) = ∑
    int x = (*fp)(a, b); // Calls function sum with arguments a and b
    int y = sum(a, b); // Calls function sum with arguments a and b
}

import std;

using Callback = void(*)(int);

void process(int a, int b, Callback cb) {
    callback(a + b);
}

void printResult(int result) {
    std::println("Result: {}", result);
}

int main(int argc, char* argv[]) {
    // using the traditional function pointer:
    process(1, 2, printResult);
    // prints: "Result: 3"

    // using a lambda:
    process(3, 4, [](int result) -> void { std::println("Result: {}"); });
    // prints: "Result: 7"
}

Ada

Ada is a strongly typed language where all pointers are typed and only safe type conversions are permitted. All pointers are by default initialized to null, and any attempt to access data through a null pointer causes an exception to be raised. Pointers in Ada are called access types. Ada 83 did not permit arithmetic on access types (although many compiler vendors provided for it as a non-standard feature), but Ada 95 supports “safe” arithmetic on access types via the package System.Storage_Elements.

BASIC

Several old versions of BASIC for the Windows platform had support for STRPTR() to return the address of a string, and for VARPTR() to return the address of a variable. Visual Basic 5 also had support for OBJPTR() to return the address of an object interface, and for an ADDRESSOF operator to return the address of a function. The types of all of these are integers, but their values are equivalent to those held by pointer types.

Newer dialects of BASIC, such as FreeBASIC or BlitzMax, have exhaustive pointer implementations, however. In FreeBASIC, arithmetic on ANY pointers (equivalent to C's void *) are treated as though the ANY pointer was a byte width. ANY pointers cannot be dereferenced, as in C. Also, casting between ANY and any other type's pointers will not generate any warnings.

dim as integer f = 257
dim as any ptr g = @f
dim as integer ptr i = g
assert(*i = 257)
assert( (g + 4) = (@f + 1) )

C

In C pointers are variables that store addresses and can be null. Each pointer has a type it points to, but one can freely cast between pointer types. However, it is not possible to cast between a function pointer and an object pointer. A special pointer type called the "void pointer" allows pointing to any (non-function) object, but is limited by the fact that it cannot be dereferenced directly. The address itself can often be directly manipulated by casting a pointer to and from an integral type of sufficient size, though the results are undefined; while earlier C standards did not have an integral type that was guaranteed to be large enough, C99 specifies the uintptr_t type defined in <stdint.h>, but an implementation need not provide it.

Pointer arithmetic, that is, the ability to modify a pointer's target address with arithmetic operations (as well as magnitude comparisons), is restricted by the language standard to remain within the bounds of a single array object or just after it, and will otherwise invoke undefined behavior. Adding or subtracting from a pointer moves it by a multiple of the size of its datatype. For example, adding 1 to a pointer to 4-byte integer values will increment the pointer's pointed-to byte-address by 4. This has the effect of incrementing the pointer to point at the next element in a contiguous array of integers—which is often the intended result. Pointer arithmetic cannot be performed on void pointers because the void type has no size, and thus the pointed address cannot be added to, although gcc and other compilers will perform byte arithmetic on void * as a non-standard extension, treating it as if it were char *.

Pointer arithmetic provides the programmer with a single way of dealing with different types: adding and subtracting the number of elements required instead of the actual offset in bytes. In particular, the C standard explicitly declares that the syntax a[n], which is the n-th element of the array a, is equivalent to *(a + n), which is the content of the element pointed by a + n. This implies that, for example, a[3] and 3[a] both access the fourth element of the array a.

While powerful, pointer arithmetic can be a source of computer bugs. It tends to confuse novice programmers, forcing them into different contexts: an expression can be an ordinary arithmetic one or a pointer arithmetic one, and sometimes it is easy to mistake one for the other. In response to this, many modern high-level computer languages do not permit direct access to memory using addresses.

The void pointer, or void *, is supported in ANSI C as a generic pointer type. A pointer to void can store the address of any object (not function),^[a] and, is implicitly converted to any other object pointer type on assignment, but it must be explicitly cast if dereferenced. Before ANSI C, K&R used char * for the "type-agnostic pointer" purpose.

int x = 4;
void *p1 = &x;
int *p2 = p1; // void * implicitly converted to int *
int a = *p2;
int b = *(int *)p1; // when dereferencing inline, there is no implicit conversion

C++

C++ fully supports C pointers and C typecasting. It also supports a new group of typecasting operators to help catch some unintended dangerous casts at compile-time. C++ also supports another form of reference, quite different from a pointer, called simply a reference or reference type.

Since C++11, the C++ standard library also provides smart pointers, which can be used in some situations as a safer alternative to primitive C pointers.

• std::unique_ptr (represents unique ownership of a resource, cannot be copied but can be moved)
• std::shared_ptr (represents shared ownership of a resource, resource is only deleted once the last shared pointer is destroyed or reset)
• std::weak_ptr (represents no ownership, can point to a shared pointer's resources without incrementing the reference count)
• std::hazard_pointer (single-writer multi-reader pointer that may be owned by at most one thread at any point of time)

std::unique_ptr replaces the previous smart pointer std::auto_ptr, which was deprecated in C++11 and removed in C++17.

In contrast to C, C++ does not allow the implicit conversion of void* to other pointer types, even in assignments. This was a design decision to avoid careless and even unintended casts, though most compilers only output warnings, not errors, when encountering other casts.

int x = 4;
void* p1 = &x;
int* p2 = p1; // this fails: there is no implicit conversion from void*
int* p3 = reinterpret_cast<int*>(p1); // C++ cast

In C++, there is no void& (reference to void) to complement void* (pointer to void), because references behave like aliases to the variables they point to, and there can never be a variable whose type is void.

struct Integer {
    int value;
    
    [[nodiscard]]
    int get() const noexcept {
        return value;
    }
};

Integer s1; // default-constructed, s1.value = 0
Integer* ps = &s1;

int Integer::* ptr = &Integer::value; // pointer to Integer::value
int (Integer::* fp)() const = &Integer::get; // pointer to Integer::get

s1.*ptr = 1;
std::println("{}", (s1.*fp)()); // prints 1
ps->*ptr = 2;
std::println("{}", (ps->*fp)()); // prints 2

class X {
    // ...
};

class Y {
    // ...
};

char X::* a; // pointer-to-member to char
char X::* b[5]; // array of pointers-to-member to char 
char* X::* c; // pointer-to-member to pointer to char(s)
char X::** d; // pointer to pointer-to-member to char 
char (*e)[5]; // pointer-to-member to array(s) of chars 
char X::* f(); // function which returns a pointer-to-member to char
char Y::* X::* g; // pointer-to-member to pointer-to-member to pointer to char(s)
char X::* X::* h; // pointer-to-member to pointer-to-member to pointer to char(s)
char (X::* i())[5]; // function which returns pointer-to-member to an array of chars
char (X::* j)() // pointer-to-member-function which returns a char
char (X::* k[5])(); // an array of pointers-to-member-functions which return a char

C#

In the C# programming language, pointers are supported by either marking blocks of code that include pointers with the unsafe keyword, or through the System.Runtime.CompilerServices namespace for pointer access. The syntax is essentially the same as in C++, and the address pointed can be either managed or unmanaged memory. However, pointers to managed memory (any pointer to a managed object) must be declared using the fixed keyword, which prevents the garbage collector from moving the pointed object as part of memory management while the pointer is in scope, thus keeping the pointer address valid.

However, an exception to this is from using the IntPtr structure, which is a memory managed equivalent to int*, and does not require the unsafe keyword nor the CompilerServices assembly. This type is often returned when using methods from the System.Runtime.InteropServices, for example:

using System;
using System.Runtime.InteropServices;

// Get 16 bytes of memory from the process's unmanaged memory
IntPtr pointer = Marshal.AllocHGlobal(16);

// Do something with the allocated memory

// Free the allocated memory
Marshal.FreeHGlobal(pointer);

The .NET framework includes many classes and methods in the System and System.Runtime.InteropServices namespaces (such as the Marshal class) which convert .NET types (for example, System.String) to and from many unmanaged types and pointers (for example, LPWSTR or void*) to allow communication with unmanaged code. Most such methods have the same security permission requirements as unmanaged code, since they can affect arbitrary places in memory.

C# allows stack-allocated arrays in safe code using System.Span.^[24]

namespace Wikipedia.Examples;

using System;

public class Example
{
    static void Main(string[] args)
    {
        int num = 1024;
        unsafe 
        {
            // convert an int into bytes by creating a byte pointer
            byte* p = (byte*)&number;
            Console.Write("The 4 bytes of the integer are: ");
            for (int i = 0; i < sizeof(int); ++i)
            {
                Console.Write(" {0:X2}", *p);
                ++p;
            }
            Console.WriteLine();
        }

        // Stack-allocated arrays can be done either through pointers or Span<T>
        unsafe
        {
            int* numbers = stackalloc int[5];
        }
        Span<int> numbers = stackalloc int[5];
    }
}

C#, like C and C++, also has a void* (void pointer) type, but it is highly unrecommended.^[25]

Unlike C and C++, right-aligned asterisks are not accepted by the compiler. For example:

int* a, b;
int *a, *b; // illegal in C#

In C and C++, this would declare a as int* and b as int, but in C# this declares both variables as int*.^[25]

COBOL

The COBOL programming language supports pointers to variables. Primitive or group (record) data objects declared within the LINKAGE SECTION of a program are inherently pointer-based, where the only memory allocated within the program is space for the address of the data item (typically a single memory word). In program source code, these data items are used just like any other WORKING-STORAGE variable, but their contents are implicitly accessed indirectly through their LINKAGE pointers.

Memory space for each pointed-to data object is typically allocated dynamically using external CALL statements or via embedded extended language constructs such as EXEC CICS or EXEC SQL statements.

Extended versions of COBOL also provide pointer variables declared with USAGE IS POINTER clauses. The values of such pointer variables are established and modified using SET and SET ADDRESS statements.

Some extended versions of COBOL also provide PROCEDURE-POINTER variables, which are capable of storing the addresses of executable code.

PL/I

The PL/I language provides full support for pointers to all data types (including pointers to structures), recursion, multitasking, string handling, and extensive built-in functions. PL/I was quite a leap forward compared to the programming languages of its time.^{[citation needed]} PL/I pointers are untyped, and therefore no casting is required for pointer dereferencing or assignment. The declaration syntax for a pointer is DECLARE xxx POINTER;, which declares a pointer named "xxx". Pointers are used with BASED variables. A based variable can be declared with a default locator (DECLARE xxx BASED(ppp); or without (DECLARE xxx BASED;), where xxx is a based variable, which may be an element variable, a structure, or an array, and ppp is the default pointer). Such a variable can be address without an explicit pointer reference (xxx=1;, or may be addressed with an explicit reference to the default locator (ppp), or to any other pointer (qqq->xxx=1;).

Pointer arithmetic is not explicitly part of the PL/I standard, but the UNSPEC builtin function and pseudo-variable allow pointer arithmetic and many compilers allow expressions of the form ptr = ptr±expression. IBM PL/I also has the builtin function PTRADD to perform the arithmetic. Pointer arithmetic is always performed in bytes.

IBM Enterprise PL/I compilers have a new form of typed pointer called a HANDLE. Handles are essentially typed pointers.

D

The D programming language is a derivative of C and C++ which fully supports C pointers and C typecasting. It supports pointer arithmetic, and also has pointer slices. A pointer in D can decay to void* implicitly.^[26]

In D, it is possible to use ref for a reference, which automatically dereferences, disallows pointer arithmetic, and does not allow escaping a function (i.e. through return).

A pointer slice can be seen as a pointer with a length.

import std.stdio;

void main() {
    int[] arr = [10, 20, 30, 40, 50];
    int* ptr = &arr[0];
    int[] slice = ptr[0 .. 3]; // Slice the array from index 0 to 3 (exclusive)
    writeln("Slice: ", slice); // Output: Slice: [10, 20, 30]
}

Eiffel

The Eiffel object-oriented language employs value and reference semantics without pointer arithmetic. Nevertheless, pointer classes are provided. They offer pointer arithmetic, typecasting, explicit memory management, interfacing with non-Eiffel software, and other features.

Fortran

Fortran-90 introduced a strongly typed pointer capability. Fortran pointers contain more than just a simple memory address. They also encapsulate the lower and upper bounds of array dimensions, strides (for example, to support arbitrary array sections), and other metadata. An association operator, => is used to associate a POINTER to a variable which has a TARGET attribute. The Fortran-90 ALLOCATE statement may also be used to associate a pointer to a block of memory. For example, the following code might be used to define and create a linked list structure:

type real_list_t
  real :: sample_data(100)
  type (real_list_t), pointer :: next => null ()
end type

type (real_list_t), target :: my_real_list
type (real_list_t), pointer :: real_list_temp

real_list_temp => my_real_list
do
  read (1,iostat=ioerr) real_list_temp%sample_data
  if (ioerr /= 0) exit
  allocate (real_list_temp%next)
  real_list_temp => real_list_temp%next
end do

Fortran-2003 adds support for procedure pointers. Also, as part of the C Interoperability feature, Fortran-2003 supports intrinsic functions for converting C-style pointers into Fortran pointers and back.

Go

Go has pointers, declared similar to C/C++ pointers but with the asterisk first. For example, a pointer to T is written *T. Unlike C, Go has garbage collection, and disallows pointer arithmetic. Reference types, like in C++, do not exist. Some built-in types, like maps and channels, are boxed (i.e. internally they are pointers to mutable structures), and are initialized using the make function. In an approach to unified syntax between pointers and non-pointers, the arrow (->) operator has been dropped: the dot operator on a pointer refers to the field or method of the dereferenced object. This, however, only works with one level of indirection.

Java

There is no explicit representation of pointers in Java. Instead, more complex data structures like objects and arrays are implemented using references. The language does not provide any explicit pointer manipulation operators. It is still possible for code to attempt to dereference a null reference (null pointer), however, which throws a java.lang.NullPointerException. The space occupied by unreferenced memory objects is recovered automatically by garbage collection at run-time.^[27]

Java provides the classes java.lang.ref.WeakReference and java.lang.ref.PhantomReference, which respectively implement weak references and phantom references.

Modula-2

Pointers are implemented very much as in Pascal, as are VAR parameters in procedure calls. Modula-2 is even more strongly typed than Pascal, with fewer ways to escape the type system. Some of the variants of Modula-2 (such as Modula-3) include garbage collection.

Oberon

Much as with Modula-2, pointers are available. There are still fewer ways to evade the type system and so Oberon and its variants are still safer with respect to pointers than Modula-2 or its variants. As with Modula-3, garbage collection is a part of the language specification.

Pascal

Unlike many languages that feature pointers, standard ISO Pascal only allows pointers to reference dynamically created variables that are anonymous and does not allow them to reference standard static or local variables.^[28] It does not have pointer arithmetic. Pointers also must have an associated type and a pointer to one type is not compatible with a pointer to another type (e.g. a pointer to a char is not compatible with a pointer to an integer). This helps eliminate the type security issues inherent with other pointer implementations, particularly those used for PL/I or C. It also removes some risks caused by dangling pointers, but the ability to dynamically let go of referenced space by using the dispose standard procedure (which has the same effect as the free library function found in C) means that the risk of dangling pointers has not been eliminated.^[29]

However, in some commercial and open source Pascal (or derivatives) compiler implementations —like Free Pascal,^[30] Turbo Pascal or the Object Pascal in Embarcadero Delphi— a pointer is allowed to reference standard static or local variables and can be cast from one pointer type to another. Moreover, pointer arithmetic is unrestricted: adding or subtracting from a pointer moves it by that number of bytes in either direction, but using the Inc or Dec standard procedures with it moves the pointer by the size of the data type it is declared to point to. An untyped pointer is also provided under the name Pointer, which is compatible with other pointer types.

Type
   months = (jan,feb,mar,apr,may,jun,jul,aug,sep,oct,nov,dec);
   calptr = ^Calendar_Type;
   Calendar_Type = record
       Prev,Next: CalPtr;
       Month: Months;
       day: byte;
       year: integer;
       event: string;
   end;

var
   That: ^integer;
   NextCalendar,
   calendar: ^calptr;

begin
    new(calendar)
    calendar^.prev := nil;
    calendar^.next := nil;
    Calendar^.Month := Sep;
    Calendar^.Day := 11;
    Calendar^.Year := 2001;

    new(that);
    That^ := 1;

    New(nextCalendar);
    nextCalendar^.prev := Calendar;
    nextCalendar^.Next := NIL;
    New(Calendar);
...
    Dispose(that);
    Dispose(calendar);
    Dispose(nextCalendar);
  
end;

Perl

The Perl programming language supports pointers, although rarely used, in the form of the pack and unpack functions. These are intended only for simple interactions with compiled OS libraries. In all other cases, Perl uses references, which are typed and do not allow any form of pointer arithmetic. They are used to construct complex data structures.^[31]

Rust

Rust uses references, which are similar to pointers but guaranteed to point to a valid value. Working with raw pointers is less common, generally for low-level systems programming. Raw pointers can only be dereferenced inside an unsafe block.^[32][33][34] Operations with raw pointers are found in std::ptr.

In Rust, there is no null pointer constant. It is instead given by std::ptr::null().

Rust also has several types of smart pointers:

• std::boxed::Box: equivalent to C++'s std::unique_ptr^[35]
• std::rc::Rc: equivalent to a reference-counted single-threaded shared pointer
• std::sync::Arc: equivalent to an atomically reference-counted thread safe shared pointer
• std::rc::Weak: equivalent to C++'s std::weak_ptr^[36]

A pointer to T is written as *const T or *mut T in Rust. The following demonstrates raw pointers in Rust:

fn main() {
    let mut num: i32 = 42;

    let r1 = &num as *const i32;
    let r2 = &mut num as *mut i32;

    unsafe {
        println!("r1 points to: {}", *r1);
        println!("r2 points to: {}", *r2);

        *r2 = 100;
        println!("num is now: {}", num);
    }
}