Concept of " Static " in Programming

According to the standard C++, static refers to the storage duration of an object. The storage duration is therefore a property of an object, and it defines the lifetime the contents of the storage should have. In C++ there are four storage durations:
• static storage duration
• thread storage duration
• automatic storage duration
• dynamic storage duration

A storage duration is specified when an object is constructed. For example

static const int cte_LicId = 123455;

As such the storage of this object should last the entire time the program runs. In general, if a variable does not have dynamic storage duration, does not have thread storage duration, and is
not a local variable then it has a static storage duration. The storage for such an entity will last for the duration of the program (i.e. a global variable has static storage duration even if it not explicitly stated in his declaration)

In the above example, the static storage duration is associated with the object, cte_LicId, introduced by the declaration. As such the storage of this object should last the entire time of the program's run. In general, if a variable does not have dynamic storage duration, does not have thread storage duration, and is not a local variable then it has a static storage duration. The storage for such an entity shall last for the duration of the program (i.e. a global variable has static storage duration even if it not explicitly specified)


A local variable can be declared with static storage duration using the keyword static.

int foo(int i) {
static int s = rand(125);
return i+1;
}

Similarly for a class data member. Please refer to your C++ reference guide for more info.

There is no common concept in all the languages. The most similarity is with variables.
The table below covers C, C++ and C# in a maybe a bit simplistic way. What you see is the various uses of static.

Language	static file level variable	static function level variable	static file level function	static class	static member variable	static member function	static constructor
C	internal linkage, lives from the point of declaration until the end of the program	no linkage, lives from the point of declaration until the end of the program	internal linkage	n/a	n/a	n/a	n/a
C++	same as C	same as C	same as C	n/a	shared between all instances of the class	no instance function, has no hidden *this* parameter	n/a
C#	n/a	n/a	n/a	class with only static fields (member variables) and methods (member functions)	same as C++	same as C++	called before the first element of the class is accessed from outside

Cheers
Andi

See here[^]

Use the static modifier to declare a static member, which belongs to the type itself rather than to a specific object.



When a member of a class is static you can see it as a member that belongs to the "object template". A class can be seen as an object template, able to create many objects of a certain type all with the same properties (but different values for each property)

eg.

class MyObjectTemplate{
  public static string MystaticMember = "Static value, belonging to the class, not the instance of a class";
  public string MyUsualMember = "Normal value, belonging to the instance of the class";
 
}

class TestStatic{
   public static void Main(){
      MyObjectTemplate obj1 = new MyObjectTemplate();
      MyObjectTemplate obj2 = new MyObjectTemplate();
      obj2.MyUsualMember = "new value for obj1";  //now only obj2's member value is changed, ob1's value is still the same.
      //obj1.MystaticMember -> can't
      MyObjectTemplate.MystaticMember = "change this";  //now it is changed for everyone.
   }
}

Only use static when it makes absolute sense. Since you cannot call object members from static members (unless you create one in the static method eg) you end up in creating everything static before you know it and that goes against Object Oriented principles.

try to find some examples and make some yourself. Correct usage can help you a lot, incorrect usage can drown your application into a useless pile of rubbish.

Hope this helps.

a static variable is a variable that has been allocated statically—whose lifetime or "extent" extends across the entire run of the program. This is in contrast to the more ephemeral automatic variables (local variables are generally automatic), whose storage is allocated and deallocated on the call stack; and in contrast to objects whose storage is dynamically allocated in heap memory.

When a program (executable or library) is loaded into memory, static variables are stored in the data segment of the program's address space (if initialized), or the BSS segment (if uninitialized), and are stored in corresponding sections of object files prior to loading.

static means: direct access, always available, always accessible and changeable anywhere while the app is still alive (running).

and you can't really learn it in theory.
go ahead and do some real code on static.

Code once, then you'll know it better than text explained here.