Static variables in C++ exist for the lifetime of the entire program rather than individual function calls. They can be declared at global, file, class, or function scope. Globally scoped static variables are initialized when the program starts and exist until it ends, while static variables within functions are initialized on first use and persist between function calls. Static class members belong to the class itself rather than individual objects and can be accessed without an instance.

1. StaticKeyword
1
Static keyword
We have been using static keyword in our examples. What is the meaning of
static? The word refers to something that is stationary, stopped and not moveable.
What are the types of these variables, declared as static?
How can we make use of them? Static as the word implies are variables which
exist for a certain amount of time, much longer than that by ordinary automatic
variables. Let’s consider the example about the lifetime of data variables.
One of the variable types is global variable. Global variables are those that are
defined outside of main. They are written as standalone statements before main
function
int i; the variable ‘I’ is a global variable. It is not only accessible in main but also
in all the functions. They can assign some value to ‘I’ or obtain the value of ‘I’.
Global variables come into existence whenever we execute the program and the
memory is allocated for ‘I’. It exists all the time when the program is running. At
the end of the program execution, the memory will be de-allocated and returned to
the operating system. So it has a very long lifetime. We need a value which exists
for the complete execution of the program and is available in all the functions. We
use global variables. It is not a good idea to do that unless it is absolutely
necessary. The major plus point of these variables is that these are accessible from
everywhere in the program. The inconvenience is that these variables are visible in
those functions too which does not need them
The Many Meanings of the C++ “Static” Keyword
In C++, the static keyword has a lot of meanings. Let’s go over all of them
Meaning 1: Private Linkage
This one comes from C, and it lets you mark a variable as “file private”.

2. StaticKeyword
2
Example:
static int i = 42;
void doSomething()
{
cout << i;
}
In this example, static tells the compiler to not make the variable i available from
other sourcefiles. If another file tries to use i, perhaps using the extern keyword, it
would generate a linker error (unresolved external symbol). The same concept
applies to functions whose access you want to limit to the current file.
Uses:
This is very handy for creating “file private” variables and functions. I recommend
using static for any file-only functions. This way, you can name them whatever
you like without risking a naming collision in the global namespace.
Gotchas:
Unfortunately, you can’t declare a class as static. Also, the language makes no
guarantee about the order in which static variables are initialized. In my
experience, static variables in the same file are initialized in a “sane” order, so you
can do things like this
static int i = 42;
static int j = i + 1;
Meaning 2: Function Call Spanning
This one also comes from C, and it lets you give a function-local variable a long
lifespan.
Example:
void foo()

3. StaticKeyword
3
{
static int callCount = 0;
callCount++;
cout << "foo has been called " << callCount << " times" << endl;
}
Uses:
it’s a great way to keep track of how many times a function has been called, so it
works well for generating unique ID numbers (watch out for thread-safety!). It’s
also useful to keep track of whether a function is being called for the first time
ever, like this:
void foo()
{
static boolfirstTime = true;
if(firstTime)
{
// Do something special here
firstTime = false;
}
}
Gotchas:
Static function-local variables are initialized the first time the function is called,
not before. Using these kinds of variables can often make your codenot thread safe
and not re-entrant, so take care before using them. You can put static variables
within scopeblocks (like inside an if or for statement). I’m not totally sure what

4. StaticKeyword
4
the implications are, and frankly I’ve never felt the need to limit the scopeof a
variable so aggressively.
Meaning 3: Per-Class Data
When you declare a class member as static, it now belongs to the class at large, and
not a particular instance.
Example:
// In the .h file:
class MyClass
{
public:
static int FavoriteNumber;
static void foo();
};
// In the .cpp file (to initialize the static variable):
int MyClass::FavoriteNumber = 42;
void MyClass::foo()
{
// can't access member variables here!
}
Uses:

5. StaticKeyword
5
It’s very common to store class-level constants this way. You can declare class
functions as static as well, so they would be callable from anyone who has access
to your class, even if they don’thave an instance. This is handy for helper
functions. I generally like to make class functions static if they don’tneed to
operate on any instance data, typically for private helper functions.
Gotchas:
Static members are initialized very early in your program’s execution, before
main() is even called actually. You also have no guarantee about the order in
which they are initialized between classes in different files. Be careful not to
initialize one static class variable from another (possibly not-yet-initialized) static
class variable. Also, you can’t access instance data from this within a static class
function (unless someone passes you a this pointer). Lastly, you have to initialize
your static class variables in your implementation (.cpp)file. Otherwise, the
compiler doesn’tknow how to allocate them (see the example above).
What is the difference between a static class and a static
member variable or method?
Let's start with the memory first. Whenever a process is loaded in the RAM, we
can say that the memory is roughly divided into three areas (within that process):
Stack, Heap, and Static (which, in .NET, is actually a special area inside Heap
only known as High FrequencyHeap).
The static part holds the “static” member variables and methods. What exactly is
static? Those methods and variables which don'tneed an instance of a class to be
created are defined as being static. In C# (and Java too), we use the static keyword
to label such members as static. For e.g.
class MyClass
{
public static int a;
public static void DoSomething();
}

6. StaticKeyword
6
These member variables and methods can be called without creating an instance of
the enclosing class. E.g., we can call the static method DoSomething( ) as:
MyClass.DoSomething();
We don't need to create an instance to use this static method.
Static class declarations
The static keyword in C++ is used to specify that variables will be in
memory till the time the program ends; and initialized only once. Just
like C# and Java, these variables don’t need an object to be declared to
use them.
Summary
Static methods in the C# language differ from instance methods in
both the method declarations and in the method call sites. Static
methods apply to a type, not an instance of the type they are
defined on