Static & Global

[DatMCEyeBall]

DatMCEyeBall,

Do you actually run these code snippets before posting them and confusing the hell out of everyone?

Nope, I'm using my phone.

[czardas]

I believe 'Static' just implies the variable exists for the duration of the script. Because you can't go up one level from global scope, static global variables do not retain their original assigned value in the same way that static local variables do when you exit a function.

Edited December 31, 2013 by czardas

[guinness]

Nope, I'm using my phone.

Seriously? Next time add a warning you haven't tested and also don't imply it's the version of AutoIt we're using, because that's also insinuating you have tested as well.

[Melba23]

DatMCEyeBall,

 

Nope, I'm using my phone

Then please do us all a favour and do not post untested code snippets again when there is a serious discussion ongoing - particularly when it is a subject about which you evidently have absolutely no understanding at all.

M23

[BrewManNH]

Static variables are to be used only in a function, what they're for is so that if you declare a variable as a static variable in a function when you leave that function the variable retains its value. Global statics make absolutely no sense, because globals always retain their values no matter where you are in the script. Static variables are not constants, they're just local variables that don't lose their contents when the function ends. Any other use is a misuse of the variable typing.

 

The second example in the help file demonstrates it well. Here's a modified version that also demonstrates how a Global isn't changed by the Local Static variable. BUT take note, the variable referenced right after the Func line, and before the Local declaration line is the GLOBAL variable of the same name.

 

#include <MsgBoxConstants.au3>
Global $vVariableThatIsStatic = 0

Example()

Func Example()
    SomeFunc() ; This will display a message box of 1, 1.
    SomeFunc() ; This will display a message box of 1, 2.
    SomeFunc() ; This will display a message box of 1, 3.
EndFunc   ;==>Example

Func SomeFunc()
    ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : THIS IS THE GLOBAL VARIABLE $vVariableThatIsStatic = ' & $vVariableThatIsStatic & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
    ; This initialises a Static variable in Local scope. When a variable is declared just in Local scope (within a Function,)
    ; it's destroyed when the Function ends/returns. This isn't the case for a Static variable. The variable can't be
    ; accessed from anywhere else in the script apart from the Function it was declared in.
    Local Static $vVariableThatIsStatic = 1
    ConsoleWrite('@@ Debug(' & @ScriptLineNumber & ') : $vVariableThatIsStatic = ' & $vVariableThatIsStatic & @CRLF & '>Error code: ' & @error & @CRLF) ;### Debug Console
    Local $vVariableThatIsLocal = 0
    $vVariableThatIsLocal += 1 ; This will always be 1 as it was destroyed once returned from SomeFunc.
    $vVariableThatIsStatic += 1 ; This will increase by 1.
    MsgBox($MB_SYSTEMMODAL, $vVariableThatIsLocal, $vVariableThatIsStatic)
EndFunc   ;==>SomeFunc

[James]

Hang on a second...

Shouldn't static be used in a function where you want the next return value of it to be the same as the last, after it's changed? Global Static just means "Yo, create me a value that's going to be the same, but is still mutable and is available in every scope.". It's not like Java where Static means constant. If you're after that, use a constant. When I write constants, I write them in upper-snake-case. YO_IM_A_CONSTANT.

Edited December 31, 2013 by James

[DXRW4E]

Static variables are to be used only in a function, what they're for is so that if you declare a variable as a static variable in a function when you leave that function the variable retains its value. Global statics make absolutely no sense

.I know that my English is not ok, but I think you understand this

yes is right, for the moment only this

Global $sGlobal = "Global text"
Global Static $sStatic = "Global Static text"

Global $sGlobal = "new text" ; $sGlobal's value will be changed to "new text"
Global $sStatic = "new text2" ; No change
MsgBox(0,0,$sStatic)

;~ >Running:(3.3.10.2):C:\Program Files (x86)\AutoIt3\autoit3.exe "C:\Users\DXRW4E\Desktop\New AutoIt v3 Script (2).au3"    
;~ --> Press Ctrl+Alt+F5 to Restart or Ctrl+Break to Stop
;~ "C:\Users\DXRW4E\Desktop\New AutoIt v3 Script (2).au3" (5) : ==> Cannot make static variables into regular variables.:
;~ Global $sStatic = "new text2"
;~ Global ^ ERROR
;~ ->11:10:36 AutoIt3.exe ended.rc:1
;~ >Exit code: 1    Time: 0.423

but may do so, in order to work as they should, can not I speak with competence regarding C because I do not know much about C, but in C sees them Global Static seeuse only the files where they are being declared, in autoit this can be done with Au3Check and some (Optional) directive or something like that, where indicate the names of the functions that seeuseeditchange that variable

 

Ciao.

 

C++ Complete Reference - Herbert Schildt (4rd Edition)

static Global Variables

Applying the specifier static to a global variable instructs the compiler to create a

global variable that is known only to the file in which you declared it. This means

that even though the variable is global, routines in other files may have no knowledge

of it or alter its contents directly, keeping it free from side effects. For the few situations

where a local static variable cannot do the job, you can create a small file that contains

only the functions that need the global static variable, separately compile that file, and

use it without fear of side effects.

To illustrate a global static variable, the series generator example from the previous

section is recoded so that a seed value initializes the series through a call to a second

function called series_start( ). The entire file containing series( ), series_start( ), and

series_num is shown here:

/* This must all be in one file - preferably by itself. */

static int series_num;

void series_start(int seed);

int series(void);

int series(void)

{

series_num = series_num+23;

return series_num;

}

/* initialize series_num */

void series_start(int seed)

{

series_num = seed;

}

so has much sense OK

 

concrete example see my INI File Processing Functions '?do=embed' frameborder='0' data-embedContent>> I have a handle them

;;;; DO NOT EVER USE\CHANGE\EDIT THESE VARIABLES ;;;;
;;;;  THESE VARIABLES ARE USED INTERNALLY ONLY   ;;;;
Global Static $INI_NULL_REF = Null
Global Static $_HINI[11][11] = [[10, 0]]
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 

I do not want users to accidentally change the $_HINI OK

 

There are lots and lots of other scenarios that require or need to use a Global Static, or better to say when a Global Static solves many situations, and since autoit does not support pointers, is very useful to have at least the Global Static

 

Ciao.

Edited December 31, 2013 by DXRW4E

[James]

Then you need to use the Const keyword.

[DatMCEyeBall]

Hang on a second...

Shouldn't static be used in a function where you want the next return value of it to be the same as the last, after it's changed? Global Static just means "Yo, create me a value that's going to be the same, but is still mutable and is available in every scope.". It's not like Java where Static means constant. If you're after that, use a constant. When I write constants, I write them in upper-snake-case. YO_IM_A_CONSTANT.

*YO_IMA_CONTSTANT_DAWG

[DXRW4E]

Then you need to use the Const keyword.

I think many still have not really understood the function Static, and the real Global Static, they are not Const???, we are completely out of context here

@All

I am not here to give lessons (would be nice, but I'm not so good), or just asked for help, because I need Global Static , and as I believe do not need a lot of work to enable it in Au3Check, or simply asked if it is possible to add, nothing else

Ciao.

Edited December 31, 2013 by DXRW4E

[James]

Global Const $SUP_DAWG = "I'm immutable! Come at me bro!"
Global Static $SUP_HOMEBOI = "U wat blud? I'll mutable you in a minute" ; P.s, he won't because Const can't be changed.

Edited December 31, 2013 by James

[BrewManNH]

I understood what you were saying, and I also understand that you're thinking about it incorrectly.

Static variables can not be Const.

As has been mentioned a couple of times already, you want a constant not a static.

Also from the help file.

 

If the scope specifier Global is used, then the static variable is visible and usable in all parts of the script; in this regard, a Global Static has very little difference from a Global variable.

Whether that last part means that there's no difference or if there is a notable difference I don't know, I can't seem to find any instances where making a Global static has any change from just making it a Global.

Also, when you declare an array as a constant, you have to assign every element on the declaration line, you can't change the values in any element later because you made it a constant.

[James]

Basically, Static in AutoIt performs a different function to that in C and Java.

[czardas]

You could add a line at the top of every function in the UDF to reassign the variable to equal a constant (using a second variable). This would be the equivalent of file scope.

Edit

Sorry, I misunderstood static, only having used it once without actually modifying the value. You would actually need to include a function with Static Local variables to call and overwrite their global counterparts. Same principle but more ugly.

Edited December 31, 2013 by czardas

[DXRW4E]

Basically, Static in AutoIt performs a different function to that in C and Java.

is the same for all, only that the AutoIt compiler is not that of the "C" and "java", and this is understandable is everything Ok but according to my suggestion, a certain thing you can do perfectly in AutoIt, need just that when Au3Check load a file, take all the names of the functions in that file, and then see if there are Gobal Static, and get to know them only in those functions that file, or add a directive, where to put the names of the functions where seeuseedit that Global Static, nothing else

 

Ciao.

Edited December 31, 2013 by DXRW4E

[jchd]

In AutoIt, static means the constructor is called only once and the destructor only called at program termination. From this point of view, global static and global are effectively identical.

What the OP seems to mean in his first post is that he would like to restrict the scope of global static to an enumerated set of functions by way of a directive.

I'd rather have file scope, halas that would mean a fundamental rework of the tools unlikely to happen anytime soon. Masquerading file scope à la czardas (posted above) is kind of horrible.

What could be a way to introduce file scope is instead to make that block scope, with e.g. BEGIN and END statements. Any local variable within would be visible only in its block. That would preserve the external tools strategy and "compiler" structure.

Edited December 31, 2013 by jchd

[DXRW4E]

You could add a line at the top of every function in the UDF to reassign the variable to equal a constant. This would be the equivalent of file scope.

I said here before

this is the point how to protect them in UDF, because in personal script does not need not have to do it does not make sense to do it

Ciao.

Edited December 31, 2013 by DXRW4E

[DXRW4E]

In AutoIt, static means the constructor is called only once and the destructor only called at program termination. From this point of view, global static and global are effectively identical.

so for the moment, so also help, but I think they can be done much better, with minor improvements or modifications

Ciao.

Edited December 31, 2013 by DXRW4E

[czardas]

Masquerading file scope à la czardas (posted above) is kind of horrible.

 

LOL. Yeah horrible patch. What I said was also incorrect - I just realized.

Edited December 31, 2013 by czardas

[jchd]

Of course in my hypothetical BLOCK ... ENDBLOCK structure (names more in the current style), vars local to a function would remain in function scope.