|
not really an "empty" region, but a region that could potentially be overwritten by something else...
|
|
|
|
|
But the area of memory which holds '5' should'nt exist anymore. Isnt that right? So the pointer points to null.
|
|
|
|
|
That's not correct.
Deleting something (or letting it go out of scope) doesn't erase the memory it was using, it just marks it as unused, so the memory manager is free to reuse that memory at any point.
Basically the same as happens when you delete a file from your HDD - undelete tools can recover it, because whilst the file entry is removed from the file table on the disk, the actual data is still there, until it gets overwritten by something else.
In the case of your example, nothing is happening between your creation of the pointer, and the access of the "deleted" memory, but in a bigger example it is less likely to survive intact.
|
|
|
|
|
Hi,
minkowski wrote: I would have thought that as you leave create(), marks goes out of scope
This is correct.
minkowski wrote: therefore you destroy the object
marks is just an integer, there is not much to destroy.
minkowski wrote: and *p would be pointing to an empty region of memory in main().
*p is still pointing to the same address in memory, that now is invalid but just by chance still contains some meaningfull data. If you do some additional tasks between the call to create() and the output operation, the data at the address may change.
Regards,
Tim
|
|
|
|
|
So its dangerous to do something like I did in that example as p may access a piece of memory that does not exist?
|
|
|
|
|
minkowski wrote: So its dangerous to do something like I did in that example
Yes it is. The behaviour is undefined.
minkowski wrote: as p may access a piece of memory that does not exist?
The memory do still exist. However, the content may have change.
Regards,
Tim
|
|
|
|
|
In addition to what already been said, I would present the safe way of doing it: declare the variables as static, like this:
<code>
int* create( )
{
static int marks = 5;
static int *pt=&marks;
return pt;
}
</code>
If you declare variables static, they will be stored in the heap instead of the stack.
Alcohol. The cause of, and the solution to, all of life's problems - Homer Simpson
|
|
|
|
|
That could be equally dangerous, if you ever plan on calling the create function multiple times
|
|
|
|
|
Correct me if I'm wrong, but as far as I remember, a static variable gets a fixed position on the heap.
If I'm right, what's the danger with calling the function more than once?
Alcohol. The cause of, and the solution to, all of life's problems - Homer Simpson
|
|
|
|
|
int *p;
int *q;
p=create();
q=create();
(*q)++;
cout<<endl<<"The marks are : "<<*(p);
return 0;
p and q will both point to the same location, so modifying one will modify the other, which might not be the expected behaviour
|
|
|
|
|
here is an example of where your code would not work :
::printf("%d %d", *(create()), *(create()));
|
|
|
|
|
Correct me if I'm wrong, but as far as I remember, a static variable gets a fixed position on the heap.
If I'm right, what's the danger with calling the function more than once?
-- modified at 7:59 Wednesday 25th October, 2006
Now I've checked your code. It returns 5 both times.
BTW, you mean
::printf("%d %d", *(create()), *(create()));
don't you?
Alcohol. The cause of, and the solution to, all of life's problems - Homer Simpson
|
|
|
|
|
kakan wrote: what's the danger with calling the function more than once?
if the functions does this for instance :
int* create() {
static int p = 0;
p++;
return &p;
}
with such printf(), all the calls will print the same value...
kakan wrote: BTW, you mean
::printf("%d %d", *(create()), *(create()));
yes ^^ Fixed, thanks
|
|
|
|
|
Nope, a static gets inititalized just once.
So with your printf, the result gets this:
2 1
Well. I don't want to be rude, but if you change a variable, then the variable in question obviously gets changed...
static or not.
Alcohol. The cause of, and the solution to, all of life's problems - Homer Simpson
|
|
|
|
|
no, do the test... the result will be 2 2
it is initialized once, but after that, the value it gets incremented is the same at final...
|
|
|
|
|
Funny, in my VC6, this code:
<br />
int* create( )<br />
{<br />
static int p = 0;<br />
p++; <br />
return &p;<br />
}<br />
<br />
main()<br />
{<br />
::printf("%d %d", *(create()), *(create()));<br />
}<br />
Produces the result:
2 1
If I set a breakpoint at "return &p", p contains 1 for the first call, and 2 for the second call.
Alcohol. The cause of, and the solution to, all of life's problems - Homer Simpson
|
|
|
|
|
humm, what about when the function returns p directly, instead of its address ?
i know i already encountered such a problem, but i don't remember the exact case...
|
|
|
|
|
Same result, this code:
<br />
int create2( )<br />
{<br />
static int p = 0;<br />
p++; <br />
return p;<br />
}<br />
<br />
::printf("%d %d", create2(), create2());<br />
produces the result:
2 1
Same as before. A breakpoint at "return p" gives the same result as before (of course).
Have you tried it yourself?
Alcohol. The cause of, and the solution to, all of life's problems - Homer Simpson
|
|
|
|
|
Hi kakan
isnt that what you would expect because the definition of a static variable is to create 1 and only 1 version of the variable?
|
|
|
|
|
Hello. That's exactly what I expect. But tox obviously doesn't. And it seems as it's my job to prove him wrong, instead of the opposite...
Alcohol. The cause of, and the solution to, all of life's problems - Homer Simpson
|
|
|
|
|
Sorry, may be I am getting confused.... Um, since at every funcion call to create2() you set p = 0 it should reset p everytime. But appears to not. Why is that?
Thanks for any information.
|
|
|
|
|
Sorry, may be I am getting confused In your definition of create2() you reset p, by p = 0. So in each call to create2() p should be set to 0 before being incremented. So wouldnt you therefore expect the same value printed everytime?
|
|
|
|
|
Sorry, may be I am getting confused In your example above of create() you reset p, by p = 0. So in each call to create() p should be set to 0 before being incremented. So wouldnt you therefore expect the same value printed everytime?
|
|
|
|
|
Actually I just answered my own question
The static int p = 0 only gets called once at instantiation which makes sense coz otherwise you will have loads of p's around which goes against the idea of it being static (only 1 copy of the variable exists).
Well I hope that is correct.
|
|
|
|
|
Sorry for the delay. It's due to the fact I went home from work yesterday.
That's right, a static variable just gets initialized once.
Besides, there are just one copy of it, in the heap.
The fact that it is stored in the heap (as opposite to the stack), makes it protected from alterations.
So if you want to make sure (as in this case) that a value, returned from a function will contain the same value, static is the way to go.
This goes for plain C. For C++, a class member variable does the same.
Kakan
Alcohol. The cause of, and the solution to, all of life's problems - Homer Simpson
|
|
|
|