"immutable string" vs "const string*"

[Dennis]

On Sunday, 9 September 2018 at 08:41:37 UTC, Christian Mayer 
wrote:
> As of my current understanding "char" will create a new 
> variable and copy the content of the original to the new 
> variable. "char*" will just use the pointer. And "const char*" 
> is good for when not modifying. But I also can achieve the same 
> using "immutable char".

In D, a string looks like this:
```
struct string {
   size_t length; // length of a string
   immutable(char)* ptr; // pointer to the actual characters of 
the string
}
```
On 32-bit, that struct has a size of 2*4 = 8 bytes. On 64-bit, 
it's 2*8 = 16 bytes.
So when you have a string in a function signature:
```
void print(string str);
```
In terms of performance and calling convention, that's basically 
the same as doing this in C:
```
void print(size_t length, char *string);
```
Except that in C, the length of strings is traditionally 
calculated based on the null-terminator instead of passed as 
parameter. In both cases, 8 (or 16 on 64-bit) bytes are passed to 
the function. When you use a string*, you give a pointer to a 
structure with a pointer and a length. This cuts the size of the 
function parameters in half (only 4 or 8 bytes are passed), but 
it adds an extra level of indirection. So it takes an extra 
instruction to dereference the pointer, makes it more error-prone 
for the programmer, and harder to reason about for the optimizer.

I'd recommend just passing strings as if they were a basic type, 
see [1].
As for when to use const and immutable, I recommend reading [2].

[1] https://digitalmars.com/articles/b01.html
[2] https://dlang.org/articles/const-faq.html