static variable

[ghle]

Personal experience says your approach will not work. Inaccessible address, I think. Depends on compiler, I guess. Maybe exception error at run time... IIRC we are talking heap versus stack issues.

[ghle]

(Surprised) I tried it and it worked. There was no problem accessing the static variable by address outside the function. Be certain not to in-line the function, as that has certain ramifications. The static is created on the heap, and the address *is* accessible from outside the class and outside the function it is defined in. I am quite surprised. I thought even the compiler would catch it. Ignore previous post.:-O int *CPBDialog::TryThis() { static int test; test += 1; return &test; } CErrorOkDlg::CErrorOkDlg(CWnd* pParent /*=NULL*/) : CPBDialog(CErrorOkDlg::IDD, pParent) { //{{AFX_DATA_INIT(CErrorOkDlg) //}}AFX_DATA_INIT } BOOL CErrorOkDlg::OnInitDialog() { CPBDialog::OnInitDialog(); ModifyStyleEx(0,WS_EX_NODRAG,0); // Sound Beeper SoundWarning(); int *test = TryThis(); int test2 = *test; return FALSE; } Gary

[George_George]

Thanks toxcct, Your answer is clear. regards, George

[George_George]

Thanks koos, Your answer is great! regards, George

[George_George]

Thanks DavidCrow, Data segment is some global space of a process, compared with function local stack space? regards, George

[George_George]

Thanks for your help and sample, Gary! It is great! regards, George

[ghle]

George_George wrote:

I am wondering how C or C++ manages static variable internally.

Global statics are placed on the heap, not the stack. They are initialized upon first use by the application. They are destroyed upon exit from the application. Whereas variables on the stack come and go, the heap hangs around until program termination. I had thought Global statics were handled differently than Local statics, but I proved myself wrong. Beware of INLINE statics, however. If the code is actually INLINED, the compiler may create multiple instances of the static variable storage, plus one that is global. This will no doubt lead to problems. Gary

[George_George]

Thanks Gary,

ghle wrote:

I had thought Global statics were handled differently than Local statics, but I proved myself wrong.

You mean global static variable and function local variable are handled in the same way by compiler? regards, George

[ghle]

George_George wrote:

You mean global static variable and function local variable are handled in the same way by compiler?

George, both the global statics and local statics are placed onto the heap - by the compiler. I'd say they are handled similar, but not identical. For example, global statics are initialized at start-up of the program, but local statics are not initialized until they first come into scope. Both are destroyed only upon termination of the program, that is when the heap is destroyed. You said "function local variable", but I mean function local STATIC variable. A function local variable - non-static - are pushed onto the stack not put in the heap. When the function goes out of scope, so do it's variables. Returning from the function to the calling program will pop the stack, removing all local non-static variables from existence. But the function static variables were put on the heap, and they still exist after the function goes out of scope, available to the routine/method once it comes back into scope from another call. (And as noted earlier in this thread, I found local statics were available from outside of the local function if the address of the static is returned by the method.)

Heap
Global statics
Main() statics
Method B statics
Method C statics
/Heap

**Stack after calling Main()** _Main() non-static variables_ **/Stack** **Stack after calling method B from Main()** _Main() non-static variables Method B non-static variables_ **/Stack** **Stack after calling method C from B** _Main() non-static variables Method B non-static variables Method C non-static variables_ **/Stack** **Stack after calling method C from method C (recursion)** _Main() non-static variables Method B non-static variables Method C non-static variables Susequent method C non-static variables_ **/Stack** **Stack after returning from method C to method B** _Main() non-static variables Method B non-static variables_ **/Stack** **Stack after returning to Main() from method B** _Main() non-static variables_ **/Stack**

Heap after returning to Main(). All statics now initialized.
Global statics
Main() statics
Method B statics
Method C statics
/Heap

Gary -- modified at 8:43 Monday 27th August, 2007

[George_George]

Thanks Gary, Your reply is great! regards, George