Arrays

arrays.zig

  1. const expect = @import("std").testing.expect;
  2. const assert = @import("std").debug.assert;
  3. const mem = @import("std").mem;
  5. // array literal
  6. const message = [_]u8{ 'h', 'e', 'l', 'l', 'o' };
  8. // get the size of an array
  9. comptime {
  10.     assert(message.len == 5);
  11. }
  13. // A string literal is a single-item pointer to an array literal.
  14. const same_message = "hello";
  16. comptime {
  17.     assert(mem.eql(u8, &message, same_message));
  18. }
  20. test "iterate over an array" {
  21.     var sum: usize = 0;
  22.     for (message) |byte| {
  23.         sum += byte;
  24.     }
  25.     try expect(sum == 'h' + 'e' + 'l' * 2 + 'o');
  26. }
  28. // modifiable array
  29. var some_integers: [100]i32 = undefined;
  31. test "modify an array" {
  32.     for (some_integers) |*item, i| {
  33.         item.* = @intCast(i32, i);
  34.     }
  35.     try expect(some_integers[10] == 10);
  36.     try expect(some_integers[99] == 99);
  37. }
  39. // array concatenation works if the values are known
  40. // at compile time
  41. const part_one = [_]i32{ 1, 2, 3, 4 };
  42. const part_two = [_]i32{ 5, 6, 7, 8 };
  43. const all_of_it = part_one ++ part_two;
  44. comptime {
  45.     assert(mem.eql(i32, &all_of_it, &[_]i32{ 1, 2, 3, 4, 5, 6, 7, 8 }));
  46. }
  48. // remember that string literals are arrays
  49. const hello = "hello";
  50. const world = "world";
  51. const hello_world = hello ++ " " ++ world;
  52. comptime {
  53.     assert(mem.eql(u8, hello_world, "hello world"));
  54. }
  56. // ** does repeating patterns
  57. const pattern = "ab" ** 3;
  58. comptime {
  59.     assert(mem.eql(u8, pattern, "ababab"));
  60. }
  62. // initialize an array to zero
  63. const all_zero = [_]u16{0} ** 10;
  65. comptime {
  66.     assert(all_zero.len == 10);
  67.     assert(all_zero[5] == 0);
  68. }
  70. // use compile-time code to initialize an array
  71. var fancy_array = init: {
  72.     var initial_value: [10]Point = undefined;
  73.     for (initial_value) |*pt, i| {
  74.         pt.* = Point{
  75.             .x = @intCast(i32, i),
  76.             .y = @intCast(i32, i) * 2,
  77.         };
  78.     }
  79.     break :init initial_value;
  80. };
  81. const Point = struct {
  82.     x: i32,
  83.     y: i32,
  84. };
  86. test "compile-time array initialization" {
  87.     try expect(fancy_array[4].x == 4);
  88.     try expect(fancy_array[4].y == 8);
  89. }
  91. // call a function to initialize an array
  92. var more_points = [_]Point{makePoint(3)} ** 10;
  93. fn makePoint(x: i32) Point {
  94.     return Point{
  95.         .x = x,
  96.         .y = x * 2,
  97.     };
  98. }
  99. test "array initialization with function calls" {
  100.     try expect(more_points[4].x == 3);
  101.     try expect(more_points[4].y == 6);
  102.     try expect(more_points.len == 10);
  103. }

Shell

  1. $ zig test arrays.zig
  2. 1/4 test.iterate over an array... OK
  3. 2/4 test.modify an array... OK
  4. 3/4 test.compile-time array initialization... OK
  5. 4/4 test.array initialization with function calls... OK
  6. All 4 tests passed.

See also:

Anonymous List Literals

Similar to Enum Literals and Anonymous Struct Literals the type can be omitted from array literals:

anon_list.zig

  1. const std = @import("std");
  2. const expect = std.testing.expect;
  4. test "anonymous list literal syntax" {
  5.     var array: [4]u8 = .{11, 22, 33, 44};
  6.     try expect(array[0] == 11);
  7.     try expect(array[1] == 22);
  8.     try expect(array[2] == 33);
  9.     try expect(array[3] == 44);
  10. }

Shell

  1. $ zig test anon_list.zig
  2. 1/1 test.anonymous list literal syntax... OK
  3. All 1 tests passed.

If there is no type in the result location then an anonymous list literal actually turns into a struct with numbered field names:

infer_list_literal.zig

  1. const std = @import("std");
  2. const expect = std.testing.expect;
  4. test "fully anonymous list literal" {
  5.     try dump(.{ @as(u32, 1234), @as(f64, 12.34), true, "hi"});
  6. }
  8. fn dump(args: anytype) !void {
  9.     try expect(args.@"0" == 1234);
  10.     try expect(args.@"1" == 12.34);
  11.     try expect(args.@"2");
  12.     try expect(args.@"3"[0] == 'h');
  13.     try expect(args.@"3"[1] == 'i');
  14. }

Shell

  1. $ zig test infer_list_literal.zig
  2. 1/1 test.fully anonymous list literal... OK
  3. All 1 tests passed.

Multidimensional Arrays

Multidimensional arrays can be created by nesting arrays:

multidimensional.zig

  1. const std = @import("std");
  2. const expect = std.testing.expect;
  4. const mat4x4 = [4][4]f32{
  5.     [_]f32{ 1.0, 0.0, 0.0, 0.0 },
  6.     [_]f32{ 0.0, 1.0, 0.0, 1.0 },
  7.     [_]f32{ 0.0, 0.0, 1.0, 0.0 },
  8.     [_]f32{ 0.0, 0.0, 0.0, 1.0 },
  9. };
  10. test "multidimensional arrays" {
  11.     // Access the 2D array by indexing the outer array, and then the inner array.
  12.     try expect(mat4x4[1][1] == 1.0);
  14.     // Here we iterate with for loops.
  15.     for (mat4x4) |row, row_index| {
  16.         for (row) |cell, column_index| {
  17.             if (row_index == column_index) {
  18.                 try expect(cell == 1.0);
  19.             }
  20.         }
  21.     }
  22. }

Shell

  1. $ zig test multidimensional.zig
  2. 1/1 test.multidimensional arrays... OK
  3. All 1 tests passed.

Sentinel-Terminated Arrays

The syntax [N:x]T describes an array which has a sentinel element of value x at the index corresponding to len.

null_terminated_array.zig

  1. const std = @import("std");
  2. const expect = std.testing.expect;
  4. test "null terminated array" {
  5.     const array = [_:0]u8 {1, 2, 3, 4};
  7.     try expect(@TypeOf(array) == [4:0]u8);
  8.     try expect(array.len == 4);
  9.     try expect(array[4] == 0);
  10. }

Shell

  1. $ zig test null_terminated_array.zig
  2. 1/1 test.null terminated array... OK
  3. All 1 tests passed.

See also: