Can I use a static var to "cache" the result? C++

Question

I am using a function that returns a char*, and right now I am getting the compiler warning "returning address of local variable or temporary", so I guess I will have to use a static var for the return, my question is can I make something like if(var already set) return var else do function and return var?

This is my function:

char * GetUID()
{
   TCHAR buf[20];

   StringCchPrintf(buf, 20*sizeof(char), TEXT("%s"), 
            someFunction());

   return buf;
}

And this is what I want to do:

char * GetUID()
{
   static TCHAR buf[20];

   if(strlen(buf)!=0) return buf;

   StringCchPrintf(buf, 20*sizeof(char), TEXT("%s"), 
            someFunction());

   return buf;
}

Is this a well use of static vars? And should I use ZeroMemory(&buf, 20*sizeof(char))? I removed it because if I use it above the if(strlen...) my TCHAR length is never 0, should I use it below?

Answer 1

It's OK if your code is single threaded. The buffer will be set to contain all zeros when the function is entered for the very first time, so there is no need to explicitly set its contents to zero. But these days all code eventually tends to become multi-threaded, so I would not do this, if I were you.

Answer 2

You could do that, but it won't be thread-safe. You should also be careful with what you do with the result, since you can not store it between subsequent calls to the function (without copying it, of course).

You should also initialize the static variable to the empty string.

Answer 3

What you should do instead is allocate buf dynamically using new, and then return it. But be aware that the caller would be responsible for deallocating the memory.

Better yet, use std::string instead of char *.

Answer 4

The reason you're getting a warning is because the memory allocated within your function for buf is going to be popped off the stack once the function exits. If you return a pointer to that memory address, you have a pointer to undefined memory. It may work, it may not - it's not safe regardless.

Typically the pattern in C/C++ is to allocate a block of memory and pass a pointer to that block into your function. e.g.

void GetUID( char* buf )
{
    if(strlen(buf)!=0) return;

    StringCchPrintf(buf, 20*sizeof(char), TEXT("%s"), someFunction());
}

If you want the function (GetUID) itself to handle caching the result, then you can use a static, a singleton (OOP), or consider thread local storage. (e.g. in Visual C++)

__declspec(thread) TCHAR buf[20];

Answer 5

This is how I would do it. It caches; it does not rely on the buffer being 0.

It does have the implicit assumption that 'buf' will be identical from thread to thread, which is not (to my knowledge) correct. I would use a global for that purpose.

//returns a newly allocated buffer, every time. remember to delete [] it.
char * GetUID()
{
   static TCHAR buf[20];
   static bool run = false;
   TCHAR ret_mem = new TCHAR[20];

   if(run) 
  { return ret_mem; }

  //do stuff to the buf
  //assuming - dst, src, size. 
  memcpy(ret_mem, buf, 20);

  run = true;
  return ret_mem;
}