C Programming - Arrays - Discussion

int (*ptr)[10];
here "ptr" is name of array,[10] is index of that array.
but '*'-it denotes the pointer varable is created of specified name. name-(ptr).

*ptr[10] means 'ptr is an array of pointer type 10 elements'.

(*ptr)[10] means there is an array of 10 elements with no array varaible but 'ptr is pointer type variable' that has base address of that array.

I have got that ++a is pre-increment so it will increment and then assign the value.

Similarly a++ means it assigns and then increment so its value cannot be printed by this only it shows the value what we assigned..... clear per-increment post-increment is the concept used there...!!!!!

@Chris:
Turbo C uses __Cdecl__ type of Argument Passing mechanism in which rightmost arg is passed 1st and leftmost at atlast..
In printf(), as u might know, the leftmost format specifier is associated with leftmost value,but due to __Cdecl__, the evaluation of values is done from rightmost position..
So, 1st %d -> a++
2nd %d -> a--
3rd %d -> ++a
4th %d -> --a
5th %d -> a
This is binding is done,but as rightmost is evaluated 1st,
5th %d has value of a(5)
4th %d has --a(4) as preincrement has higher priority
3rd %d has ++a(5)
2nd %d has a--(5) as post increment is done after assignment
1st %d has a++(4) same reason as above..
So the output is as given..
Hope u have understood..
gd:)

*ptr (10) means.

It is a pointer type aaray whch have 10 integers in it.

Any one can explin main difference between a[] & *ptr[] with an example.

@Chris and @Sundar:

"printf("%d %d %d %d %d", a++, a--, ++a, --a, a); " evaluates the value passed in it from right to left(int turbo C).
That is
first "a" will get its value as 5
then --a will store 4
then ++a will store 5 (as "--a" had decremented a's value n ++a incremented it)
then "a--" will have 5 ( as a-- is post increment therefore a's value will be affected after evaluation of the expression "a--")
then "a++" will have value 4 (b'coz above "a--" has made its value 4)

Therefore output is: 45545
Hope u know preincrement increments the value first and then use it in the expression, whereas postincrement uses the previous value of the variable and then modifies it thet is increments by 1.

eg:
int x=5 ,y,z;
y= ++x; //first x will become 6 then y will get assigned 6
z= x++; //first x will get assigned in z that is z=6 then x gets incremented.

Good night :) :)
Hope u understood....

@Chris

The given output '4 5 5 4 5' is matches in Turbo C - 16 OS (DOS).


But, I tried in GCC, the details are as below:

Warnings:=

prog.c: In function 'main':
prog.c:5: warning: operation on 'a' may be undefined
prog.c:5: warning: operation on 'a' may be undefined
prog.c:5: warning: operation on 'a' may be undefined
prog.c:5: warning: operation on 'a' may be undefined

Output:=

4 5 5 5 5

Please can anyone explain with full details here. Thanks in advance.

#include<stdio.h>
int main()
{
int a=5;
printf("%d %d %d %d %d", a++, a--, ++a, --a, a);
return 0;
}

// Ans : 4 5 5 4 5

Can any one explain the above code please ?

The brackets are the key to this problem. Always read C declarations from right to left (backwards) and start will stuff inside brackets.

[] = array * = pointer

int *ptr [10] backwards is [10] ptr * int

so this is Array of 10 pointers to int

int (*ptr)[10] bracket first and backwards is * ptr [10] int

so this is pointer to an array of 10 integers