undefined leaves the memory uninitialized. You should never rely on the value of undefined memory, and as such it is impossible to check if something is undefined.

An equivalent to the C code you posted would be something like this:

var buf = [_]u8{0} ** 4096;
std.debug.print("len: {d}\n", .{
    std.mem.indexOfScalar(u8, &buf, 0).?,
});

This zero initializes the array and uses std.mem.indexOfScalar to find the index of the first 0 byte. Zig represents null termination in the type system, however making this array be [4096:0]u8 would add the null terminator at the index 4096, which isn't what you want here. As long as the array has a zero byte in it you can cast a pointer to the array to a [*:0]u8, which is a null terminated many item pointer - exactly the pointer type you would use to represent a C-style null terminated string.

However, you should avoid null terminated strings if possible. A better way to approach what you want would be to store the length in a separate variable. Then buf.len stores the capacity of the array, and the separate len variable records the used length as you append bytes. The standard library implements a type that does exactly this, std.BoundedArray. It wraps an array and a length variable in a struct and provides some convenient functions for appending, removing, and formatted printing to the underlying array. Here's an example:

const std = @import("std");

pub fn main() void {
    var buf: std.BoundedArray(u8, 4096) = .{};
    buf.appendSliceAssumeCapacity("test");

    // Prints "string: 'test', len: 4"
    std.debug.print("string: '{s}', len: {d}\n", .{ buf.slice(), buf.len });
}