Allocators

    const stdout = std.io.getStdOut().writer();

    var gpa = std.heap.GeneralPurposeAllocator(.{}){};

    var list = std.ArrayList(i32).init(gpa.allocator());
    defer list.deinit();

    try list.append(42);

    for (list.items) |value| {
        try stdout.print("Output:  {d}", .{value});
    }

  const allocator = std.heap.page_allocator;
  const stdout = std.io.getStdOut().writer();

  const MyStruct = struct {
      myFloat: f32,
      myInt: i32,
  };

  const memory = try allocator.alloc(u8, 42);
  defer allocator.free(memory);

  try stdout.print("Len of the memory: {}\n", .{memory.len});

  var myStruct = try allocator.create(MyStruct); 
  defer allocator.destroy(myStruct);

  myStruct.*.myFloat = 3.1415;
  myStruct.*.myInt = 42;

  try stdout.print("myStruct: {}\n", .{myStruct});

  const stdout = std.io.getStdOut().writer();

  var buffer: [100]u8 = undefined;
  var fixedBuffAlloc = std.heap.FixedBufferAllocator.init(&buffer);
  const allocator = fixedBuffAlloc.allocator();

  const memory = try allocator.alloc(u8, 50);
  defer allocator.free(memory);

  try stdout.print("Len of the memory: {}\n", .{memory.len});

  // Example of OutOfMemory error
  _ = allocator.alloc(u8, 51) catch |err| {
    try stdout.print("There is an error: {}\n", .{err});
  };

  const stdout = std.io.getStdOut().writer();

  const MyStruct = struct {
      myFloat: f32,
      myInt: i32,
  };

  const page_allocator = std.heap.page_allocator;
  var arena = std.heap.ArenaAllocator.init(page_allocator);
  defer arena.deinit();
  const allocator = arena.allocator();

  var myStruct = try allocator.create(MyStruct);

  myStruct.*.myFloat = 3.1415;
  myStruct.*.myInt = 42;

  try stdout.print("myStruct: {}\n", .{myStruct});
  // No need to manual free myStuct

  pub fn GeneralPurposeAllocator(comptime config: Config) type {
      return struct {
          /// Implementation ....
      };
  }

pub const Config = struct {
    /// Number of stack frames to capture.
    stack_trace_frames: usize = default_stack_trace_frames,

    /// If true, the allocator will have two fields:
    ///  * `total_requested_bytes` which tracks the total allocated bytes of memory requested.
    ///  * `requested_memory_limit` which causes allocations to return `error.OutOfMemory`
    ///    when the `total_requested_bytes` exceeds this limit.
    /// If false, these fields will be `void`.
    enable_memory_limit: bool = false,

    /// Whether to enable safety checks.
    safety: bool = std.debug.runtime_safety,

    /// Whether the allocator may be used simultaneously from multiple threads.
    thread_safe: bool = !builtin.single_threaded,

    /// What type of mutex you'd like to use, for thread safety.
    /// when specified, the mutex type must have the same shape as `std.Thread.Mutex` and
    /// `DummyMutex`, and have no required fields. Specifying this field causes
    /// the `thread_safe` field to be ignored.
    ///
    /// when null (default):
    /// * the mutex type defaults to `std.Thread.Mutex` when thread_safe is enabled.
    /// * the mutex type defaults to `DummyMutex` otherwise.
    MutexType: ?type = null,

    /// This is a temporary debugging trick you can use to turn segfaults into more helpful
    /// logged error messages with stack trace details. The downside is that every allocation
    /// will be leaked, unless used with retain_metadata!
    never_unmap: bool = false,

    /// This is a temporary debugging aid that retains metadata about allocations indefinitely.
    /// This allows a greater range of double frees to be reported. All metadata is freed when
    /// deinit is called. When used with never_unmap, deliberately leaked memory is also freed
    /// during deinit. Currently should be used with never_unmap to avoid segfaults.
    /// TODO https://github.com/ziglang/zig/issues/4298 will allow use without never_unmap
    retain_metadata: bool = false,

    /// Enables emitting info messages with the size and address of every allocation.
    verbose_log: bool = false,
};

  const stdout = std.io.getStdOut().writer();

  const MyStruct = struct {
      myFloat: f32,
      myInt: i32,
  };

  var gpa = std.heap.GeneralPurposeAllocator(.{}){};
  const allocator = gpa.allocator();

  // Returns `Check.leak` if there were leaks; `Check.ok` otherwise.
  defer {
      const checkStatus = gpa.deinit();
      if (checkStatus == std.heap.Check.leak) {
          std.log.err("Leaks detected !!!", .{});
      }
  }

  var myStruct = try allocator.create(MyStruct);
  defer allocator.destroy(myStruct);

  myStruct.*.myFloat = 3.1415;
  myStruct.*.myInt = 42;

  try stdout.print("myStruct: {}\n", .{myStruct});

  test "Test ArrayList" {
      var array = std.ArrayList(i32).init(std.testing.allocator);
      defer array.deinit();

      const expected: i32 = 42;
      try array.append(expected);

      try std.testing.expectEqual(expected, array.items[0]);
  }

  test "Test ArrayList" {
      var array = std.ArrayList(i32).init(std.testing.allocator);
      //defer array.deinit(); -> the array will not be free

      const expected: i32 = 42;
      try array.append(expected);

      try std.testing.expectEqual(expected, array.items[0]);
  }

  /// This should only be used in temporary test programs.
  pub const allocator = allocator_instance.allocator();
  pub var allocator_instance = b: {
      if (!builtin.is_test)
          @compileError("Cannot use testing allocator outside of test block");
      break :b std.heap.GeneralPurposeAllocator(.{}){};
  };

  test "test alloc falling" {
    const numberOfAllocation = 0;
    var failingAlloc = std.testing.FailingAllocator.init(std.testing.allocator, numberOfAllocation);
    var list = std.ArrayList(i32).init(failingAlloc.allocator());
    defer list.deinit();

    const expected = 45;

    try std.testing.expectError(std.mem.Allocator.Error.OutOfMemory, list.append(expected));
  }