C / C++ / MFC

George_George23-Aug-07 20:19

23-Aug-07 20:19

Thanks Josh,

Josh Gray wrote:
I'd rather provide a method to allow other code to modify the static.

I agree with most points of you. But I do not quite understand your above points. Could you show me a sample please about how to modify the static variable please?

I am wondering how to modify the value of the static variable from other function (other than from the function in which it is defined)?

regards,
George

User 58385223-Aug-07 20:29

User 583852

23-Aug-07 20:29

George_George wrote:
I am wondering how to modify the value of the static variable from other function (other than from the function in which it is defined)?

Sorry, my mistake as you cant do that.

You can however define a static in a class and access it from any of the methods in that class. Even const methods!

George_George23-Aug-07 20:31

23-Aug-07 20:31

Hi Josh,

I think you mean static member of a class. But I mean a static variable defined inside a function.

regards,
George

User 58385223-Aug-07 20:36

User 583852

23-Aug-07 20:36

George_George wrote:
I think you mean static member of a class. But I mean a static variable defined inside a function.

Yes you are right which makes me wonder why you have global methods? I suspect there is probably a better to solution to what you are trying to do but its hard to suggest anything without knowing more about what you are doing and in what context

George_George23-Aug-07 20:51

23-Aug-07 20:51

Thanks Josh,

You are right. I am writing a part of the application in C (not C++). I am wondering and willing to listen to your comments and ideas of any disadvantages if I return the address of static variable defined in a function, then let other part of code to access the variable by the returned address.

regards,
George

User 58385223-Aug-07 20:55

User 583852

23-Aug-07 20:55

George_George wrote:
You are right. I am writing a part of the application in C (not C++). I am wondering and willing to listen to your comments and ideas of any disadvantages if I return the address of static variable defined in a function, then let other part of code to access the variable by the returned address.

Well you could make the static global rather than defining it within a function then have two function to get and set its value but thats just an attempt to make a procedural language more OO.

George_George23-Aug-07 22:27

23-Aug-07 22:27

Thanks Josh,

I can understand and agree that your approach works. But when we come back to my approach, returning address of function *local* static variable, are there any disadvantages?

regards,
George

ghle24-Aug-07 15:28

24-Aug-07 15:28

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.

ghle25-Aug-07 4:04

25-Aug-07 4:04

(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. Blush | :O

<br />
int *CPBDialog::TryThis()<br />
{<br />
 static int test;<br />
<br />
	test += 1;<br />
	return &test;<br />
}<br />
<br />
<br />
CErrorOkDlg::CErrorOkDlg(CWnd* pParent /*=NULL*/)<br />
	: CPBDialog(CErrorOkDlg::IDD, pParent)<br />
{<br />
	//{{AFX_DATA_INIT(CErrorOkDlg)<br />
	//}}AFX_DATA_INIT<br />
}<br />
<br />
<br />
BOOL CErrorOkDlg::OnInitDialog() <br />
{<br />
	CPBDialog::OnInitDialog();<br />
<br />
	ModifyStyleEx(0,WS_EX_NODRAG,0);<br />
<br />
	// Sound Beeper<br />
	SoundWarning();<br />
	int *test = TryThis();<br />
	int test2 = *test;<br />
<br />
	return FALSE;<br />
}<br />
<br />
<br />

Gary

George_George25-Aug-07 22:08

25-Aug-07 22:08

Thanks for your help and sample, Gary!

It is great!

regards,
George

BadKarma23-Aug-07 22:10

BadKarma

23-Aug-07 22:10

This is a very interresting article about the use and the concept of the static keyword
clickety[^]

codito ergo sum

George_George23-Aug-07 22:36

23-Aug-07 22:36

Thanks BadKarma,

If I mean local static function variable, and if I use the address of the variable as the return value, then access the address outside the function (read/write). Does this approach have any disadvantages?

regards,
George

BadKarma23-Aug-07 23:24

BadKarma

23-Aug-07 23:24

Whether this is a bad design or a good one, depends on the place where you use this. So you should think carefully where to implement.

There is however on big disadvantage to this design. The function isn't thread safe.
This means that when called from multiple threads the behavior will be unpredictable.

codito ergo sum

George_George23-Aug-07 23:39

23-Aug-07 23:39

Thanks BadKarma,

BadKarma wrote:
This means that when called from multiple threads the behavior will be unpredictable

Could you provide more detailed scenario to describe why it is not thread safe please?

regards,
George

toxcct24-Aug-07 1:42

toxcct

24-Aug-07 1:42

do you know what thread safe means ?
can't you search the web before asking dumb questions like you know doing very well, and weighting the forum for nothing ?

returning the address of a local static variable isn't thread safe simply means that if a thread is calling the function (so, potentially being modifying the variable value), but another thread is modifying the variable at the same time, using the direct access through its address, you cannot ensure of the final value of the variable...
when both threads write at the same place at the same time, the one which wrote the memory at last wins the game...

ps: so i see you keep playing with the voting system... be very careful when voting my posts. they can just explode on you face, but then don't ever wonder why :p

[VisualCalc][Binary Guide][CommDialogs] | [Forums Guidelines]

George_George25-Aug-07 21:25

25-Aug-07 21:25

Thanks toxcct,

Your answer is clear.

regards,
George

codeII24-Aug-07 1:49

codeII

24-Aug-07 1:49

int& MyFunction( )
{
static int localStatic = 0;
int nMyArray[ 10 ];
if ( localStatic < 10 )
{
//localStatic is not guaranteed < 10
nMyArray[ localStatic ] = 1;
}
return localStatic;
}

When one tread comes inside the “if statement” another tread could have set localStatic to for instance 11.

If you want to use a variable outside the scope of the function why are you not using a global?
When using a static in a function this “means” that the function is responsible for this variable. And it cannot, when this variable is managed outside this function. Keeping strict rules provides confusing situations, In terms of who is modifying what.

Another thing you should know is that when you are using a static within a class function, different instances of this class would use the same static instance; this can cause problems like the tread example above.

Using globals:
In header:
extern int g_MyVar;

In cpp
int g_MyVar = 0;

or when possible using a local variable giving to the function
void MyFunction( int& nValue )
{
nValue++;
…
}

int nValue = 0;
MyFunction( nValue );

George_George25-Aug-07 21:27

25-Aug-07 21:27

Thanks koos,

Your answer is great!

regards,
George

David Crow24-Aug-07 6:05

David Crow

24-Aug-07 6:05

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

I believe it's in the data segment.

"A good athlete is the result of a good and worthy opponent." - David Crow

"To have a respect for ourselves guides our morals; to have deference for others governs our manners." - Laurence Sterne

George_George25-Aug-07 21:29

25-Aug-07 21:29

Thanks DavidCrow,

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

regards,
George

ghle26-Aug-07 3:42

26-Aug-07 3:42

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_George26-Aug-07 6:42

Re: static variable [modified]

26-Aug-07 6:42

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

ghle26-Aug-07 10:00

26-Aug-07 10:00

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

<br />
Stack after calling Main()<br />
Main() non-static variables<br />
/Stack<br />
<br />
Stack after calling method B from Main()<br />
Main() non-static variables<br />
Method B non-static variables<br />
/Stack<br />
<br />
Stack after calling method C from B<br />
Main() non-static variables<br />
Method B non-static variables<br />
Method C non-static variables<br />
/Stack<br />
<br />
Stack after calling method C from method C (recursion)<br />
Main() non-static variables<br />
Method B non-static variables<br />
Method C non-static variables<br />
Susequent method C non-static variables<br />
/Stack<br />
<br />
Stack after returning from method C to method B<br />
Main() non-static variables<br />
Method B non-static variables<br />
/Stack<br />
<br />
Stack after returning to Main() from method B<br />
Main() non-static variables<br />
/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_George26-Aug-07 19:22