Uses of static variables inside functions

I have been writing C code for many years, but I recently came accross a feature that I have never used: a static variable inside a function. Therefore, I was wondering what are some ways that you have used this feature and it was the开发者_如何学运维 right design decision.

E.g.

int count(){
    static int n;
    n = n + 1;
    return n;
}

is a BAD design decision. why? because later you might want to decrement the count which would involve changing the function parameters, changing all calling code, ...

Hopefully this is clear enough, thanks!

void first_call()
{
   static int n = 0;

   if(!n) {
     /* do stuff here only on first call */
     n++;
   }

   /* other stuff here */
}

I have used static variables in test code for lazy initialization of state. Using static local variables in production code is fraught with peril and can lead to subtle bugs. It seems (at least in the code that I generally work on) that nearly any bit of code that starts out as a single-threaded only chunk of code has a nasty habit of eventually ending up working in a concurrent situation. And using a static variable in a concurrent environment can result in difficult issues to debug. The reason for this is because the resulting state change is essentially a hidden side effect.

I have used static variables as a way to control the execution of another thread.

For instance, thread #1 (the main thread) first declares and initializes a control variable such as:

/* on thread #1 */
static bool run_thread = true;
// then initialize the worker thread

and then it starts the execution of thread #2, which is going to do some work until thread #1 decides to stop it:

/* thread #2 */
while (run_thread)
{
  // work until thread #1 stops me
}

There is one prominent example that you very much need to be static for protecting critical sections, namely a mutex. As an example for POSIX threads:

static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&mut);
/* critical code comes here */
pthread_mutex_unlock(&mut);

This wouldn't work with an auto variable.

POSIX has such static initialzers for mutexes, conditions and once variables.