Pointers

Zig has two kinds of pointers:

  • *T - pointer to exactly one item.
    • Supports deref syntax: ptr.*
  • [*]T - pointer to unknown number of items.
    • Supports index syntax: ptr[i]
    • Supports slice syntax: ptr[start..end]
    • Supports pointer arithmetic: ptr + x, ptr - x
    • T must have a known size, which means that it cannot be c_void or any other opaque type.

These types are closely related to Arrays and Slices:

  • *[N]T - pointer to N items, same as single-item pointer to array.

    • Supports index syntax: array_ptr[i]
    • Supports slice syntax: array_ptr[start..end]
    • Supports len property: array_ptr.len

  • []T - pointer to runtime-known number of items.

    • Supports index syntax: slice[i]
    • Supports slice syntax: slice[start..end]
    • Supports len property: slice.len

Use &x to obtain a single-item pointer:

test.zig

  1. const expect = @import("std").testing.expect;
  3. test "address of syntax" {
  4.     // Get the address of a variable:
  5.     const x: i32 = 1234;
  6.     const x_ptr = &x;
  8.     // Dereference a pointer:
  9.     expect(x_ptr.* == 1234);
  11.     // When you get the address of a const variable, you get a const pointer to a single item.
  12.     expect(@TypeOf(x_ptr) == *const i32);
  14.     // If you want to mutate the value, you'd need an address of a mutable variable:
  15.     var y: i32 = 5678;
  16.     const y_ptr = &y;
  17.     expect(@TypeOf(y_ptr) == *i32);
  18.     y_ptr.* += 1;
  19.     expect(y_ptr.* == 5679);
  20. }
  22. test "pointer array access" {
  23.     // Taking an address of an individual element gives a
  24.     // pointer to a single item. This kind of pointer
  25.     // does not support pointer arithmetic.
  26.     var array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  27.     const ptr = &array[2];
  28.     expect(@TypeOf(ptr) == *u8);
  30.     expect(array[2] == 3);
  31.     ptr.* += 1;
  32.     expect(array[2] == 4);
  33. }
  1. $ zig test test.zig
  2. 1/2 test "address of syntax"... OK
  3. 2/2 test "pointer array access"... OK
  4. All 2 tests passed.

In Zig, we generally prefer Slices rather than Sentinel-Terminated Pointers. You can turn an array or pointer into a slice using slice syntax.

Slices have bounds checking and are therefore protected against this kind of undefined behavior. This is one reason we prefer slices to pointers.

test.zig

  1. const expect = @import("std").testing.expect;
  3. test "pointer slicing" {
  4.     var array = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  5.     const slice = array[2..4];
  6.     expect(slice.len == 2);
  8.     expect(array[3] == 4);
  9.     slice[1] += 1;
  10.     expect(array[3] == 5);
  11. }
  1. $ zig test test.zig
  2. 1/1 test "pointer slicing"... OK
  3. All 1 tests passed.

Pointers work at compile-time too, as long as the code does not depend on an undefined memory layout:

test.zig

  1. const expect = @import("std").testing.expect;
  3. test "comptime pointers" {
  4.     comptime {
  5.         var x: i32 = 1;
  6.         const ptr = &x;
  7.         ptr.* += 1;
  8.         x += 1;
  9.         expect(ptr.* == 3);
  10.     }
  11. }
  1. $ zig test test.zig
  2. 1/1 test "comptime pointers"... OK
  3. All 1 tests passed.

To convert an integer address into a pointer, use @intToPtr. To convert a pointer to an integer, use @ptrToInt:

test.zig

  1. const expect = @import("std").testing.expect;
  3. test "@ptrToInt and @intToPtr" {
  4.     const ptr = @intToPtr(*i32, 0xdeadbee0);
  5.     const addr = @ptrToInt(ptr);
  6.     expect(@TypeOf(addr) == usize);
  7.     expect(addr == 0xdeadbee0);
  8. }
  1. $ zig test test.zig
  2. 1/1 test "@ptrToInt and @intToPtr"... OK
  3. All 1 tests passed.

Zig is able to preserve memory addresses in comptime code, as long as the pointer is never dereferenced:

test.zig

  1. const expect = @import("std").testing.expect;
  3. test "comptime @intToPtr" {
  4.     comptime {
  5.         // Zig is able to do this at compile-time, as long as
  6.         // ptr is never dereferenced.
  7.         const ptr = @intToPtr(*i32, 0xdeadbee0);
  8.         const addr = @ptrToInt(ptr);
  9.         expect(@TypeOf(addr) == usize);
  10.         expect(addr == 0xdeadbee0);
  11.     }
  12. }
  1. $ zig test test.zig
  2. 1/1 test "comptime @intToPtr"... OK
  3. All 1 tests passed.

See also:

volatile

Loads and stores are assumed to not have side effects. If a given load or store should have side effects, such as Memory Mapped Input/Output (MMIO), use volatile. In the following code, loads and stores with mmio_ptr are guaranteed to all happen and in the same order as in source code:

test.zig

  1. const expect = @import("std").testing.expect;
  3. test "volatile" {
  4.     const mmio_ptr = @intToPtr(*volatile u8, 0x12345678);
  5.     expect(@TypeOf(mmio_ptr) == *volatile u8);
  6. }
  1. $ zig test test.zig
  2. 1/1 test "volatile"... OK
  3. All 1 tests passed.

Note that volatile is unrelated to concurrency and Atomics. If you see code that is using volatile for something other than Memory Mapped Input/Output, it is probably a bug.

To convert one pointer type to another, use @ptrCast. This is an unsafe operation that Zig cannot protect you against. Use @ptrCast only when other conversions are not possible.

test.zig

  1. const std = @import("std");
  2. const expect = std.testing.expect;
  4. test "pointer casting" {
  5.     const bytes align(@alignOf(u32)) = [_]u8{ 0x12, 0x12, 0x12, 0x12 };
  6.     const u32_ptr = @ptrCast(*const u32, &bytes);
  7.     expect(u32_ptr.* == 0x12121212);
  9.     // Even this example is contrived - there are better ways to do the above than
  10.     // pointer casting. For example, using a slice narrowing cast:
  11.     const u32_value = std.mem.bytesAsSlice(u32, bytes[0..])[0];
  12.     expect(u32_value == 0x12121212);
  14.     // And even another way, the most straightforward way to do it:
  15.     expect(@bitCast(u32, bytes) == 0x12121212);
  16. }
  18. test "pointer child type" {
  19.     // pointer types have a `child` field which tells you the type they point to.
  20.     expect(@typeInfo(*u32).Pointer.child == u32);
  21. }
  1. $ zig test test.zig
  2. 1/2 test "pointer casting"... OK
  3. 2/2 test "pointer child type"... OK
  4. All 2 tests passed.

Alignment

Each type has an alignment - a number of bytes such that, when a value of the type is loaded from or stored to memory, the memory address must be evenly divisible by this number. You can use @alignOf to find out this value for any type.

Alignment depends on the CPU architecture, but is always a power of two, and less than 1 << 29.

In Zig, a pointer type has an alignment value. If the value is equal to the alignment of the underlying type, it can be omitted from the type:

test.zig

  1. const std = @import("std");
  2. const expect = std.testing.expect;
  4. test "variable alignment" {
  5.     var x: i32 = 1234;
  6.     const align_of_i32 = @alignOf(@TypeOf(x));
  7.     expect(@TypeOf(&x) == *i32);
  8.     expect(*i32 == *align(align_of_i32) i32);
  9.     if (std.Target.current.cpu.arch == .x86_64) {
  10.         expect(@typeInfo(*i32).Pointer.alignment == 4);
  11.     }
  12. }
  1. $ zig test test.zig
  2. 1/1 test "variable alignment"... OK
  3. All 1 tests passed.

In the same way that a *i32 can be coerced to a *const i32, a pointer with a larger alignment can be implicitly cast to a pointer with a smaller alignment, but not vice versa.

You can specify alignment on variables and functions. If you do this, then pointers to them get the specified alignment:

test.zig

  1. const expect = @import("std").testing.expect;
  3. var foo: u8 align(4) = 100;
  5. test "global variable alignment" {
  6.     expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
  7.     expect(@TypeOf(&foo) == *align(4) u8);
  8.     const as_pointer_to_array: *[1]u8 = &foo;
  9.     const as_slice: []u8 = as_pointer_to_array;
  10.     expect(@TypeOf(as_slice) == []align(4) u8);
  11. }
  13. fn derp() align(@sizeOf(usize) * 2) i32 { return 1234; }
  14. fn noop1() align(1) void {}
  15. fn noop4() align(4) void {}
  17. test "function alignment" {
  18.     expect(derp() == 1234);
  19.     expect(@TypeOf(noop1) == fn() align(1) void);
  20.     expect(@TypeOf(noop4) == fn() align(4) void);
  21.     noop1();
  22.     noop4();
  23. }
  1. $ zig test test.zig
  2. 1/2 test "global variable alignment"... OK
  3. 2/2 test "function alignment"... OK
  4. All 2 tests passed.

If you have a pointer or a slice that has a small alignment, but you know that it actually has a bigger alignment, use @alignCast to change the pointer into a more aligned pointer. This is a no-op at runtime, but inserts a safety check:

test.zig

  1. const std = @import("std");
  3. test "pointer alignment safety" {
  4.     var array align(4) = [_]u32{ 0x11111111, 0x11111111 };
  5.     const bytes = std.mem.sliceAsBytes(array[0..]);
  6.     std.testing.expect(foo(bytes) == 0x11111111);
  7. }
  8. fn foo(bytes: []u8) u32 {
  9.     const slice4 = bytes[1..5];
  10.     const int_slice = std.mem.bytesAsSlice(u32, @alignCast(4, slice4));
  11.     return int_slice[0];
  12. }
  1. $ zig test test.zig
  2. 1/1 test "pointer alignment safety"... incorrect alignment
  3. /home/andy/Downloads/zig/docgen_tmp/test.zig:10:63: 0x206f2b in foo (test)
  4.     const int_slice = std.mem.bytesAsSlice(u32, @alignCast(4, slice4));
  5.                                                               ^
  6. /home/andy/Downloads/zig/docgen_tmp/test.zig:6:27: 0x2059ba in test "pointer alignment safety" (test)
  7.     std.testing.expect(foo(bytes) == 0x11111111);
  8.                           ^
  9. /home/andy/Downloads/zig/lib/std/special/test_runner.zig:61:28: 0x22dd31 in std.special.main (test)
  10.         } else test_fn.func();
  11.                            ^
  12. /home/andy/Downloads/zig/lib/std/start.zig:334:37: 0x20748d in std.start.posixCallMainAndExit (test)
  13.             const result = root.main() catch |err| {
  14.                                     ^
  15. /home/andy/Downloads/zig/lib/std/start.zig:162:5: 0x2071c2 in std.start._start (test)
  16.     @call(.{ .modifier = .never_inline }, posixCallMainAndExit, .{});
  17.     ^
  18. error: the following test command crashed:
  19. docgen_tmp/zig-cache/o/8fe80128a94c1613e48317295fc76cfc/test

allowzero

This pointer attribute allows a pointer to have address zero. This is only ever needed on the freestanding OS target, where the address zero is mappable. If you want to represent null pointers, use Optional Pointers instead. Optional Pointers with allowzero are not the same size as pointers. In this code example, if the pointer did not have the allowzero attribute, this would be a Pointer Cast Invalid Null panic:

allowzero.zig

  1. const std = @import("std");
  2. const expect = std.testing.expect;
  4. test "allowzero" {
  5.     var zero: usize = 0;
  6.     var ptr = @intToPtr(*allowzero i32, zero);
  7.     expect(@ptrToInt(ptr) == 0);
  8. }
  1. $ zig test allowzero.zig
  2. 1/1 test "allowzero"... OK
  3. All 1 tests passed.

Sentinel-Terminated Pointers

The syntax [*:x]T describes a pointer that has a length determined by a sentinel value. This provides protection against buffer overflow and overreads.

test.zig

  1. const std = @import("std");
  3. // This is also available as `std.c.printf`.
  4. pub extern "c" fn printf(format: [*:0]const u8, ...) c_int;
  6. pub fn main() anyerror!void {
  7.     _ = printf("Hello, world!\n"); // OK
  9.     const msg = "Hello, world!\n";
  10.     const non_null_terminated_msg: [msg.len]u8 = msg.*;
  11.     _ = printf(&non_null_terminated_msg);
  12. }
  1. $ zig build-exe test.zig -lc
  2. ./docgen_tmp/test.zig:11:17: error: expected type '[*:0]const u8', found '*const [14]u8'
  3.     _ = printf(&non_null_terminated_msg);
  4.                 ^
  5. ./docgen_tmp/test.zig:11:17: note: destination pointer requires a terminating '0' sentinel
  6.     _ = printf(&non_null_terminated_msg);
  7.                 ^

See also: