Why doesn't this work? (pointers)

[Chris Schumacher]

I wrote the following program to demonstrate an oddity I found in C++.

#include <iostream>
using namespace std;
int main()
{int *p, *q;
p = q;
q = new int;
*q = 12;
cout << *p;
system("pause") ;
return 0;
}
Your compiler will either give a gibberish answer or crash when you try
to run this program.
Here's what I don't understand: p and q are pointing to the same memory
address. That being said, why can't you access the dynamic variable using
p as well as q?
What would happen if you created a new variable using p too? Aren't they
both pointing to the same memory? Would they overwrite each other?

Thanks.

-==Kensu==-
I actually came across this while working with a homemade linked list.
You can imagine how frustrating THAT was...

[Ben Caradoc-Davies]

On Sun, 10 Oct 2004 22:22:00 GMT, Chris Schumacher <ke*****@hotmai l.com> wrote:

q = new int;

Here new allocates space for an int, and returns the location of the new
object, so this assignment overwrites any previous value of q. And besides, you
never initialised the old q, so it was full of garbage even before this line.

You must find a place to store an int (using new or a variable), then set both
p and q to point to it. Use

p = q;

after the "new" line to do this.

Turn on warnings in your compiler and it will likely detect the use of
uninitialised variables.

--
Ben Caradoc-Davies <be*@wintersun. org>
http://wintersun.org/

[Ioannis Vranos]

Chris Schumacher wrote:

I wrote the following program to demonstrate an oddity I found in C++.

#include <iostream>
using namespace std;
int main()
{int *p, *q;
Here p and q are initialised and thus point to "random" areas in memory.

p = q;
Here the "random" memory address stored in q is assigned to p.
q = new int;

Here an int is created in the free store and its address is assigned to
q pointer variable.
*q = 12;

Here the address stored in q is dereferenced, and the int pointed is
assigned the value 12.
cout << *p;

Here you dereference the "random" memory value assigned to p in the
beginning, and you read some "random" memory portion of the program,
invoking undefined behaviour.

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Karthik Kumar]

Chris Schumacher wrote:

I wrote the following program to demonstrate an oddity I found in C++.

#include <iostream>
using namespace std;
int main()
{int *p, *q;
1. Both the pointer variables are not initialized.
p = q;
2. You are assigning one of them to the other.
q = new int;
3. You are allotting a chunk of memory and q stores the pointer to that
location.

*q = 12;
4. You are storing a particular value in the memory pointed to , by q.

cout << *p;

5. (3) and (4) still do not affect p anyway. p is still
uninitialized and dereferencing it results in UB.

As Ben had already pointed out, you can do
the assignemnt 'p = q' after allocating memory for q.
Otherwise it does not help anyway.

--
Karthik. http://akktech.blogspot.com .
' Remove _nospamplz from my email to mail me. '

[Ioannis Vranos]

Correction:
Ioannis Vranos wrote:

Here p and q are

uninitialised

and thus point to "random" areas in memory.

[Chris Schumacher]

Ben Caradoc-Davies <be*@wintersun. org> wrote in
news:sl******** ********@localh ost.localdomain :

On Sun, 10 Oct 2004 22:22:00 GMT, Chris Schumacher
<ke*****@hotmai l.com> wrote:

q = new int;

Here new allocates space for an int, and returns the location of the
new object, so this assignment overwrites any previous value of q. And
besides, you never initialised the old q, so it was full of garbage
even before this line.

Ah, I see now. Thanks.
Both of the textbooks I used seemed to gloss over the fact that pointers
are not initalized during declaration. They made it seem that the new int
or whatever is placed in the memory location that the variable is pointing
at when declared.

Thanks again, to everyone who replied.
-==Kensu==-

[Mike Wahler]

"Chris Schumacher" <ke*****@hotmai l.com> wrote in message
news:Xn******** *************** ******@207.115. 63.158...

I wrote the following program to demonstrate an oddity I found in C++.
The 'oddity' is in your code, not the language
#include <iostream>
using namespace std;
int main()
{int *p, *q;
There now exist two pointers, named 'p' and 'q'.
Neither has a defined, valid value. Any attempt
to evaluate the value of either will produce
'undefined behavior' (which means anything can
happen, from 'appearing to work' to a crash,
or anything else.
p = q;
Kaboom. Evalution of unintialized object.
q = new int;
Allocates storage sufficient to store a single type
'int' object, and stores the address of this storage
in the pointer 'q'.
*q = 12;
Assigns the value 12 to the allocated type 'int' object.
cout << *p;
Kaboom again. Evalution of an ininitialized object.


system("pause") ;
return 0;
}
Your compiler will either give a gibberish answer or crash when you try
to run this program.
According to the definition of the language, it can do absolutely
anything (or nothing) at all.
Here's what I don't understand: p and q are pointing to the same memory
address.
They are not. 'p' doesn't point anywhere. 'q' points to an
allocated type 'int' object.
That being said,
Saying it doesn't make it so. :-)
why can't you access the dynamic variable using
p as well as q?
Because 'p' does not point anywhere. (It might 'by accident',
but officially its value is undefined.)

What would happen if you created a new variable using p too?
You can allocate another 'int' and assign its addres to 'p'.
If you did, then 'p' would have the same behavior as 'q' (except
that it would point to a different object.).
Aren't they
both pointing to the same memory?
No. Nothing in your code has assigned the address of the
allocated 'int' to 'p'.
Would they overwrite each other?
Only if you write code to do so.
I actually came across this while working with a homemade linked list.
You can imagine how frustrating THAT was...

Yes, I imagine expecting behavior based upon a false assumption
would be frustrating. :-)

-Mike

[Mike Wahler]

"Chris Schumacher" <ke*****@hotmai l.com> wrote in message
news:Xn******** *************** ******@207.115. 63.158...

Ben Caradoc-Davies <be*@wintersun. org> wrote in
news:sl******** ********@localh ost.localdomain :

On Sun, 10 Oct 2004 22:22:00 GMT, Chris Schumacher
<ke*****@hotmai l.com> wrote:

q = new int;
Here new allocates space for an int, and returns the location of the
new object, so this assignment overwrites any previous value of q. And
besides, you never initialised the old q, so it was full of garbage
even before this line.

Ah, I see now. Thanks.
Both of the textbooks I used seemed to gloss over the fact that pointers
are not initalized during declaration.

That is not a 'fact'. The fact is that objects of automatic
storage duration are not automatically initialized. Their
type doesn't matter. Objects with static storage duration
are automatically initialized (to 0).
They made it seem that the new int
or whatever is placed in the memory location that the variable is pointing
at when declared.

A definition of a pointer *never* will cause it to point
anywhere unless you supply an initializer. This is the
case for a pointer of any storage duration.

Which textbooks are you referring to?

-Mike

[Mike Wahler]

"Ioannis Vranos" <iv*@guesswh.at .grad.com> wrote in message
news:1097448661 .181043@athnrd0 2...

Chris Schumacher wrote:

I wrote the following program to demonstrate an oddity I found in C++.

#include <iostream>
using namespace std;
int main()
{int *p, *q;
Here p and q are initialised

Uninitialised. (But I'm sure that's what you meant).

and thus point to "random" areas in memory.
They might, they might not. Their values are undefined.

p = q;

Here the "random" memory address stored in q is assigned to p.

1) (The randome 'value' of 'q' might or might not correspond to
valid memory addresses.

2) Because of 1), no assignment at all is required to take place.

q = new int;

Here an int is created in the free store and its address is assigned to
q pointer variable.

*q = 12;

Here the address stored in q is dereferenced, and the int pointed is
assigned the value 12.

cout << *p;

Here you dereference the "random" memory value

First, this causes the value of 'p' to be evaluted, producing
undefined behavior. A dereference might or might not happen.
And if such a dereference did somehow succeed, another evaluation
of an ininitialized object would happen, resulting again in
undefined behavior.
assigned to p in the
beginning, and you read some "random" memory portion of the program,
invoking undefined behaviour.

The entire program's behavior becomes undefined as soon
as the expression p=q is evaluated.

-Mike

[Mike Wahler]

"Mike Wahler" <mk******@mkwah ler.net> wrote in message
news:60******** *********@newsr ead1.news.pas.e arthlink.net...

"Ioannis Vranos" <iv*@guesswh.at .grad.com> wrote in message
news:1097448661 .181043@athnrd0 2...

Chris Schumacher wrote:

I wrote the following program to demonstrate an oddity I found in C++.

#include <iostream>
using namespace std;
int main()
{int *p, *q; p = q;

The entire program's behavior becomes undefined as soon
as the expression p=q is evaluated.

Make that "as soon as the expression 'q' is evaluated the first time"

-Mike