I think it was Dennis Ritchie who pointed out what a fudge this was:

char *strstr(const char *haystack, const char *needle);

ANSI C introduced the “const” modifier, and wanted to use it for the
arguments to strstr. But if the result is a pointer into the
“haystack” string, then if that is const, then so should the result
be. But that means it can only be assigned to a variable that also has
the “const” modifier.

Really, it should have become two functions, one where both
“haystack” and the result are const, and one where neither is.

Lawrence D'Oliveiro <ldo@nz.invalid> writes:

> I think it was Dennis Ritchie who pointed out what a fudge this was:
>
> char *strstr(const char *haystack, const char *needle);
>
> ANSI C introduced the “const” modifier, and wanted to use it for the
> arguments to strstr. But if the result is a pointer into the
> “haystack” string, then if that is const, then so should the result
> be. But that means it can only be assigned to a variable that also has
> the “const” modifier.
>
> Really, it should have become two functions, one where both
> “haystack” and the result are const, and one where neither is.

Now (in C23) it has become a generic function that preserves const
correctness in its first argument.

--
Ben.

On Sat, 24 Feb 2024 23:54:42 -0000 (UTC), Lawrence D'Oliveiro
<ldo@nz.invalid> wrote:

>I think it was Dennis Ritchie who pointed out what a fudge this was:
>
> char *strstr(const char *haystack, const char *needle);
>
>ANSI C introduced the “const” modifier, and wanted to use it for the
>arguments to strstr. But if the result is a pointer into the
>“haystack” string, then if that is const, then so should the result
>be. But that means it can only be assigned to a variable that also has
>the “const” modifier.
>
>Really, it should have become two functions, one where both
>“haystack” and the result are const, and one where neither is.

It seems to me that the const modifier in this context does not mean
no one can ever modify the string. It is a guarantee that the
function will not modify the string. Once the function returns, all
bets are off.

While I don't recall having the need myself, I see nothing wrong with
calling strstr to find a substring and then doing whatever I want to
the haystack, such as terminating it either before of after the
substring by inserting a '\0'.

--
Remove del for email

Barry Schwarz <schwarzb@delq.com> writes:
> On Sat, 24 Feb 2024 23:54:42 -0000 (UTC), Lawrence D'Oliveiro
> <ldo@nz.invalid> wrote:
>>I think it was Dennis Ritchie who pointed out what a fudge this was:
>>
>> char *strstr(const char *haystack, const char *needle);
>>
>>ANSI C introduced the “const” modifier, and wanted to use it for the
>>arguments to strstr. But if the result is a pointer into the
>>“haystack” string, then if that is const, then so should the result
>>be. But that means it can only be assigned to a variable that also has
>>the “const” modifier.
>>
>>Really, it should have become two functions, one where both
>>“haystack” and the result are const, and one where neither is.
>
> It seems to me that the const modifier in this context does not mean
> no one can ever modify the string. It is a guarantee that the
> function will not modify the string. Once the function returns, all
> bets are off.
>
> While I don't recall having the need myself, I see nothing wrong with
> calling strstr to find a substring and then doing whatever I want to
> the haystack, such as terminating it either before of after the
> substring by inserting a '\0'.

That's fine if haystack is modifiable. The problem is that when the
haystack argument points to a non-modifiable string, such as a string
literal, the return value purports to allow modifying it.

An example:

#include <string.h>
#include <stdio.h>
int main(void) {
const char *message = "hello, world";
char *s = strstr(message, "world");
puts(s);
s[0] = 'W';
puts(s);
}

The first puts(s) correctly prints "world". The assignment to s[0] has
undefined behavior (seg fault on my system).

One solution would have been to define two functions with different
names:

const char *strstr_c(const char *haystack, const char *needle);
char *strstr ( char *haystack, const char *needle);

C++ has <cstring>, which is mostly a copy of C's <string.h>, but it has
two overloaded strstr() functions.

C23 makes strstr() a generic function, so the return value has the type
of the first argument.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Medtronic
void Void(void) { Void(); } /* The recursive call of the void */

On 2/24/24 22:10, Keith Thompson wrote:
....
> C23 makes strstr() a generic function, so the return value has the type
> of the first argument.

Nice! I see this also applies to memchr, strchr, strpbrk, and strrchr.
However, I think they missed and opportunity to generalize. Those
functions are generic only with respect to the type qualifiers. I think
it would have been even better if they had been made generic over the
character type, allowing wchar_t, char16_T, and char32_t.