Static in C

Static is a keyword that is used in the C programming language. It can be used both as variables and as functions. In other words, it can be declared both as a static variable and a static function.

Static variables have the advantage of preserving their value even if they are out of scope. A regular variable's scope is confined to how it is defined, whereas a static variable's scope is unlimited. Static variables preserve their previous value in their earlier scope and are not initialized again in the new scope.

Syntax:

static dataTypevariableName = variableValue;

In English, the word static means "pertaining to or characterised by a permanent or immobile situation." Computer language, on the other hand, is used to represent things that do not change over time.A variable that is stored using static is assigned address during build time. It will therefore be safe to use a pointer to such a variable.

• During the building process, a variable that is saved using static is given an address. As a result, using a reference to a very variable will be safe.

E.g., While the application is compiling and executing, a static int variable remains in memory. When a function call where the variable is created ends, the regular variable is destroyed.

#include <stdio.h>
	int fun()
	{
		static int count = 0;
		count++;
		return count;
	}
	int main()
	{
		printf (“%d \n”, fun());
		printf (“ %d \n”, fun());
		return 0;
	}

Output:

1 2

• Static variables are assigned memory in the data segment, not the stack segment, and a static function's lifespan spans the whole programme.
• Inside a structure, static variables should not be defined. The reason for this is that the C compiler expects all of the structure components to be in the same place. That is, structure members' memory allocation should be contiguous. It will be allowed to specify structure within the function, as well as dynamically or globally allocate memory.All structure members should reside in the same memory because the value for the structure element is fetched by counting the offset of the element form the beginning address of a structure. Differentiating one member from the data segment negates the purpose of a centralized and decentralized, since a static variable can be applied to the whole structure.
• Static variables, such as global variables, are initialized as 0.

E.g., the value of X can be printed as 0. In comparison, the value of Y is something garbage.

#include <stdio.h>
	int main() 
	{
		static int x;
		int y;
		printf(“ %d \n”, x, y);
	}

• In the C programming language, static variables can be initialized using constant literals.
• A static local variable is a local variable that has been declared using the static keyword. When a function updates a static local variable, the changed value is available to all subsequent functions.Static functions and static global variables are possible in the C programming language.
• A function's static variable retains its value between invocations.
• A static method is a member function of a class that is defined using the static keyword. It may be accessible by all instances of a class; however, it cannot be limited to a single instance.
• A static global variable or a function is seen only in its file where it is declared at.

E.g.:

#include <stdio.h>
#include <conio.h>
void book()
{
int x = 10;
static int y = 10;


x += 5;
y += 5;


printf (“x = %d, y = %d \n”, x, y);
}
int main()
{
int i;
for (i = 0; i<10; ++i)
	book();
}

Output:

x = 15, y = 15
x = 15, y = 20
x = 15, y = 25
x = 15, y = 30
x = 15, y = 35
x = 15, y = 40
x = 15, y = 45
x = 15, y = 50

If a function has to retain some state among invocations and you don't want to employ global variables, static help is helpful. This should be used with caution, as it may make your code thread-safe while also making it more difficult to understand.

Static is also often used as a kind of access control. Developing various features in the C programming language exposes a few public functions to users; the rest of the functions should be made static so that the user cannot access them, which is known as encapsulation.

The use of static keywords has a variety of applications. Limiting the scope of variables declared within a function or module is the most effective use.

Static variables and static functions can be concealed from the outside world by using static keywords, which behaves similarly to the usage of private and public in more object-oriented languages.