Discussion on: What's a String Literal in Zig?

View post

Replies for: This is good - string literals are still something I'm stumbling over. var foo: [50]u8 = undefined; foo = "bar"; // compile error here I think I...

I don't think there's a way to directly assign a smaller array to a larger one, but you can always create a helper function to do so:

fn array(comptime T: type, comptime size: usize, items: ?[]const T) [size]T {
    var output = std.mem.zeroes([size]T);
    if (items) |slice| std.mem.copy(T, &output, slice);
    return output;
}

const A = struct {
    foo: [10]u8,
};

// fully initialize
var foo: [3]u8 = .{'f', 'o', 'o'};

// zero initialize then copy desired contents
var bar: [50]u8 = [_]u8{0} ** 50;
std.mem.copy(u8, &bar, "bar");

var baz: A = A{.foo = [_]u8{0} ** 10};
std.mem.copy(u8, &baz.foo, "baz");

// fully initialize with comptime concatenation
var bar_full: [50]u8 = "bar".* ++ [_]u8{0} ** 47;
var baz_full: A = A{.foo = "baz".* ++ [_]u8{0} ** 7};

// with helper function
var bar_alt = comptime array(u8, 50, "bar");
var baz_alt = A{.foo = comptime array(u8, 10, "baz")};

David Vanderson • Aug 9 '21

Thanks - great to see different options for how to do it!

Can you think of a way to use the helper function and somehow infer the size of the struct member so it doesn't have to be repeated? Not a huge deal but I can't figure out how to do it.

mrkishi • Aug 9 '21

I don't know how to do that exactly. The closest I could come up with would be to leave the array undefined and use a helper function to fill it in, but that has slightly different semantics since the memcpy is a little more explicit:

fn init_array(target: anytype, items: ?[]const std.meta.Elem(@TypeOf(target))) void {
    const T = std.meta.Elem(@TypeOf(target));
    if (items) |slice| {
        std.mem.copy(T, target, slice);
        std.mem.set(T, target[slice.len..], std.mem.zeroes(T));
    } else {
        std.mem.set(T, target, std.mem.zeroes(T));
    }
}

var foo: [50]u8 = undefined;
init_array(&foo, "foo");

var a = A{.foo = undefined};
init_array(&a.foo, "foo");

David Vanderson • Aug 9 '21

Good solution. I haven't seen std.meta.Elem before so I'm going to go read up on that. Thanks!

haydenridd • Nov 26 '24

Yep, tried a couple ways but can't seem to get around having to manually specify the type in some way rather than being able to infer it. Slight variant I came up with specifically for string literals only:

fn stringLiteralToArray(comptime literal: []const u8, ArrayType: type) ArrayType {
    const ti = @typeInfo(ArrayType);
    comptime {
        assert(ti == .Array);
        assert(ti.Array.len >= literal.len);
    }
    return literal[0..literal.len].* ++ .{0} ** (ti.Array.len - literal.len);
}

// Non-field variables can infer the type
var string_buffer = stringLiteralToArray("A default value", [64]u8);

// Struct fields need to specify both sadly
const SomeStruct = struct {
    field: [32]u8 = stringLiteralToArray("Another default", [32]u8),
};