Initializing an array of string constants, and another constant array of the equivalent lengths Ok, a struct would actually be most convenient, but it woudl be easier on teh system to have 2 seperate arrays rather than an array of structs.
#define PAIR(Str) {(Str), sizeof(Str)-1}
static const struct StrStruct {
    const char *Str;
    unsigned int Len;
} Packed4 DefaultStr[] = {
    PAIR(&quot;Error&quot;),
    PAIR(&quot;An unexpected error occurred&quot;),
    PAIR(&quot;while saving data&quot;),
    PAIR(&quot;Close some windows or programs and try again&quot;),
    PAIR(&quot;Singleplayer&quot;),
    PAIR(&quot;Multiplayer&quot;),
    PAIR(&quot;Settings&quot;),
    PAIR(&quot;Quit&quot;),
    PAIR(&quot;Graphics&quot;),
    PAIR(&quot;User Interface&quot;),
    PAIR(&quot;Sounds&quot;),
    PAIR(&quot;Controls&quot;),
    PAIR(&quot;Language&quot;),
    PAIR(&quot;Compatibility&quot;),
    PAIR(&quot;Help&quot;),
    PAIR(&quot;About&quot;),
    PAIR(&quot;On&quot;),
    PAIR(&quot;Off&quot;),
    PAIR(&quot;Field of View&quot;),
};

Simply hardcoding them is 'magic numbers'.
static const char *const Strs[] = {
    &quot;Singleplayer&quot;,
    &quot;Multiplayer&quot;,
    &quot;Settings&quot;,
    &quot;Quit&quot;,
    &quot;Graphics&quot;,
    &quot;User Interface&quot;,
    &quot;Sounds&quot;,
    &quot;Controls&quot;,
    &quot;Language&quot;,
    &quot;Compatibility&quot;,
    &quot;Help&quot;,
    &quot;About&quot;,
    &quot;On&quot;,
    &quot;Off&quot;,
    &quot;Field of View&quot;
};
static const unsigned short Lengths[] = {
    12,
    11,
    8,
    //...
};

So I came up with my current solution, though kind of a pain in the backside, I have this.
#define ERROR &quot;Error&quot;
#define UNEXPECTEDERROR &quot;An unexpected error occurred&quot;
#define WHILESAVINGDATA &quot;while saving data&quot;
#define CLOSEPROGRAMS &quot;Close some windows or programs and try again&quot;
#define SINGLEPLAYER &quot;Singleplayer&quot;
#define MULTIPLAYER &quot;Multiplayer&quot;
#define SETTINGS &quot;Settings&quot;
#define QUIT &quot;Quit&quot;
#define GRAPHICS &quot;Graphics&quot;
#define UI &quot;User Interface&quot;
#define AUDIO &quot;Audio&quot;
#define CONTROLS &quot;Controls&quot;
#define LANGUAGE &quot;Language&quot;
#define COMPATIBILITY &quot;Compatibility&quot;
#define HELP &quot;Help&quot;
#define ABOUT &quot;About&quot;
#define ON &quot;On&quot;
#define OFF &quot;Off&quot;
#define FOV &quot;Field of View&quot;
static const char *const DStr[] = {
    ERROR,
    UNEXPECTEDERROR,
    WHILESAVINGDATA,
    CLOSEPROGRAMS,
    SINGLEPLAYER,
    MULTIPLAYER,
    SETTINGS,
    QUIT,
    GRAPHICS,
    UI,
    AUDIO,
    CONTROLS,
    LANGUAGE,
    COMPATIBILITY,
    HELP,
    ABOUT,
    ON,
    OFF,
    FOV,
};
#define STRLEN(Str) (sizeof(Str)-1)
static const unsigned short DLen[] = {
    STRLEN(ERROR),
    STRLEN(UNEXPECTEDERROR),
    STRLEN(WHILESAVINGDATA),
    STRLEN(CLOSEPROGRAMS),
    STRLEN(SINGLEPLAYER),
    //...
};

Is there a better way to do this? Is there a cleaner way to initialize an constant array of strings, and a constant array of the equivalent lenghts? I'm mainly looking at the last one. How can I improve that one?
To expand on my comment, the X macro technique can be used for this. See here, for example
The idea is that we define the list once, for example
#define STRINGLIST \
X( &quot;alice&quot;) \
X( &quot;bob&quot;) \
X( &quot;cat&quot;)

When we want to use this list, we invoke the above macro, having defined the macro X:
static const char *const DStr[] = {
#define X(S) S,
STRINGLIST
#undef X
};

static const unsigned short DLen[] = {
#define X(S) sizeof( S)-1,
STRINGLIST
#undef X
};

This way we only have to define the strings once, and guarantee that the arrays DStr and DLen are in the same order. The disadvantage is that it looks pretty bizarre first time you see it, and others maintaining your code might be boggled.