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

[Robben]

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(i nt),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

[Luke Meyers]

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

[Jonathan Mcdougall]

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(i nt),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

[Luke Meyers]

> 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

[Regulus]

when you delete a pointer,

delete i;
i = null;

it is a good habit, especially in very complex environment.

[W Marsh]

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.

[Jonathan Mcdougall]

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

[Jim Langston]

"W Marsh" <wayneDOTmarshA TgmailDOTcom@de cipher> wrote in message
news:43******** *************** @news.zen.co.uk ...

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

[W Marsh]

Jim Langston wrote:

"W Marsh" <wayneDOTmarshA TgmailDOTcom@de cipher> wrote in message
news:43******** *************** @news.zen.co.uk ...

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.

[Robben]

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.