why is string not implicit convertable to const(char*) ?

[dcoder]

On Saturday, 30 June 2012 at 00:27:46 UTC, Jonathan M Davis wrote:
> On Saturday, June 30, 2012 02:12:22 mta`chrono wrote:
>> does anyone know why string not implicit convertable to 
>> const(char*) ?
>> 
>> -------
>> import core.sys.posix.unistd;
>> 
>> void main()
>> {
>>         // ok
>>         unlink("foo.txt");
>> 
>>         // failed
>>         string file = "bar.txt";
>>         unlink(file);
>> }
>> 
>> test.d(10): Error: function core.sys.posix.unistd.unlink 
>> (const(char*))
>> is not callable using argument types (string)
>> test.d(10): Error: cannot implicitly convert expression (file) 
>> of type
>> string to const(char*)
>
> Because it's _not_ const char*. It's an array. And passing a 
> string directly
> to a C function (which is almost the only reason that you'd 
> want a string to
> convert to a const char*) is generally _wrong_. Strings in D 
> are _not_ zero-
> terminated. String _literals_ are (they have a '\0' one 
> character passed their
> end), so as it just so happens, if string implicitly converted 
> to const char*,
> your code would work, but if your string had been created from 
> anything other
> than a string literal, it would _not_ be zero terminated. Even 
> concatenating
> two string literals results in a string which isn't 
> zero-terminated. So,
> implictly converting strinvg to const char* would just cause 
> bugs (in fact, it
> _used_ to work, and it was fixed so that it doesn't precisely 
> because it's
> behavior which just causes bugs).
>
> What you need to do is use std.string.toStringz. It converts a 
> string to a
> zero-terminated string. It appends '\0' to the end of the 
> string if it has to
> (which could result in the string having to be reallocated to 
> make room for
> it), but if it can determine that it's unnecessary (which it 
> can do at least
> some of the time with string literals), it'll just return the 
> string's ptr
> property without doing any allocating. But since you _need_ 
> that '\0', that's
> the best that you can do. Simply passing the string's ptr 
> property to a C
> function would be wrong, since it's not zero-terminated.
>
> Your function call should look like
>
> unlink(toStringz(file));
>
> Of course, you could just do std.file.remove(file), which 
> ultimately does the
> same thing and does so on all platforms rather than just POSIX, 
> but that's a
> separate issue from converting a string to a const char*.
>
> - Jonathan M Davis

Thanks for the thorough explanation, but it begs the question why 
not make strings be array of chars that have \0 at the end of it? 
  Since, lots of D programmers were/are probably C/C++ 
programmers, why should D be different here?  Wouldn't it 
facilitate more C/C++ programmers to come to D?

Just curious.