lvalue required as increment operand

Array is a static continuous block of allocated memory. Array names are immutable references to the first block memory. An attempt to increment the address (referenced by name of array) would result in loss (better to say deference) of other memory locations. Say we have array

int p[]={10,20,30}

Here p (by design) refers to index 0. Say somewhere we increment p as : p++
Assuming increment to be allowed would result in p to point to index 1. Now thinking what p[1]=?
p[1] would then translate to dereferencing the value one place to the right of the current p location

Or location p[2] for original array.
Do this repeatedly and soon tracking the array indices would become very troublesome.
So to avoid such mishaps array names(lvalues) addresses are immutable. Another concept is word addressing and byte addressing:-

Character Arrays(string) in C are byte addressable instead of being word addressable. So if we have an array

int a[]={10,20,30}

printf("%d",*(a+1)) //Ouput:20 (int is word addressable)
printf("%d",*(++a)) // Error: Array references are immutable

int* cpya=a;
printf("%d",*(++cpya)) /* Output:20 (cpy is not array reference but a copy. Hence is Mutable) */

char b[]="Hello"
printf("%c",*(++b)) // Error : Array references are immutable
printf("%c",*(b+1)) /* undefined_behavior as character Array(strings) are byte addressable and not word addressable */
printf("%c",*(b+sizeof(char)*1)) // Output :e (It's byte addressable).