How to iterate through a struct array in C?

Question

The following struct is given:

typedef struct {    
    int a;    
    int b;    
    int c; 
} POST, *PPOST;

The assignment is to make a function int compare_post( PPOST pp, POST p); that checks if there is identical copy of p in the "array" pp, which ends with a null-pointer.

The correct answer is the following:

int compare_post( PPOST pp, POST p) {
       while( pp ){
            if((pp->a == p.a )&&(pp->b == p.b )&&(pp->c == p.c ))
               return 1;            
            pp++;     
       }
      return 0; 
}

My question is why while(pp) is used and not while(*pp)? Don't we need dereference pp to get the actual value in order to detect where it is NULL?

Answer 1

The assignment does not make sense, because the function prototype

int compare_post( PPOST pp, POST p);

mentioned in the assignment does not make sense. The function parameter pp can't be a pointer to the first element of an array terminated by a NULL pointer. If an array is to be terminated by a NULL pointer, the array must have a pointer data type, i.e. it must be an array of pointers. However, if the array has a pointer data type, then a pointer to the first element of that array must be a pointer to a pointer. In other words, there must be two levels of pointer indirection. Therefore, the first parameter of the function must be changed to the following:

int compare_post( PPOST *pp, POST p );

which is equivalent to:

int compare_post( POST **pp, POST p );

For clarity, and because some people consider creating typedefs for pointers inappropriate, I will use the second syntax.

With this new function prototype, the correct answer would be the following:

int compare_post( POST **pp, POST p ) {
    while ( *pp ) {
        if ( ( (*pp)->a == p.a ) && ( (*pp)->b == p.b ) && ( (*pp)->c == p.c ) )
            return 1;
        pp++;
    }
    return 0;
}

Answer 2

Written without typedefs to clarify that p is a struct and pp is a pointer,

struct Post { int a, b, c; };

int compare_post(struct Post *pp, struct Post p) {
    while(pp) {
        if((pp->a == p.a) && (pp->b == p.b) && (pp->c == p.c))
            return 1;            
        pp++;     
    }
    return 0;
}

While it makes syntactic sense to say while(pp), which is a pointer comparison that enters the loop as long as pp is not null, it almost certainly is a logical error. A null-pointer is "guaranteed to compare unequal to a pointer to any object or function". So, if pp is a valid object of struct Post, it will repeat the comparison until an array element is pairwise equal, returning 1, or go off the side of the array and cause undefined behaviour. The only way to call this safely is pass a null pointer as pp (returns 0) or by engineering any in the pp array equal to p, (returns 1.) By the function name, I would expect something like this:

int compare_post(struct Post *x, struct Post *y) {
    return (x->a == y->a) && (x->b == y->b) && (x->c == y->c);
}

This is at a different level of indirection from C strings, which, in order to represent a variable-length, they use a sentinel NUL. This character is all-bits-zero, and is represented by the escape-sequence '\0', as well as a explicit cast (char)0. This is not null-pointer in the previous context.

Answer 3

The better title for this question is to how to pass array to function. The function in question is incorrect - to force this approach to work we need to change signature - to pass pointer to PPOST. Most likely author of this code relies on idea (not standard) that end of sequence is specified with special value NULL (sentinel), that is for array (allocated for N + 1 pointers) after N not empty elements (pointers to structure) follows N + 1 element (pointer) that will be equal to zero. This zero pointer will mark the end of range. And of course this is responsibility of coder - to mark the end of array of pointers by assigning last element to NULL before calling the function. Do following before calling a function:

// allocate array of pointers
PPOST *ptr = (PPOST*) malloc((N + 1)*sizeof(PPOST*));
ptr + N = NULL; // mark the end - sentinel
POST p;
// ---
compare_post( ptr, p)
// ---
int compare_post( PPOST *pp, POST p)
{
   while( *pp ){
        if(((*pp)->a == p.a )&&((*pp)->b == p.b )&&((*pp)->c == p.c ))
           return 1;            
        pp++;     
   }
  return 0; 
}

You should test the pointer - dereferenced pointer to pointer (*pp) - not value of structure **pp. That is you will iterate through array until you reach N + 1 element.

More common approach (especially widely used in C++ std library) is to pass too pointers to specify boundaries of range: begin of sequence and one past the last: [beg, end). Where end is not included in range. This allows to avoid creating of tedious array of pointers:

// allocate array of struct POST
PPOST ptr = (PPOST) malloc( N * sizeof(POST));
// fill structures
PPOST onePastTheEnd = ptr + N;
POST p;
// ---
compare_post( ptr, onePastTheEnd, p)
// ---
int compare_post( PPOST pp, PPOST end, POST p)
{
   while( pp != end ){
        if((pp->a == p.a )&&(pp->b == p.b )&&(pp->c == p.c ))
           return 1;            
        pp++;     
   }
  return 0; 
}

As soon as we start to change function signature we can also pass the size of the array - this is another approach.