I was thinking that all strings generated at compile-time have a null-terminator added. But then I thought, wait, maybe that's only specifically for string literals.

What is the true answer? If you generate a string, let's say via a CTFE call, does it have a null terminator?

-Steve

On Saturday, 9 December 2017 at 18:45:18 UTC, Steven Schveighoffer wrote:
> I was thinking that all strings generated at compile-time have a null-terminator added. But then I thought, wait, maybe that's only specifically for string literals.
>
> What is the true answer? If you generate a string, let's say via a CTFE call, does it have a null terminator?
>
> -Steve

The results of CTFE calls are literals. Therefore they are treated the same.
Thus the answer to your question is yes.

However there might be rare corner-cases in which the null termiantor is not there.
Should this happen please file a bug and sent me a mail specifically.

On Saturday, December 09, 2017 23:38:46 Stefan Koch via Digitalmars-d-learn wrote:
> On Saturday, 9 December 2017 at 18:45:18 UTC, Steven
>
> Schveighoffer wrote:
> > I was thinking that all strings generated at compile-time have a null-terminator added. But then I thought, wait, maybe that's only specifically for string literals.
> >
> > What is the true answer? If you generate a string, let's say via a CTFE call, does it have a null terminator?
> >
> > -Steve
>
> The results of CTFE calls are literals. Therefore they are
> treated the same.
> Thus the answer to your question is yes.
>
> However there might be rare corner-cases in which the null
> termiantor is not there.
> Should this happen please file a bug and sent me a mail
> specifically.

My initial reaction was that of course the null terminator wouldn't be there if it wasn't an actual string literal, but I tested it, and it was, but then when I thought it through some more, there really isn't any difference in the generated string between these options:

enum str = "hello world";

enum str = "hello" ~ " world";

string foo()
{
    string retval = "hello wor";
    retval ~= 'l';
    retval ~= 'd';
    return retval;
}

enum str = foo();

In all cases, the compiler has to execute what's on the right-hand side to generate the value, and in all cases, it would go where string literals go in the binary, because there really isn't any difference from the compiler's perspective at that point (at least not from what I understand). Aside from the function call case, it probably even generates pretty much the same binary (whether the function call case would depend on whether the linker removed the function from the binary).

I tried to think of a case where the result wouldn't be equivalent to a string literal, and I couldn't think of any. I didn't really want to make any statements about what was guaranteed though, since I'm not a compiler dev and not very familiar with the compiler internals.

- Jonathan M Davis