|
Thanks
The second link you provided is different, It relate to Dynamic Data Exchange and Controls
|
|
|
|
|
Hi I am a bit puzzled over why this code works.
<br />
#include <iostream.h><br />
int* create( )<br />
{<br />
<br />
int marks = 5;<br />
int *pt=&marks;<br />
<br />
return pt;<br />
}<br />
<br />
int main( )<br />
{<br />
<br />
int *p;<br />
p=create();<br />
cout<<endl<<"The marks are : "<<*(p);<br />
return 0;<br />
<br />
} <br />
I would have thought that as you leave create(), marks goes out of scope therefore you destroy the object and *p would be pointing to an empty region of memory in main().
Thanks for any explanation.
|
|
|
|
|
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?
|
|
|
|