Internal static variables in C, would you use them?

Question

In C you can have external static variables that are viewable every where in the file, while internal static variables are only visible in the function but is persistent

Answer 1

They are used to implement tools like strtok, and they cause problems with reentrancy...

Think carefully before fooling around with this tool, but there are times when they are appropriate.

Answer 2

I find it handy for one-time, delayed, initialization:

int GetMagic()
{
   static int magicV= -1;

   if(-1 == magicV)
   {
      //do expensive, one-time initialization
      magicV = {something here}
   }
   return magicV;
}

As others have said, this isn't thread-safe during it's very first invocation, but sometimes you can get away with it :)

Answer 3

Not anymore. I've seen or heard the results of function local static variables in multithreaded land, and it isn't pretty.

Answer 4

A simple use for this is that a function can know how many times it has been called.

Answer 5

For example, in C++, it is used as one way to get singleton istances

SingletonObject& getInstance()
{
  static SingletonObject o;
  return o;
}

which is used to solve the initialization order problem (although it's not thread-safe).

Ad "shouldn't the function be in its own file"

Certainly not, that's nonsense. Much of the point of programming languages is to facilitate isolation and therefore reuse of code (local variables, procedures, structures etc. all do that) and this is just another way to do that.

BTW, as others pointed out, almost every argument against global variables applies to static variables too, because they are in fact globals. But there are many cases when it's ok to use globals, and people do.

Answer 6

I've never heard this specific construct termed "internal static variable." A fitting label, I suppose.

Like any construct, it has to be used knowledgeably and responsibly. You must know the ramifications of using the construct.

It keeps the variable declared at the most local scope without having to create a separate file for the function. It also prevents global variable declaration.

For example -

char *GetTempFileName()
{
  static int i;
  char *fileName = new char[1024];
  memset(fileName, 0x00, sizeof(char) * 1024);
  sprintf(fileName, "Temp%.05d.tmp\n", ++i);
  return fileName;
}

VB.NET supports the same construct.

Public Function GetTempFileName() As String
  Static i As Integer = 0
  i += 1
  Return String.Format("Temp{0}", i.ToString("00000"))
End Function

One ramification of this is that these functions are not reentrant nor thread safe.