C strlen使用指针

Question

I have seen the standard implementation of strlen using pointer as:

int strlen(char * s) {
  char *p = s;
  while (*p!='\0')
    p++;
  return p-s;
}

I get this works, but when I tried to do this using 3 more ways (learning pointer arithmetic right now), I would want to know whats wrong with them?

1. This is somewhat similar to what the book does. Is this wrong?

    int strlen(char * s) { char *p = s; while (*p) p++; return ps; } 

2. I though it would be wrong if I pass an empty string but still gives me 0, kinda confusing since p is pre increment: (and now its returning me 5)

    int strlen(char * s) { char *p = s; while (*++p) ; return ps; } 

3. Figured this out, does the post increment and returns +1 on it.

    int strlen(char * s) { char *p = s; while (*p++) ; return ps; } 

Answer 1

1) Looks fine to me. I personally prefer the explicit comparison against '\\0' so that it's clear you didn't mean to (for example) compare p to the NULL pointer in situations where it's not clear from context.

2) When your program runs, the area of memory known as the stack is uninitialized. Local variables live there. The way you wrote your program puts p in the stack (if you made it const or used malloc , it would almost certainly live elsewhere). What happens when you look at *p is that you then peek at the stack. If the string is length 0, this is the same as char p[1] = {0} . Pre-incrementing looks at the byte immediately after the \\0 , so you're looking at undefined memory. Here be dragons!

3) I don't think there's a question there :) As you see, it always returns one more than the correct answer.

Addendum: You can also write this using a for-loop, if you prefer this style:

size_t strlen(char * s) {
    char *p = s;
    for (; *p != '\0'; p++) {}
    return p - s;
}

Or (more error-prone-ly)

size_t strlen(char * s) {
    char *p = s;
    for (; *p != '\0'; p++);
    return p - s;
}

Also, strlen can't return a negative number, so you should use an unsigned value. size_t is even better.

Answer 2

Version 1 is fine - while (*p != '\\0') is equivalent to while (*p != 0) , which is equivalent to while (*p) .

In the original code and version 1, the pointer p is advanced if and only if *p is not 0 (IOW, you're not at the end of the string).

Versions 2 and 3 advance p regardless of whether *p is 0 or not. *p++ evaluates to the character p points to, and as a side effect advances p . *++p evaluates to the character following the character p points to, and as a side effect advances p . Therefore, versions 2 and 3 will always advance p past the end of the string, which is why your values are off.

Answer 3

One issue you will run into when you compare the performance of strlen replacement functions is their performance will suffer compared to the actual strlen function for long strings? Why? strlen processes more than one-byte per iteration in searching for the end of string. How can you implement a more efficient replacement?

It's not that difficult. The basic approach is to look at 4-bytes per iteration and adjust the return based on where within those 4-bytes the nul-byte is found. You could do something like the following (using array indexing):

size_t strsz_idx (const char *s) {
    size_t len = 0;
    for(;;) {
        if (s[0] == 0) return len;
        if (s[1] == 0) return len + 1;
        if (s[2] == 0) return len + 2;
        if (s[3] == 0) return len + 3;
        s += 4, len += 4;
    }
}

You can do the exact same thing using pointers and masks:

size_t strsz (const char *s) {
    size_t len = 0;
    for(;;) {
        unsigned x = *(unsigned*)s;
        if((x & 0xff) == 0) return len;
        if((x & 0xff00) == 0) return len + 1;
        if((x & 0xff0000) == 0) return len + 2;
        if((x & 0xff000000) == 0) return len + 3;
        s += 4, len += 4;
    }
}

Either way, you will find a 4-byte comparison each iteration will give you performance equivalent to strlen itself.