How does std::strlen wоrk internally?

Question

I've been struggling to understand std::strlen() but in vain:

AFAIK strlen() returns the number of characters in a null-terminated constant character string in terms of bytes. If it is not null-terminated then the behavior is undefined. Apart from that, it is OK.

So: std::strlen(""); is 0.

But, because I've read about it on www.cppreference.com, I've found a possible implementation as:

// This is from:   https://en.cppreference.com/w/cpp/string/byte/strlen

std::size_t strlen(const char* start) {
     const char* end = start;
     while(*++end != 0);// I think this causes UB
     return end - start;
  }

But if I run it:

int main()
{
    const char cp1[] = "";
    const char cp2[] = "\0";
    const char cp3[] = "\0Hello";
    const char cp4[] = "H\0ello";
    const char cp5[1] = {};// UB?
    const char cp6[] = {'\0'};
    const char cp7[] = {'H', '\0'};

    cout << std::strlen(cp1) << " " << sizeof(cp1) << endl;// 0 1 OK
    cout << strlen(cp1) << " " << sizeof(cp1) << endl;// 1 1  is UB?

    cout << "\nDone!\n";
}

So what I see is that the version implemented on the website triggers an Undefined Behavior: The loop combines the pre-increment operator and de-reference operator in its condition and as we know the operators are of the same precedence level and they are evaluated from right to left. Thus, first increment the pointer and then de-reference it. In the case of the empty string, the pointer points one past the last character (null character) then de-references it, which is UB as far as I know.

It's not UB, but rather a simple logic bug: The `end` pointer will always point to the null-terminator, so the reported size will always include it. — Some programmer dude, Jan 21 '20 at 14:21
Increment `end` pointer after you check for zero, not before. The implementation on cppreference clearly does `*end++` not `*++end`. Och wow, it was edited. [history](https://en.cppreference.com/mwiki/index.php?title=cpp/string/byte/strlen&action=history) — KamilCuk, Jan 21 '20 at 14:23
@KamilCuk Actually it was. It was just edited because it was UB. — NathanOliver, Jan 21 '20 at 14:26
@KamilCuk It should be noted that the reference page was edited today, due to this issue. And also that the "fix" doesn't work as it will lead to the exact same issue. — Some programmer dude, Jan 21 '20 at 14:26
A "better" implementation would be something like `for (auto end = start; *end != '\0'; ++end) { /* empty */ }` — Some programmer dude, Jan 21 '20 at 14:27
@NathanOliver Hmm... When I first looked at the new example, I didn't see the `-1` in the return statement. With that subtraction the fix is working. — Some programmer dude, Jan 21 '20 at 14:43
This is why it is good idea to use up *one more line* of your allotted total source code lines for life, and not combine the `++` in the condition. Just put it in a separate line. — hyde, Jan 21 '20 at 14:52

score 5 · Accepted Answer · answered Jan 21 '20 at 14:30

You are correct that the possible implementation has undefined behavior. *++end increments and then dereferences, which is UB on a empty string since you dereference the past the end element.

The possible implementation has since been changed to

std::size_t strlen(const char* start) {
   const char* end = start;
   while(*end++ != 0);
   return end - start - 1;
}

which is a correct implementation.

score 1 · Answer 2 · answered Jan 22 '20 at 04:34

1

be like this post inc,

std::size_t strlen(const char* const start) {
     const char* end = start;
     while(*end++ != 0);   // fixing I think this causes UB
     return --end - start;
  }

answered Jan 22 '20 at 04:34

How does std::strlen wоrk internally?

2 Answers2