What happens when I use strlen() after incrementing a pointer?

Question

I've done some research on strlen() and have a question.

Let's say I have an array of 50 elements and a pointer to the first element, meaning:

char A[50],*x;
gets(A);
x=&A[0];

From what I've understood, strlen(x) was supposed to give me the length of the string.

My question is, what exactly happens as I increment x?

Answer 1

First of all, and sorry for the digression, but please, never use the obsolete gets() function. Please use fgets instead.

In answer to your question, if x is a pointer to a valid nonempty string, strlen(x+1) will always equal strlen(x) - 1.

Suppose we have this string, with x pointing to it:

     +---+---+---+---+---+---+
  a: | H | e | l | l | o | \0|
     +---+---+---+---+---+---+
       ^
       |
   +---|---+
x: |   *   |
   +-------+

That is, x points to the first character of the string. Now, what strlen does is simply start at the pointed-to character and count characters until it finds the terminating '\0'.

So if we increment x, now it points to the 'e' (that is, it points to the string "ello"), like this:

     +---+---+---+---+---+---+
  a: | H | e | l | l | o | \0|
     +---+---+---+---+---+---+
           ^
           |
          /
         /
        /
       |
   +---|---+
x: |   *   |
   +-------+

So strlen will get a length that's one less.

---

Footnote: I'm reminded of an amusing bug I've come across more than once. When you use malloc to allocate space for a string, you always have to remember to include space for the terminating '\0'. Just don't do it this way:

char *p = malloc(strlen(str + 1));

My co-worker did this once (no, really, it was a co-worker, not me!), and it was stubborn to track down, because it was so easy to look at the buggy code and not see that it wasn't

char *p = malloc(strlen(str) + 1);

as it should have been.

Answer 2

It will return less than it would have before. In C, a string is just a pointer to the memory address of the first character, so if your string was

"ABCDEF"

If you increment the pointer, instead of pointer to 'A' it will point to 'B', so the new string is

"BCDEF"

And strlen("BCDEF") is 5 whereas strlen("ABCDEF") is 6.

Answer 3

It gives you one smaller. x += i is roughly equivalent to the pseudocode x = substr(x, i). (Note that bad things will happen if i is more than the length of x.)

Answer 4

Your code:

char A[50],*x;
gets(A);
x=&A[0];

strlen(x) was supposed to give me the length of the string

what happens as I increment x? Does strlen(x) now give me the same value as before or a smaller one and if so, why does it happen?

Well the answer is more complicated than one may think. The answer is: it depends!

By declaring A[50] compiler will allocate 50 bytes on the stack which are not initialized to any value.

Lets say that content of A happens to be

A[50] = { '5', '1', '2', '3', 0 /*.............*/ };

Then consider two scenarios:

a) user enters:<enter>

b) user enters:'7'<enter>

The content of the array A will be for different

a) { 0, '1', '2', '3', 0 /*.............*/ };

b) { '7', 0, '2', '3', 0 /*.............*/ };

and results of the strlen may surprise you:

This is test program and results:

#include <stdio.h>
#include <string.h>

int main(void)
{
    char  A[50] = { '5', '1', '2', '3', 0 };
    char *x;

    gets(A);
    x=&A[0];

    for (int i=0; i < 5; i++)
        printf("%d: %02X\n", i, A[i]);

    printf("strlen(x)  = %zu\n", strlen(x));  
    printf("strlen(x+1)= %zu\n", strlen(x+1)); 

    return 0;
}

Test:

<enter>                                                                                                                                         
0: 00                                                                                                                                        
1: 31                                                                                                                                        
2: 32                                                                                                                                        
3: 33                                                                                                                                        
4: 00                                                                                                                                        
strlen(x)  = 0                                                                                                                               
strlen(x+1)= 3  

7<enter>                                                                                                                                            
0: 37                                                                                                                                        
1: 00                                                                                                                                        
2: 32                                                                                                                                        
3: 33                                                                                                                                        
4: 00                                                                                                                                        
strlen(x)  = 1                                                                                                                               
strlen(x+1)= 0 

As you know strlen counts number of characters from starting position till first '\0' is encounter. If starting byte is equal '\0' than strlen(x) = 0.

For scenario a) strlen(x), strlen(x+1) will be 0 and 3
For scenario b) strlen(x), strlen(x+1) will be 1 and 0.

Please do not use gets (Why is the gets function so dangerous that it should not be used?) and also notice that I print ASCII chars in hexadecimal format e.g.'2' = 0x32.