2 Quick Pointer Questions:

**Krak** · 01-23-2003

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)

**Magos** · 01-23-2003

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.

**Polymorphic OOP** · 01-23-2003

*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.

**bennyandthejets** · 01-23-2003

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

**shiv_tech_quest** · 01-24-2003

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

**shiv_tech_quest** · 01-24-2003

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;

**bennyandthejets** · 01-24-2003

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++);

**bennyandthejets** · 01-24-2003

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.

Thread: 2 Quick Pointer Questions:

Thread Tools

Search Thread

Display

2 Quick Pointer Questions:

I don't think so

Re: 2 Quick Pointer Questions:

Similar Threads

sorting number

Double Pointer to a data type that is already a pointer!

A quick pointer question

Direct3D problem

Quick question about SIGSEGV