2 Quick Pointer Questions:

I have two questions about pointers:

Code:

---

#include <iostream.h>
void somefunc(int * fptr)
{
  *fptr += 250;
}

void somefunc2(int * fptr2)
{
  *fptr2 = 450;
}

void somefunc3(int * fptr3)
{
  *fptr3 ++;// This doesn't work.
}

main()
{
  int x = 3;
  int * Xaddr = &x;

        cout << x << endl;

  somefunc(Xaddr);
        cout << x << endl;

  somefunc2(Xaddr);
        cout << x << endl;

  somefunc3(Xaddr);
        cout << x << endl;
  return 0;
}

---

Yet, strangely, the same line here does:

Code:

---

#include <iostream.h>
void somefunc(int * fptr)
{
  *fptr += 250;
}

void somefunc2(int * fptr2)
{
  *fptr2 = 450;
}

void somefunc3(int * fptr3)
{
  *fptr3 += 1; // This does work.
}

main()
{
  int x = 3;
  int * Xaddr = &x;

        cout << x << endl;

  somefunc(Xaddr);
        cout << x << endl;

  somefunc2(Xaddr);
        cout << x << endl;

  somefunc3(Xaddr);
        cout << x << endl;
  return 0;
}

---

My two questions are thus:

1.) In cases like this, does the ++ operator not work?
2.) Is this one of the primary uses of pointers? (Through functions)

Could be a problem with the priority of operators (increasing the pointer instead of the data). Try this and see if it works better:

(*fptr3)++;

Pointers can be used for many things. Using them to increase single integers in the way you do it isn't so common though.

*fptr3++ does not deference a pointer and then increment it. It dereferences the pointer and then increments the POINTER sizeof(int) (not the value of the data fptr points to). operator++ is working, but you are confused on it's presedence with respect to the dereference operator.

Polymorphic, I think you got it the wrong way around. Those operators have precedence from right to left. That means that the following two statements are equal:

Code:

---

*fptr3++;
*(fptr3++);

---

The address contained within the pointer is incremented by sizeof(int), then it is dereferenced.

Code:

---

                        Precedence of Operators

Operator                                Order of evaluation

()  []  .  ->                                left to right
! ~ - ++ -- & * (type) sizeof    right to left //see this line
*  /  %                                    left to right
+  -                                          left to right
<<  >>                                    left to right
<  <=  >  >=                            left to right
==  !=                                    left to right

---

Quote:

---

Originally posted by bennyandthejets
Polymorphic, I think you got it the wrong way around. Those operators have precedence from right to left. That means that the following two statements are equal:

Code:

---

*fptr3++;
*(fptr3++);

---

The address contained within the pointer is incremented by sizeof(int), then it is dereferenced.

---

This should help you

Code:

---

int x[3] = { 10, 20, 30 };

int *p = x;

int  temp = *p++;

// In your terms, p++ would take it to &x[1] and the value at that place
// which is 20 would be assigned to temp

but *p++ works this way
first *p
then p++

// so reality is temp gets 10 and then p gets incremented from
&x[0] to &x[1]

---

operations done on pointers are w.r.t THEIR DATATYPE and not w.r.t the datatype of the data that they are pointing to

Quote:

---

Originally posted by Krak
I have two questions about pointers:
[code]
void somefunc3(int * fptr3)
{
*fptr3 ++;// This doesn't work.
}


void somefunc3(int * fptr3)
{
*fptr3 += 1; // This does work.
}

My two questions are thus:

1.) In cases like this, does the ++ operator not work?
2.) Is this one of the primary uses of pointers? (Through functions)

---

This is the error in first form

*fptr3++; gets translated this way
1) *fptr;
2) fptr++;
I bet that's now what you wanted

So the correction is (*fptr)++;

(*fptr)++ is as good as

(*fptr) + = 1; or (*fptr) = (*ftpr) + 1;

Are you trying to say that both operations are performed separately? I don't think so. Where brackets are not included, doesn't it evaluate according to operator precedence, for each term in the expression? Ie:

Code:

---

*ptr++;
//RIGHT TO LEFT precedence, I've proved it before
//first ptr++ is evaluated.
//so it becomes:
*(ptr++);

---

Ok, I concede. More experimentation caused me to remember that if a ++ is after the variable, it is evaluated last. If it is before the variable, it is evaluated first. Damn, this stuff is too confusing.