Difference between static methods and static variables?

Answer 1

StaticIn the C language family, a static variable is one that exists for the lifetime of a compilation unit (a source file or module).

A static variable can be declared module-wide, and thus be accessed by all functions defined within the same source file. Such a static variable cannot be directly accessed from other modules, but inner-module API can pass pointers to static variables and modify those through pointers.

A static variable can also be declared within a function body, where the usual scope rules apply. A static variable declared within a function is only initialized when the module is initialized (typically when the application loads), and preserves its values over multiple invocations of the function that contains the definition.

In C++, a static variable can also be a member of a class definition. Access to a static member variable is governed by the standard access modifiers (private, public, protected), but all instances of this class share the same static variable, and share the same value. Modifying the value of this variable affects all objects of the class.

Volatile

The volatile keyword is something all together different, and not in any way an opposite to static. A static variable may or may not be declared volatile, just as a global or local variable can be.

The volatile keyword is a hint informing the compiler that the variable's value might change without the compiler's knowledge. Therefore, the compiler's code optimizer cannot make assumptions about the variable's current value, and must always (re-) read the variable's content.

Volatile variables are sometimes used in context with interrupt handlers (although those normally benefit from more sophisticated synchronization methods such as semaphores, mutexes or locks). Most typically, volatile variables are used to model hardware registers through variables.

For example, consider a hardware register at address 0x1234, containing a single byte. The value of this byte is hardware driven and contains, for example, the current ambient light level in a range of 0..255. Such a register could be modeled with this construct:

unsigned char *const volatile lux = (unsigned char *)0x1234;

unsigned char firstReading = *lux;

unsigned char secondReading = *lux;

In this example, the volatile keyword ensures that the second reading is taken from the hardware register again. Without, a good compiler will read the memory address once and assign the same value to both variables.

Answer 2

They are entirely different things, there is no point to comparing them.

constant: it's value is not supposed to be changed.

volatile: it's value can be changed asynchronously (by an interrupt, for example).

Answer 3

A const data type is one which cannot be changed once initialized.

A volatile data type is one which should never have its value locally cached.

Note: Neither of them is data-type, they are modifiers.

Answer 4

Instance variables only apply to objects of a class (instances of the class). Every object has its own independent set of instance variables but there can only ever be one instance of a static variable. Static variables are instantiated and initialized at program load time and exist throughout the life-cycle of the program regardless of where they are declared. All global variables and constants are also implicitly static. Global variables need not be initialized at load time but they must be initialized at run-time before first use.

Since static variables exist at all times, they can maintain their value across scopes. A (non-static) variable declared inside a function is instantiated when the function is invoked and destroyed when the function falls from scope, whereas a static variable exists whether the function is in scope or not, but is only accessible while the function is in scope. This is useful when an otherwise global variable is only required by one specific function.

Static variables of a class (static members) are local to the class rather than local to objects of the class. As a member of its class, any object of the class may alter the value of a static member variable. There being only one instance of the variable, this provides a means of sharing a value amongst all objects of that class. When declared public, a static member variable is also accessible outside of the class even when no objects of that class exist. Public static member variables are often used in preference to global variables because they are localized to the class, but if the variable holds an invariant it is better to declare the variable private and provide public interface to encapsulate the invariant.

Static variables can also be explicitly declared in the global namespace (at file scope), but this is generally frowned upon unless the variable expresses the notion of a truly global concept. Localizing variables provides better encapsulation and maintainability, limiting accessibility to only the code that actually requires accessibility, whether at function scope, class scope or package scope.

Answer 5

The using of the volatile keyword.

example:

int n1;

volatile int n2;

Modifier volatile is a hint to the compiler to not register-optimize the variable, because its value can be changed asynchronously (i.e., in another thread or process). Example:

static volatile int interrupted= 0;

static void signal_handler (int signo)

{

interrupted= 1;

}

int main (void)

{

signal (SIGINT, signal_handler);

while (!interrupted) ...

}

it wouldn't work if the compiler assumed that the value of interrupted can be stored in a register (or simply assumed to be constant).

Answer 6

static variable also retains its value , at each post back,therby no need to use state management techniques if one is using static variables.

Answer 7

Yes.