* argv ++和* argv之间的差异-达到限制时

Question

could someone explain why

int main(int argc, const char * argv[]) {
  while (* argv) 
    puts(* argv++);
  return 0 ;
}

is legal, and

int main(int argc, const char * argv[]) {
  argv += argc - 1;
  while (* argv) 
    puts(* argv--);
  return 0 ;
}

isn't? In both cases the 'crement inside the while loop will point outside of the bounds of argv. Why is it legal to point to an imaginary higher index, and not to an imaginary lower index?

Best regards.

Answer 1

Because the C standard says you can form a pointer to one past the end of an array, and it will still compare properly to pointers into the array (though you can't dereference it).

The standard does not say anything of the sort for a pointer to an address before the beginning of an array -- even forming such a pointer gives undefined behavior.

Answer 2

Loop semantics and half-open intervals. The idiomatic way for iterating through an array or list of objects pointed to by a pointer is:

for (T *p = array; p < array + count; p++)

Here, p ends up being out-of-bounds (off by one, pointing one past the end of the array), so it's (not only conceptually) useful to require this not to invoke undefined behavior (the Standard actually imposes this requirement).

Answer 3

The standard forces argv[argc] to be equal to NULL , so dereferencing argv when it's been incremented argc times is legal.

On the other hand nothing is defined about the address preceding argv , so argv - 1 could be anything.

Note that argv is the only array of strings guaranteed to behave this way, as far as I know.

From the standard:

5.1.2.2.1 Program Startup

If they are declared, the parameters to the main function shall obey the following costraints:

argv[argc] shall be a null pointer

Answer 4

argv++ or ++argv as it is const pointer.

If you take a simple array like char* arr[10] and try arr++ it will give error