如何在C中使用strlen（）找到字符指针的长度？

Question

I am making it clear that my question is exact duplicate of this question.

But unfortunately I have one question which any of the answers didn't addressed. So the code was:-

#include <string.h>

int foo(void) {
  char bar[128];
  char *baz = &bar[0];
  baz[127] = 0;
  return strlen(baz);
}

Question was: What are the possible outputs of this function?

When I run this code, this gives 0 everytime and the correct answers are 0 and 127(I still didn't get why?).

My question is how this statement is even valid I mean we are calculating the length of baz which contains a memory address say 0xb96eb740 which is a hex number, so what we are doing is strlen() on this address to find it's length? I mean how can we find length of an address , which is just a number?

I am really confused and trying to understand it for hours but still not getting it.

Answer 1

Don't get stuck on the fact that it's being passed an address. strlen() always takes an address. It's argument is a const char * , the address of a string. All of these calls pass the exact same address:

strlen(baz);
strlen(&bar[0]);
strlen(bar);

baz is assigned &bar[0] , so the first and second are equivalent. An array decays to a pointer to its first element ( array == &array[0] ), so the second and third are equivalent.

I mean how can we find length of an address , which is just a number?

Let's say that bar == &bar[0] == baz == (char *) 0xb96eb740 as per your example. strlen() will first check if memory location 0xb96eb740 contains \\0 . If not, it will then check 0xb96eb741. Then 0xb96eb742. Then 0xb96eb743. It will continue checking each location sequentially until it finds \\0 .

I know that's true. But why does strlen(baz) return 0?

As the linked Q&A explains, the behavior is indeterminate because the contents of the bar[128] array are uninitialized. There could be anything in that array. The only cell we know the value of is bar[127] , which is set to \\0 . All the others are uninitialized.

That means that any one of them, or all of them, or none of them, could contain a \\0 character. It could change from run to run, from call to call even. Every time you call foo() you could get a different result. That's entirely possible. The result will vary based on what data happens to be on the stack before foo() is called.

When I run this code, this gives 0 every time and the correct answers are 0 and 127 (I still don't get why?).

It could return any value between 0 and 127. Due to the indeterminate behavior you mustn't read too much into what the program happens to return when you run it. The output could be different if you run the program again, if you cal a different set of functions before foo() , if you run a different program beforehand, if you change compilers, if you run it a different day of the week, if you use a different operating system, etc., etc., etc.

Answer 2

My question is how this statement is even valid I mean we are calculating the length of baz which contains a memory address say 0xb96eb740 which is a hex number, so what we are doing is strlen() on this address to find it's length?

The strlen function accepts an address as argument, and its behaviour is to read the character stored at that address. (It does not try to read the characters of the address as you seem to be suggesting). If that character is not '\\0' then it will read the character at the next address and see if that is '\\0' etc.

Answer 3

The answer to your question is anything can happen .

The array bar is uninitialized. Only bar[127] is explicitly set to '\\0' . Passing an uninitialized array to strlen() , which you do indirectly by passing baz , which points to bar[0] , has undefined behavior.

In practice, on modern architectures without trap values, function foo() has unspecified behavior and can return any value between 0 and 127 depending on whatever the stack contains when you call it.

In your case it returns 0 because there happens to be a null byte at the beginning of bar , but you cannot rely on that and successive calls to foo() could return different values.

If you run a program that calls foo() under valgrind or some other memory sanitizing tool, it might complain that strlen() accesses uninitialized memory.

Answer 4

Others have covered that the value is indeterminate , so I go directly to this:

I mean how can we find length of an address, which is just a number?

You don't. The length of a string is calculated by reading the memory sequentially from the address you want to start with and see how far you need to go before you hit the first '\\0' character. Here is an example of how you can implement a function that returns the length of a string:

int strlen(char * str) {
    int length=0;
    while(str[length] != '\0') 
        length++;
    return length;
}