C Programming - Functions - Discussion

This program make use of two properties of pointers to array.

1. For pointer to an array, subscript value will also work with pointer. because behind the scenes in C/C++, a[2] is essentially *(a+2) making use of pointer
by the by, 2[a] will also work the same way(No Error here).

2. a[-1] will be *(a-1) but it will only work if a is pointer to the array and pointing somewhere in middle. if a is an array, 'a' will b base address of pointer and a[-1] will go out of bounds of Array printing a garbage value in the process.


Eg:

// initialized the array.
int a[] = {0,1,2,3,4};

// given pointer the address of a[2].
int *p = a+2;

// p points to a[2].
// it'll print 1.
printf("%d", p[-1]);

It is very easy:

1-char **p=argv. As argv is an array --> it is a pointer to its 1st element ("ab") --> argv=&("ab").

2- Now: t = (p+= sizeof(int))[-1];

* (p+= sizeof(int) -> p=p+2.
*As p=argv and argv is an array of pointers --> So, size of each element in argv array is 4-bytes--->As a result, +2=+8 bytes. (As sizeof(int=2-bytes)
So, p=&("ef").

Now:
t= &("ef")[-1] is equivalent to &("ef") - 4 (As we mentioned before sizeof("ef") =4-bytes)

So, t=&("cd").

Guys.

char *argv is a array of pointers to string.
p contains the base address of argv. p points to argv. and argv[] points to base address of the respective strings.

t=(p+= sizeof(int))[-1];

p=p+2 means p will point 2 locations ahead of its type. means argv[2]. and then p[-1], we can write it as *(p-1) so now it will point to argv[1]. due to * the base address of "cd" which is contained in argv[1] get returned in t and cd get printed.

@All.

There must be;

t=(*p+=sizeof(int))[-1];
let's say argv=address of ab.
let's say argv=100.ie ab is stored at address 100.
now argv is sent to a function which takes something which points to char array ie argv
So, p points to argv.
let's say argv has address 200 so p=200.
Now we cannot directly increment p we need to increment *p.
but its written t=(p+=sizeof(int))[-1];

@Sahil, it is t= (p+=sizeof(int)) [-1]; and it works like this.

First, sizeof(int) is replaced by 2.
Now, p is of char type so it's incremented by 2bytes during assigning p=p+2. Till this time it's pointing "ef" after this it will point "cd" after executing [-1]. That's all.

initally **p contains address of argv[0] element ie "ab".it is then incremented by 2 (size of int given as 2 bytes).now it point to "ef".It is then decremented by -1.so finally points to "cd".so it print value of t as "cd".

t = (p+=sizeof(int))[-1];
t = (p=p+2)[-1];

t = (p+2)[-1];//(p+2) refers to the base address of p +'2'

//We know that num[i]=*(num+1): refer to let us c ch 8 topic the real thing.(read completely)

t = *(p+2-1);
t = *(p+1);

//Output: cd acc. to turbo c

Here char *argv[]={"ab", "cd", "ef", "gh"};.

Than call fun (argv) ;.

In char **p there is "ab".

Then sizeof (int) means 2 and then 2-1=1 store in p.

So in t=1 so ab=0 cd=1 ef=2 gh=3 in array start with 0.

So print cd.

This is the statement given in the program:

(p+= sizeof(int))[-1];

If you look at the above statement, the parenthesis separates the increment part and (-1). Does this performs decrements operation?

Rahul said i don't think it decrement it
p[-1]=p-1
but not
p[-1] = (p=p-1) it dose not affect the result to the var, it just takes the value and decrement it but dose not save it to the variable