Pointer increment operator errors

Question

Ok so this one has me really confused. I'm working on a HW problem, and discovered something that was really weird to me. here is the function and call in question

int find_oldest_frame(int **a, int size)
{
   int min = clock();
   int **ptr;
   int *ptr2;
   int frame = 0;
   int i;
   // get address of pointer so we can modify it
   ptr = a;
   // store off original pointer location.
   ptr2 = *a;

   for (i=0; i<size; i++)
   {

      // Who is the oldest time
      if (**ptr < min)
      {
         min = **ptr;
         frame = i;
      }
      printf("Current_Pointer %d\n", *ptr);
      *ptr++; // For some reason ++ doesn't work.

   }
   // now store the oldest frame with the current system time, so it's no longer the oldest.
   *ptr = ptr2;
   *ptr += frame;
   **ptr = clock();
   *ptr = ptr2;
   // Return the array index so that we can change the right page!
   return frame;

}

So to make a long story short, I get a popup (in windows) that says there was a problem and has to close.

When I try replacing *ptr++; with *ptr+=1;

The program runs. This got me interested so I used -S in gcc With the *ptr++ version I get this instruction:

addl    $4, -20(%ebp)

with *p+=1 I get

movl    -20(%ebp), %eax
movl    (%eax), %eax
leal    4(%eax), %edx
movl    -20(%ebp), %eax
movl    %edx, (%eax)

Which to me looks like a very similar operation, so assuming I'm reading this correctly,

case 1

Increment -20(%ebp) by 4 (assuming $4 means that)

case 2

we store what is in ebp to eax,

(not sure what () do), but do it again?

then take and load the address from eax offset by 4 into edx,

now copy ebp back into eax again,

now copy edx into eax,

I mean it looks like they're doing the same thing, but for some reason *ptr++ != *ptr+=1

Why? What am I missing from what I see?

EDIT: THANKS Everyone now I feel special, I can't believe I didn't realize that!

Unless your asm is very different from mine (it might be), you're reading it backwards. mov ax, bx = "copy bx into ax". — egrunin
– egrunin, Commented Nov 1, 2010 at 14:41
@egrunin I wasn't sure if it's the same across the board, I haven't read much assembly at a computer level (I've read quite a bit on a powerpc for a class, but it wasn't assembly), so I had the data swapped...sorry :) — onaclov2000
– onaclov2000, Commented Nov 1, 2010 at 14:45
GCC asm is always src on the left, dest on the right. delorie.com/djgpp/doc/brennan/brennan_att_inline_djgpp.html — Peter Stuifzand
– Peter Stuifzand, Commented Nov 1, 2010 at 14:46
@egrunin I think in the powerpc that I have frequently used, I think it's the way you described, so I really wasn't sure, It just looked that way based on the other assembly I was seeing. Which is why I guessed such. — onaclov2000
– onaclov2000, Commented Nov 1, 2010 at 14:55

Wladimir Palant · Accepted Answer · 2012-06-08 12:29:45Z

6

This is actually an issue with the operator precedence. The postfix increment operator gets applied before the pointer is dereferenced, meaning that you increment the value of the pointer (the memory it points to) and then attempt to dereference it. This is invoking undefined behaviour since it points to a single int.

In the latter case, the += is applied after the dereference occurs, so you get the value stored at the pointer's memory, then you add to it. You need to make sure the dereference occurs first if you want to use postfix increment, which you can do by using:

(*ptr)++;

instead of what you currently have.

edited Jun 8, 2012 at 12:29

Wladimir Palant

57.8k12 gold badges100 silver badges129 bronze badges

answered Nov 1, 2010 at 14:40

eldarerathis

36.4k10 gold badges93 silver badges94 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

sharptooth · Accepted Answer · 2010-11-01 14:39:56Z

2

This

*ptr++; // For some reason ++ doesn't work.

should be

 (*ptr)++;

Operator precedence matters here - *ptr++ works this way: *(ptr++) - the same way as

 while( ( *t++ = *s++ ) != 0 );

copies a null-terminated string.

answered Nov 1, 2010 at 14:39

sharptooth

171k110 gold badges545 silver badges1k bronze badges

Comments

Frédéric Hamidi · Accepted Answer · 2010-11-01 14:42:25Z

2

The operator precedence is not the same. They are respectively equivalent to:

*(ptr++);

And:

(*ptr) += 1;

You can do *(ptr)++; to increment the pointed value and leave the pointer itself untouched.

answered Nov 1, 2010 at 14:42

Frédéric Hamidi

264k42 gold badges497 silver badges486 bronze badges

Comments

Fred Foo · Accepted Answer · 2010-11-01 14:41:01Z

1

The ++ operator has higher precedence than *, which has higher precedence than +=. The ++ binds to ptr, while the += binds to (*ptr).

answered Nov 1, 2010 at 14:41

Fred Foo

365k80 gold badges765 silver badges852 bronze badges

Collectives™ on Stack Overflow

Pointer increment operator errors

4 Answers 4

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related