integer int i; *i++ and ++*i have a different integer value after the increment

Discussion in 'C++' started by Robben, Dec 26, 2005.

  1. Robben

    Robben Guest

    Hi All,

    I have an integer pointer with value 10, but it returns a different
    return value after the preincrement and post increment.

    I will be very thankful if somebody can give an explanation for this
    behavior.

    Listed below is the program and output - executed in vc++6.

    int main(int argc, char* argv[])
    {
    int *i = (int*) calloc(sizeof(int),1);
    *i = 10;

    cout << " *i++ " << *i++ << endl;
    cout << " *i " << *i << endl;

    *i = 10;
    cout << " ++*i " << ++*i << endl;
    cout << " *i " << *i << endl;

    return 0;
    }


    *i++ 10
    *i -33686019
    ++*i 11
    *i 11
    Press any key to continue
     
    Robben, Dec 26, 2005
    #1
    1. Advertising

  2. Robben

    Luke Meyers Guest

    Re: integer int i; *i++ and ++*i have a different integer value after the increment

    Review operator precedence. operator++ has higher precedence than
    unary operator*, so
    *i++
    is equivalent to
    *(i++)
    and not equivalent to
    (*i)++
    which is what your presumably wanted. When you dereference a pointer
    and find an unexpected, large-magnitude value, it generally means that
    the pointer isn't pointing where you thought it was.

    Luke
     
    Luke Meyers, Dec 26, 2005
    #2
    1. Advertising

  3. Re: integer int i; *i++ and ++*i have a different integer value after the increment

    Robben wrote:
    > Hi All,
    >
    > I have an integer pointer with value 10, but it returns a different
    > return value after the preincrement and post increment.
    >
    > I will be very thankful if somebody can give an explanation for this
    > behavior.
    >
    > Listed below is the program and output - executed in vc++6.
    >
    > int main(int argc, char* argv[])
    > {
    > int *i = (int*) calloc(sizeof(int),1);


    Don't:

    int* i = new int;

    > *i = 10;
    >
    > cout << " *i++ " << *i++ << endl;


    This is *(i++) : increment the pointer, return the old address and
    dereference it.

    > cout << " *i " << *i << endl;
    >
    > *i = 10;


    illegal, i does not point to valid memory anymore.

    > cout << " ++*i " << ++*i << endl;


    and this is ++(*i) : dereference the pointer and increment the value.

    > cout << " *i " << *i << endl;


    Don't forget to delete the int:

    delete i;

    > return 0;
    > }
    >
    >
    > *i++ 10
    > *i -33686019
    > ++*i 11
    > *i 11



    Jonathan
     
    Jonathan Mcdougall, Dec 26, 2005
    #3
  4. Robben

    Luke Meyers Guest

    Re: integer int i; *i++ and ++*i have a different integer value after the increment

    > Don't forget to delete the int:
    >
    > delete i;


    Remembering, of course, not to mix "new" or "delete" in isolation with
    C-style (de)allocation. But since I agree with your recommendation to
    use new rather than calloc, no problem.

    Luke
     
    Luke Meyers, Dec 26, 2005
    #4
  5. Robben

    Regulus Guest

    Re: integer int i; *i++ and ++*i have a different integer value after the increment

    when you delete a pointer,

    delete i;
    i = null;

    it is a good habit, especially in very complex environment.
     
    Regulus, Dec 26, 2005
    #5
  6. Robben

    W Marsh Guest

    Re: integer int i; *i++ and ++*i have a different integer value afterthe increment

    Regulus wrote:
    > when you delete a pointer,
    >
    > delete i;
    > i = null;
    >
    > it is a good habit, especially in very complex environment.


    Is it? Not having dangling pointers* at all is a better habit, IMHO. Are
    you going to be checking that "i != NULL" each time you use it?

    * Okay, it's "NULL" rather than dangling, which would be fine if C++
    were a language where null has a special meaning rather than just being 0.
     
    W Marsh, Dec 26, 2005
    #6
  7. Re: integer int i; *i++ and ++*i have a different integer value after the increment

    W Marsh wrote:
    > Regulus wrote:
    > > when you delete a pointer,
    > >
    > > delete i;
    > > i = null;
    > >
    > > it is a good habit, especially in very complex environment.

    >
    > Is it? Not having dangling pointers* at all is a better habit, IMHO.


    Not having pointers at all is still better, but some things are
    inevitable.

    > Are
    > you going to be checking that "i != NULL" each time you use it?


    The point of setting a pointer to 0 is to prevent double deletion.

    > * Okay, it's "NULL" rather than dangling, which would be fine if C++
    > were a language where null has a special meaning rather than just being 0.


    Well a valid address cannot be 0 so yes, 0 has a special meaning for
    pointers in C++.


    Jonathan
     
    Jonathan Mcdougall, Dec 26, 2005
    #7
  8. Robben

    Jim Langston Guest

    Re: integer int i; *i++ and ++*i have a different integer value after the increment

    "W Marsh" <wayneDOTmarshATgmailDOTcom@decipher> wrote in message
    news:43af88ed$0$23288$...
    > Regulus wrote:
    >> when you delete a pointer,
    >>
    >> delete i;
    >> i = null;
    >>
    >> it is a good habit, especially in very complex environment.

    >
    > Is it? Not having dangling pointers* at all is a better habit, IMHO. Are
    > you going to be checking that "i != NULL" each time you use it?
    >
    > * Okay, it's "NULL" rather than dangling, which would be fine if C++ were
    > a language where null has a special meaning rather than just being 0.


    Actually, for pointers it is the one case it does have a special meaning.

    It is legal to delete a null pointer.

    int* i = new int;
    delete i;
    delete i; // ERROR

    int* i = new int;
    delete i;
    i = NULL;
    delete i; // NO ERROR
     
    Jim Langston, Dec 26, 2005
    #8
  9. Robben

    W Marsh Guest

    Re: integer int i; *i++ and ++*i have a different integer value afterthe increment

    Jim Langston wrote:
    > "W Marsh" <wayneDOTmarshATgmailDOTcom@decipher> wrote in message
    > news:43af88ed$0$23288$...
    >
    >>Regulus wrote:
    >>
    >>>when you delete a pointer,
    >>>
    >>>delete i;
    >>>i = null;
    >>>
    >>>it is a good habit, especially in very complex environment.

    >>
    >>Is it? Not having dangling pointers* at all is a better habit, IMHO. Are
    >>you going to be checking that "i != NULL" each time you use it?
    >>
    >>* Okay, it's "NULL" rather than dangling, which would be fine if C++ were
    >>a language where null has a special meaning rather than just being 0.

    >
    >
    > Actually, for pointers it is the one case it does have a special meaning.
    >
    > It is legal to delete a null pointer.


    Sure, but you could just as well say "it is legal to delete a pointer
    with the value 0". It's different to having a null pointer (or
    reference) in a language such as C#, where deferencing it would throw an
    exception rather than causing some nasty undefined behaviour.

    >
    > int* i = new int;
    > delete i;
    > delete i; // ERROR
    >
    > int* i = new int;
    > delete i;
    > i = NULL;
    > delete i; // NO ERROR


    It's just my personal philosophy to design around potential errors like
    this so that they don't have the chance to occur, rather than just
    making them harmless if they do. I'm sure there are plenty of
    programmers far more skilled than me who would disagree, though.
     
    W Marsh, Dec 26, 2005
    #9
  10. Robben

    Robben Guest

    Re: integer int i; *i++ and ++*i have a different integer value after the increment

    Luke Meyers wrote:
    > > Don't forget to delete the int:
    > >
    > > delete i;

    >
    > Remembering, of course, not to mix "new" or "delete" in isolation with
    > C-style (de)allocation. But since I agree with your recommendation to
    > use new rather than calloc, no problem.
    >
    > Luke



    Thank you Luke and Jonathan for your feedback.
     
    Robben, Dec 26, 2005
    #10
  11. Robben

    Robben Guest

    Re: integer int i; *i++ and ++*i have a different integer value after the increment

    Luke Meyers wrote:
    > > Don't forget to delete the int:
    > >
    > > delete i;

    >
    > Remembering, of course, not to mix "new" or "delete" in isolation with
    > C-style (de)allocation. But since I agree with your recommendation to
    > use new rather than calloc, no problem.
    >
    > Luke



    Thank you Luke and Jonathan and others who had given there valuable
    suggestions and feedback.
     
    Robben, Dec 26, 2005
    #11
  12. Robben

    Ron Natalie Guest

    Re: integer int i; *i++ and ++*i have a different integer value afterthe increment

    Jonathan Mcdougall wrote:
    > Robben wrote:
    >> Hi All,
    >>
    >> I have an integer pointer with value 10, but it returns a different
    >> return value after the preincrement and post increment.
    >>
    >> I will be very thankful if somebody can give an explanation for this
    >> behavior.
    >>
    >> Listed below is the program and output - executed in vc++6.
    >>
    >> int main(int argc, char* argv[])
    >> {
    >> int *i = (int*) calloc(sizeof(int),1);

    >
    > Don't:
    >
    > int* i = new int;

    new int() if he wants the same behavior as calloc (zero initialization).

    >
    >> *i = 10;
    >>
    >> cout << " *i++ " << *i++ << endl;

    >
    > This is *(i++) : increment the pointer, return the old address and
    > dereference it.


    No, it is return the address of the pointer before the increment and
    make sure it is incremented before the next sequence point. In fact,
    the above has undefined behavior. The increments could both be applied
    before the sequence point in an allowable ordering.

    Further, even without violating that rule, you don't know which
    of the *i++ subexpressions is evaluated first.
     
    Ron Natalie, Dec 26, 2005
    #12
  13. Re: integer int i; *i++ and ++*i have a different integer value after the increment

    Ron Natalie wrote:
    > Jonathan Mcdougall wrote:
    > > Robben wrote:
    > >> Hi All,
    > >>
    > >> I have an integer pointer with value 10, but it returns a different
    > >> return value after the preincrement and post increment.
    > >>
    > >> I will be very thankful if somebody can give an explanation for this
    > >> behavior.
    > >>
    > >> Listed below is the program and output - executed in vc++6.
    > >>
    > >> int main(int argc, char* argv[])
    > >> {
    > >> int *i = (int*) calloc(sizeof(int),1);

    > >
    > > Don't:
    > >
    > > int* i = new int;

    > new int() if he wants the same behavior as calloc (zero initialization).
    >
    > >
    > >> *i = 10;
    > >>
    > >> cout << " *i++ " << *i++ << endl;

    > >
    > > This is *(i++) : increment the pointer, return the old address and
    > > dereference it.

    >
    > No, it is return the address of the pointer before the increment and
    > make sure it is incremented before the next sequence point.
    > In fact, the above has undefined behavior.
    >
    > The increments could both be applied
    > before the sequence point in an allowable ordering.
    >
    > Further, even without violating that rule, you don't know which
    > of the *i++ subexpressions is evaluated first.


    I think you missed the double quotes around the first *i++.

    However, this is still undefined behavior because i now points to an
    invalid address, though, on most platforms, the first cout statement
    should work correctly because what is dereferenced is the old address.
    The second cout:

    > cout << " *i " << *i << endl;


    is more dangerous, but may still go unnoticed unfortunately.


    Jonathan
     
    Jonathan Mcdougall, Dec 26, 2005
    #13
  14. Robben

    Ron Natalie Guest

    Re: integer int i; *i++ and ++*i have a different integer value afterthe increment

    Jonathan Mcdougall wrote:

    > I think you missed the double quotes around the first *i++.
    >


    Oops you'rre right.


    > However, this is still undefined behavior because i now points to an
    > invalid address, though, on most platforms, the first cout statement
    > should work correctly because what is dereferenced is the old address.
    > The second cout:
    >
    >> cout << " *i " << *i << endl;



    >
    > is more dangerous, but may still go unnoticed unfortunately.
    >


    Incrementing is OK, the pointer is guaranteed to have a valid
    value one past the end. However, dereferencing the pointer
    is invalid as you note.
     
    Ron Natalie, Dec 26, 2005
    #14
  15. Robben

    Old Wolf Guest

    Re: integer int i; *i++ and ++*i have a different integer value after the increment

    Jonathan Mcdougall wrote:
    > Robben wrote:
    >> int *i = (int*) calloc(sizeof(int),1);

    > Don't:
    > int* i = new int;


    Even better:
    int j;
    int *i = &j;
     
    Old Wolf, Dec 27, 2005
    #15
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Schnoffos
    Replies:
    2
    Views:
    1,237
    Martien Verbruggen
    Jun 27, 2003
  2. Hal Styli
    Replies:
    14
    Views:
    1,686
    Old Wolf
    Jan 20, 2004
  3. Replies:
    104
    Views:
    11,087
    Jordan Abel
    Oct 28, 2005
  4. Replies:
    99
    Views:
    2,536
    eliza81
    Jun 11, 2010
  5. Alf P. Steinbach /Usenet
    Replies:
    0
    Views:
    919
    Alf P. Steinbach /Usenet
    May 22, 2011
Loading...

Share This Page