Why it is not an error to increment array "a" in the below function?

Question

#include<stdio.h>
void printd(char []);
int main(void){
       char a[100];
       a[0]='a';a[1]='b';a[2]='c';a[4]='d';
       printd(a);
       return 0;
}
void printd(char a[]){
        a++;
        printf("%c",*a);
        a++;
        printf("%c",*a);
}

Explanation: I was expecting that it would result in lvalue error. But it is working with out any error and giving bc as output. Why is this incrementing array "a" is not an error?

[Because you're not incrementing an array.](https://web.archive.org/web/20150326025620/http://c-faq.com/aryptr/aryptrparam.html) — cremno, Jul 18 '15 at 06:35
If I had used a++(incrementing base address) in main function then I would have got error. — Subhiksh, Jul 18 '15 at 06:37
Yes, because the `a` in `main()` is an array and the `a` in `printd()` is a pointer. — cremno, Jul 18 '15 at 06:41
Related: http://stackoverflow.com/q/6567742/694576 and http://stackoverflow.com/q/5573310/694576 (for references to the C Standard) — alk, Jul 18 '15 at 07:21
A C11 draft can be found here: port70.net/~nsz/c/c11/n1570.html — alk, Jul 18 '15 at 16:30

alk · Accepted Answer · 2015-07-18T07:15:48.633

If an array is passed to a function it decays to a pointer to the array's first element.

Due to this inside printd() the pointer a can be incremented and decremented, to point to different elements of the array a as defined in main().

Please note that when declaring/defining a function's parameter list for any type T the expression T[] is equivaltent to T*.

In question's specific case

void printd(char a[]);

is the same as

void printd(char * a);

The code below shows equivalent behaviour as the OP's code, with pa behaving like a in side printd():

#include <stdio.h>

int main(void)
{
   char a[100];
   a[0]='a';a[1]='b';a[2]='c';a[4]='d';

   {
     char * pa = a;

     pa++;
     printf("%c", *pa);
     pa++;
     printf("%c", *pa);
   }

   return 0;
`}

score 3 · Answer 2 · answered Jul 18 '15 at 07:21

In C language array declaration in function parameter list and array declaration outside of function parameter list mean completely different things, even though they look similar (or the same) on the surface.

When you use array declaration in function parameter list (as is the case with void printd(char a[]) in your code), you are not declaring an array. The top-level [] syntax in function parameter list is just an alternative form of pointer declaration. This means that your a parameter is actually declared as char *a. It is not an array at all, it is an ordinary pointer. There's nothing unusual in being able to increment such a, and this is why you are not getting any "lvalue errors" from it.

Meanwhile, your a in main is a true array.

And _that_ is the actual correct explanation for the seemingly strange behaviour. You can't declare function parameters that are arrays. You can only use declarations that _look like_ array declarations. — gnasher729, Jul 19 '15 at 09:13

mazhar islam · Answer 3 · 2015-07-18T07:13:40.220

0

Why is this incrementing array "a" is not an error?

In C arrays are passed as a pointer to any function. Thats why you get no error.

The function calls in main() pass the name of the array, a, as an argument because the name of an array in an expression evaluates to a pointer to the array. In other words, the expression, a, is a pointer to (the first element of) the array, a[]. Its type is, therefore, char *, and a called function uses this pointer (passed as an argument) to indirectly access the elements of the array.

Now as you receive the address of the first element of a, a++ means ahead the array's initial address by 1. That's why the first printf prints b, the second element of array a.

edited Jul 18 '15 at 07:13

answered Jul 18 '15 at 06:33

mazhar islam

5,561
3
20
41

Still nitpicking: One does not pass the "name" of a variable, but the variable itself. So this "*pass the name of the array*" should read "*pass the array*". – alk Jul 18 '15 at 07:08
Also not "*the name of an array ... evaluates*", but the array itself. – alk Jul 18 '15 at 07:10
_name_ of the array is a metaphor which explained in the next line describing actually it means `char *`. – mazhar islam Jul 18 '15 at 07:13

Christian Fries · Answer 4 · 2015-07-19T20:07:54.707

0

a also works as a pointer. It is a pointer to the first element of the array. The a++ increments that pointer. That is, after a++ the a[0] or *a now gives you what a[1] gave you prior to the increment, that is 'b'.

Note that you do not increment the value of a[0] from 'a' to 'b'. Check that if you use different values in your array, like 'a, 'd', 'h', 'x'.

edited Jul 19 '15 at 20:07

answered Jul 18 '15 at 06:38

Christian Fries

16,175
10
56
67

@Ticktick, If you want to increment the value of a[0], you should do something like (*a)++ - not too elegant in this case, but used nonetheless. – piffy Jul 18 '15 at 06:42
"*a++ increments the pointer to the array.*" This is not correct. `a` in `printd()` initially is a pointer to the 1st element of `a` as defined in `main()`. A pointer to an array is something different. – alk Jul 18 '15 at 06:48

score 0 · Answer 5 · answered Jul 18 '15 at 06:49

An array is passed to a function as a pointer, which can be incremented.

So, in your example, it is not possible to increment a within the main() function, since a is an array and cannot be incremented.

However, not withstanding the syntax, the a within the printd() function is a pointer, so can be incremented. Incrementing a inside printd() does not affect the array a inside main() - although they have the same names, they are different entities within different scopes.

Why it is not an error to increment array "a" in the below function?

5 Answers5