static functions usage, importance

static = not(dynamic)<br />
not(dynamic) = no instance specific<br />
no instance specific = class specific<br />
<br />
therefore, static = shared (run-time sharing of variables/objects between instances of a particular class.)

And for access those static variables/objects We require Static methods/Functions...

static variables/objects are class specific not instance-specific...
so that,
static variables & methods can directly call using classname.

real time example
you want to count how many objects created of particular class
then declare static variable and increment-decrements value when you are create new instance of that class & dispose that instance

Happy Coding!
:)

Static function does not need an instance to call this method. In programming we normally use static method when we need same operation has to be called in different classes, different modules.

eg: Conrol validation has to be performed in diffrent UI class.

inorder write the same logic again and again you can define a static method

class Validator
{
  static bool Validate(TextBox text)
  {
    bool success = false;

    if(!string.IsNullOrEmpty(text.Text))
    {
      success = false;
    }
   return success;
  }
}

so you can call this method as 
Validator.Validate(myTextBox);
Validator.Validate(mycomboBox); // this is an example

so you dont need to create an instance to call this method. Static methods are very handy.
You can find more generous answer from google or code project. I made it very simple for yours understanding.

Suppose you declare static variables in your class.
eg

class Example
{
private:
int aVariable;
static int anotherVariable;
};

Example::anotherVariable = 0;

Now the property of the static Variable is that it doesn't belong to any particular instance of the class. It is shared by all the instances of the class. It exists even if there are no instances of the class.

Now suppose you would wish to access this variable. You could do that before creating any instances of the class. But how would you access it.

That is where static functions comes into play. With them you could access the static variable.

eg

class Example
{
public:
static int returnStaticVariable()
{
return anotherVariable;
}
private:
int aVariable;
static int anotherVariable;
};

You could call this static function with the Class Name, instead of instance.
eg

int main()
{
std::cout<<Example::returnStaticVariable();
}