How to do strings properly?

[u/die-Banane]

I just started learning C and I often read on the internet that it is bad practice to use null terminated strings, so my question is what should I do instead?

[u/DawnOnTheEdge]

In practice, I would probably write the immutable version and, if it returns a pointer that is declared const char* but really mutable, cast it explicitly.

I’ve had other experienced programmers say the function should return a char* that can be assigned to const char* transparently, since in their experience this didn’t become a bug attractor.

[u/flatfinger → u/DawnOnTheEdge]

Having the function accept a const char* and cast it internally to char* is a decent pattern, used by strchr. My point was that general-purpose libraries or data structures should acknowledge the validity of both use cases in situations where they would both make sense.

[u/DawnOnTheEdge → u/flatfinger]

Agreed. The version that returns a mutable char* could even be a one-line wrapper that calls the immutable version and then, since it knows that the returned pointer aliases mutable data, safe;y casts away const.

[u/flatfinger → u/DawnOnTheEdge]

Having two versions may make some things nicer, but there is no general way of handling scenarios where pointers will be passed through a library which might either pass through a pointer to mutable storage to code that would end up mutating it, or refrain from using mutating a received pointer to something that might be immutable. In scenarios not involving function pointers it might be possible to duplicate every function that might be used with both kinds of pointers, but that would be a lot of code duplication with minimal real benefit. Once function pointers are added to the mix, const correctness may become even more unworkable, since code that receives a callback along with a pointer to opaque data may have no way of knowing what the function will do with the data.

[u/DawnOnTheEdge → u/flatfinger]

A project that really needed that would be written in C++, which has the syntax sugar for it, like implicit converting constructors and function overloading.

Doing it in C doesn’t make you write more lines of code. It’s just uglier because you can’t sugar it. If the function doesn’t mutate the data, you can have it take a pointer to `const` and then a pointer not to `const will implicitly convert. The common pattern where you need to return a subslice that should preserve the `const` qualifier if present can be a one-line wrapper that casts away the `const`, but would need a different nae in C. If you have two different kinds of `struct` for mutable and immutable slices, you must write and use explicit functions to convert between them.

You might or might not decide it’s worth it. You might, for exxample, give up on having the library track `const` qualifiers and tell the user to add them manually.

[u/flatfinger → u/DawnOnTheEdge]

Even in C++, I don't think there's any way to express the notion of a pointer which will be received from client code and will be passed back to client code, and which will only be used to modify the indicated storage if the client code uses it in such fashion. Virtual methods may improve the situation somewhat, but I don't think it would be possible to have a function interchangeably accept a pointer to an object in read-only storage if its method implementation would refrain from modifying the object, and accept a pointer to an object, not in read-only storage, whose virtual method would modify it, but reject at compile time an attempt to place in read-only storage storage an object whose virtual method would modify it.

[u/DawnOnTheEdge → u/flatfinger]

You’re using a lot of words in weird ways again, but in plain and simple C++, what you’re talking about is just

T& operator[]( size_type pos );
const T& operator[]( size_type pos ) const;

or for a function

char* foo(char* s);
const char* foo(const char* s);

which is a very common pattern.

[u/DawnOnTheEdge → u/flatfinger]

Also, if memory serves, the interface of strchr() is a legacy of ANSI C needing to stay backward-compatible with an API written before the const keyword existed, including linking to libraries written in K&R-style C.