For loop with pointer in C

Question

I don't understand what a pointer does in the for loop. What does the *p do in the following loop?

char str[128] = "Some Text";
char *p;

for (p = str; *p /*what does this mean?*/; p++)
{
    // Code
}

I do understand the rest, but why isn't *p like p > 3 or something like that?
Why is it alone?
Why is it written that way?

Answer 1

In a Boolean context such as the condition of a for loop, each expression in C evaluates to true (non-zero) or false (zero).

You want the for loop to terminate, when it reaches the end of the string.

In C, each string is terminated with the character '\0', which is practically 0. So, when the for loop reaches the end of string, *p evaluates to '\0', which is 0, which evaluates to false, which terminates the for loop.

Answer 2

The for loop will terminate if whatever lies between the two ; in the statement is zero (false). *p dereferences p and returns the char, p points to. According to Dennis Ritchie "C treats strings as arrays of characters conventionally terminated by a marker". That marker is the null character with (ASCII) value of zero. So, this for loop :

for (p = str; *p; p++)

is equivalent to these

for (p = str; *p != '\0'; p++)
for (p = str; *p != 0; p++)
for (p = str; p[0] != '\0'; p++)

Another name for the null terminating character is sentinel or according to Donald Knuth "dummy value" (Art of Computer Programming, Volume 1). Here is a diagram of the str string, the indexes (offsets from the start) of each character and the values at each index :

For completeness and after a request at the comments here is what the debugger sees in the memory block that str occupies :

0x00007fffffffe6a0:
  0x53 0x6f 0x6d 0x65 0x20 0x54 0x65 0x78 0x74 0x00 0x00 0x00 0x00 0x00 0x00 0x00
     S    o    m    e         T    e    x    t

1. The hex value at the first line is the address (64bit) of this memory block. That's where p points to at the start of the for loop.
2. On the 2nd line you see the hex values of the letters in your string. You can see an ASCII table here. The last char in your string is t with hex value of 0x74. After that you have the string's null character 0x00. Then you see a few more null characters because I built in debug mode and the compiler zero-initialized. Normally you would see garbage (seemingly random values)
3. On the 3rd line I added the chars of your string for reference

I understand you are on precipitous learning curve at the moment with pointers in C, but eventually you'll be able to say "I C the point"

Answer 3

Before diving in, I would like to state a simple rule in C regarding an expression

When C requires the Boolean value of an expression, a false value is inferred when the expression compares equal to zero, and a true value otherwise. That is, whenever one writes

if(expr)

where expr is any expression at all, the compiler essentially acts as if it had been written as

if((expr) != 0)  

Now coming to your question:

What does the *p do in the following loop?

In C, strings are terminated by a null character '\0'.

Every character has a decimal equivalent. This '\0' is an ASCII escape character. The decimal equivalent of '\0' is 0.

So, the expression *p in loop just check that the decimal equivalent of character at the memory address pointed by p is either a zero or non-zero. When p reaches the end of the string and finds the first '\0' character, the expression *p returns¹ a zero value. A zero means false in C. This is equivalent to testing *p != '\0' or *p != 0 as stated above.

This is how it works:

---

_{1 When *p evaluates then the value of *p is fetched from memory. This value is the value of expression *p.}

Answer 4

This could be rewritten like this

for (p = str; *p != '\0'; p++)
{
    // Code
}

In C, a string must always be terminated by a null character, which is the same as '\0' or 0.

Answer 5

Lets analyze it the dry but depth way!

^{Or as D. Ritchie would say: Let's do it with the power of assembly language and the convenience of … assembly language.}

---

I'll try to explain all necessary aspects by referencing the ISO/IEC:9899 (emphasis mine)- C99 standard. (The post style is motivated by Donald Knuth's phrase "Science is what we understand well enough to explain to a computer. Art is everything else we do. ")

First of all, lets inspect what exactly is the for-loop supposed to do!

Referring to ISO/IEC:9899 6.8.5 "Iteration statements"

Semantics

4 An iteration statement causes a statement called the loop body to be executed repeatedly until the controlling expression compares equal to 0.

So far nothing new I guess, so lets get it on:

6.8.5.3 The for statement

1 The statement for ( clause-1 ; expression-2 ; expression-3 ) statement

behaves as follows: The expression expression-2 is the controlling expression that is evaluated before each execution of the loop body. ...

So we now know the body (in your case // Code) will be executed as long the beforehand evaluated value of your *p is not zero.

... The expression expression-3 is evaluated as a void expression after each execution of the loop body.[...]

So now we know, (I assume digging up p++'s definition is not necessary?!) that for each iteration p increments, so there may be a change in *p.

The following point is not related, but I'm adding it since this makes the Semantic part of for complete and its well to know since its the reason, why for(;;) is a inf-loop.

2 (---) Both clause-1 and expression-3 can be omitted. An omitted expression-2 is replaced by a nonzero constant.

Ok, that's the dry but information-enriched part of what the for loop does in your case.

Now lets get over to pointer arithmetic:

6.5.6 Additive operators

Constraints

2 For addition, either both operands shall have arithmetic type, or one operand shall be a pointer to an object type and the other shall have integer type. (Incrementing is equivalent to adding 1.)

So in your case you are adding 1 (integer) to the "pointer to an object"-type.

What is equivalent to increasing the Address by the sizeof its pointed to type like shown in this picture of tomislav kostic:

Now lets see what *p actually does.

6.5.3.2 Address and indirection operators

Constraints

[...]

2 The operand of the unary * operator shall have pointer type.

Semantics

[...]

4 The unary * operator denotes indirection. If the operand points to a function, the result is a function designator; if it points to an object, the result is an lvalue designating the object. If the operand has type ‘‘pointer to type’’, the result has type ‘‘type’’. If an invalid value has been assigned to the pointer, the behavior of the unary * operator is undefined.

This is a bit dry again¹ but for better understanding this can be reverse engineered by:

6.5.2.1 Array subscripting

[...]

Semantics

2 A postfix expression followed by an expression in square brackets [] is a subscripted designation of an element of an array object. The definition of the subscript operator [] is that E1[E2] is identical to (*((E1)+(E2))).

So *((p)+(0)) what is(since p+0 is same as p... obvious) is equal to p[0], is doing nothing else as evaluating p's object.

And since we know, expression-2 of a for loop is interrupting the iteration if it is evaluating 0, we can say it is the same as p[0] != 0.

Now the final step

Lets just look onto the C-Coder's Friend; JSSCA... No, wait...our friend was called... ASCII Now as that's clarified, we can figure out what the 0 is representing.

It is the NULL-token that in C is designating the end of a string.

---

So conclusive:

All, this is doing is:

Iterating the body of that for-loop, until p is actually pointing to the address, where the object evaluates to the "end of string"-token.

Or:

Let p go through the string until the end is reached.

---

And now just to cite my self; Something you never should forget:
(emphasis mine.....)

A variable is declared through a declarator(type-specifier) that precedes the identifier which names an lvalue object that can be evaluated to its value

It is neither more nor less!

---

¹_{That is, what I promised! ;)}

Answer 6

The *p Haiku

Poetically, I tried to represent the struggling of *p in the loop:

Brave C *p(rogrammers)

In the loop of whilederness

The NUL will stop them

_{This is an haiku poem, it consists of three lines, with the first and last line having 5 syllable, and the middle line having 7. Another example by @Samidamaru (a Master Haiku Poet, see comment below): First p equals str, Then p is incremented, Until *p is NUL.}

---

A little bit of pop

Hour of Code ambassador, Jessica Alba

---

What does the *p do in the loop?

Following the imaginary advice of Jessica (who is citing D. Knuth (1)), we will try to see the meaning of *p in the for loop:

for (p = str; *p; p++)

To this goal we first examine how the unary operator "*" works in C: “The unary operator * is the indirection or deferencing operator; when applied to a pointer, it access the object the pointer points to.” (B. Kernighan and D. Ritchie (2))

So *p is simply the value pointed by p:

1.1 A closer look to the for loop

The for loop is composed of three instructions:

1. p = str
2. *p
3. p++

In 1. we assign the pointer to the array str to p. In C the following assignments have the same effect:

p = &str[0];
p = str; 

“By definition, the value of a variable or expression of type array is the address of element zero of the array” (K & R (2)). Moreover we have that “In evaluating a[i], C converts it to *(a+i) immediately. …. it follows that &a[i] and a+i are identical” (K & R (2)). If we put i = 0, we obtain the above assignments.

We can now state that, at the beginning of the for loop, p points to the first element of str.

1.2 The core of the question

Let's move to the point 2., the core of your question. The second expression of the loop controls the exit condition: the instruction "*p" is evaluated and if is false the loop exit. This means that "*p" is equivalent to "*p != 0" or in words: when the value pointed by p is zero, exit.

Now, to understand when *p is zero we recall that the array str has been initialised as follows:

char str[128] = "Some Text";

and: “all string constants contain a null termination character (\0) as their last character” (gnu-manual). So the string actually stored in memory has a \0 at the end: "Some Text\0".

In the third instruction, p++, the pointer p is advanced to the next element of the str array, thus, at the 9-th iteration *p became 0 (or \0, NULL, NUL, see the answer from @Joe) and the loop exits.

1.3 See to believe

A picture is worth a thousand words, here is a graphical representation of the loop:

1.4 A further example: the same usage of *p in a different example

In the following snippet *p is used the same way but in a while loop:

#include <stdio.h>
int main() {
    char str[128] = "We all scream for ice cream!";
    char *p = str;
    // here we see again the loop exit condition *p == '\0'
    while(*p) {
        printf("%c", *p);
        p++;
    }
    printf("\n");
}

---

_{May the for(;*C;)e be with you!}

---

References

(1) Vol. I, Fundamental Algorithms, Section 1.1 (1968)

(2) The C Programming Language Pg 94-99

Answer 7

It takes advantage of the fact that the terminator to the string (eventually found by that for loop) will be an ASCII NUL, which is a zero, which also happens to evaluate to false, thus terminating the for loop.

It's worth noting the difference and similarity between 0, false, NULL and ASCII NUL. See this question: What is the difference between NULL, '\0' and 0

Answer 8

A long time ago, in a PDP far, far away, resources were scarce, names got short: i for index, p for pointer would please early Jedi programmers.

Implicit tests told the truth in for condition space. A single * was all they typed, trusting p and pushing it to the end of strings.

To this day, they use the for(e = s;*e;e++) most familiar and elegant loop to defy the C++ empire and its cohorts of ctors, dtors and vile iterators. Bare bits and bytes against templates, exceptions and obscure types, only the brave still dare for C to fight, and uncast the void *.

Answer 9

I have tried to satisfy the bounty awarder's desires which were mentioned at various times. To keep it simple I have restricted my answer to three sections of three lines each, and because (as The Bellman said in his Rule Of Three) "What I tell you three times is true" (the theme of this answer).

Technical

The truth of your for loop terminates it when the expression *p evaluates to 0 and this evaluation is performed before every iteration of the loop, note that in C 0 is false and anything else is true - that's a very expansive definition in other worlds!

The pointer variable p is initialised once, to point to the start of the array with p = str, and p is incremented at the end of every iteration, so *p is accessing successive elements of the array in each iteration.

The expression *p will thus evaluate to 0 (false) when the array element read by *p is the 0 or '\0' terminator that signals the end of a C "string", but you can't see this zero in the initialisation of str because it is supplied by the compiler automatically.

Lyrical

Expressions of truth

Are not understood by youth

Read Ritchie and Knuth

Whimsical

Jessica Alba is a fine actress who is very knowledgeable, having taken on board truths from observing the development of computer technology, as these quotes reveal:

"Every five years I feel like I'm a completely different person."

"It's all about your product and how it performs. Either it works, or it doesn't."

Answer 10

A haiku:

WHY   for (p=str; *p;        p++)
IS    for (p=str; p[0] != 0; p++)
THINK for (i=0;   str[i];    ++i)

EDITED

Here is some additional detail:

The second line of code of the "haiku" is equivalent to the first line. The original post asks "what does this mean" in a code-comment. The second line demonstrates the answer by equivalence. *p means p[0]. The second clause in the for loop cares about whether or not p[0] is equivalent to zero.

The third line of code of the "haiku" is a line of code which can be used conceptually: You can think of the operation of the original line as behaving much like the third line ought to.

Answer 11

As you can see from the picture, for loop starts with *p where p points the str. At this point *p has S.

When continuously looping the for, it finally reaches to str[9] which has '\0' which means NULL.

At this point the condition statement *p in for (p = str; *p; p++) is equal to NULL so the code will break from the for loop.

Answer 12

That is the condition part of the loop.
If that condition is not met then the loop is not executed anymore.
*p dereferences the pointer p and returns the character pointed at in the string str.
The C-style string str is terminated by the value \0.
The loop iterates over each character (using p) until the condition is not met.

In C a value of 0 or \0 is like the meaning offalse, i.e. condition is not met.
Any other value is like the meaning of true, i.e. condition is met.

In short, p iterates over each character in str and stops as soon as it hits the string termination character \0.

Why not using p instead of *p?
Because p is a pointer and contains an address. It's sometimes hard or even not possible to use address arithmetic only. It's not good practice and makes code hard to read.
*p is the dereferenced pointer and contains the value that p points to. In this case it is easy to use the values that p points to, because you know the string is terminated by a \0. As a condition (if, while, etc.) *p is equivalent to *p != '\0'.

Answer 13

Firstly you need to grasp a concept of pointer, like name says they point to something. Pointer contains adress of variable.

    int var=0;
    int *p;
    int p=&var;

in this code p is a pointer and printf("%d",p); prints adress of variable var and printf("%d",*p); prints value of variable var which in this example is 0.

Secondly, you must understand how arrays works.Arrays are kind of data structure that can store a fixed-size SEQUENTIAL collection of elements of the same type.

        int array[3]={9,8,7};
        printf("%d",array[0]); //prints what is on 1st position,9
        printf("%d",array[1]); //prints what is on 2nd position,8
        printf("%d",array[2]); //prints what is on 3rd position,7

operator [] are just user-friendly work with arrays. Last three lines of code can be replaced with following lines(and they will do just the same):

        printf("%d",*(array+0)); //prints what is on 1st position,9 
        printf("%d",*(array+1)); //prints what is on 2nd position,8
        printf("%d",*(array+2)); //prints what is on 3rd position,7

array is pointer to first element of array(contains adress of first element in array), so dereferencing it we get value of first element e.g. *array. We know that arrays are seqential which means that array+1 points to second element of array,so dereferencing this you get value of second element e.g. *(array+1), and so on.

Same also aplies for strings because they are array of char, except string has '\0' (null character) at the end of strings.

    char str[128] = "Some Text";
    char *p;

    for (p = str; *p; p++)
    {
        printf("%c",*p);
    }

This program prints string str.

p = str //assign address of first character of string str to p,we don't won't to lose a track of first char in string so we use p not str to iterate

*p //this expresion means *p!=0 so this is true until you arrive at the end of string,remember that '0' in ascii has integer value 48

p++ //at the end of for block you add +1 to p to obtain adress of next char

Answer 14

It can be explained as follows :

for( initialization ; Conditional Expression ; expression3)
{
    Code here will execute while 2nd Expression(Conditional Expression) is true
    true means non-zero value
    '\0' is equivelant to 0,so when *p equal '\0' : loop will terminate
}