Is it a common practice to re-use the same buffer name for various things in C?

For example, suppose I have a buffer called char journal_name[25] which 开发者_运维百科I use to store the journal name. Now suppose a few lines later in the code I want to store someone's name into a buffer. Should I go char person_name[25] or just reuse the journal_name[25]?

The trouble is that everyone who reads the code (and me too after a few weeks) has to understand journal_name is now actually person_name.

But the counter argument is that having two buffers increases space usage. So better to use one.

What do you think about this problem?

Thanks, Boda Cydo.

The way to solve this in the C way, if you really don't want to waste memory, is to use blocks to scope the buffers:

int main()
{
  {
    char journal_name[26];
    // use journal name
  }
  {
    char person_name[26];
    // use person name 
  }
}

The compiler will reuse the same memory location for both, while giving you a perfectly legible name.

As an alternative, call it name and use it for both <.<

Some code is really in order here. However a couple of points to note:

Keep the identifier decoupled from your objects. Call it scratchpad or anything. Also, by the looks of it, this character array is not dynamically allocated. Which means you have to allocate a large enough scratch-pad to be able to reuse them.

An even better approach is to probably make your functions shorter: One function should ideally do one thing at a time. See if you can break up and still face the issue.

As an alternative to the previous (good) answers, what about

char buffer[25];

char* journal_name = buffer;

then later

char* person_name = buffer;

Would it be OK ?

If both buffers are automatic why not use this? Most of compilers will handle this correctly with memory reused. But you keep readability.

{
    char journal_name[25];
    /*
        Your code which uses journal_name..
    */
}
{
    char person_name[25];
    /*
        Your code which uses person_name...
    */
}

By the way even if your compiler is stupid and you are very low of memory you can use union but keep different names for readability. Usage of the same variable is worst way.

Please use person_name[25]. No body likes hard to read code. Its not going to do much if anything at all for your program in terms of memory. Please, just do it the readable way.

You should always (well unless you're very tight on memory) go for readability and maintainability when writing code for the very reason you mentioned in your question.

25 characters (unless this is just an example) isn't going to "break the bank", but if memory is at a premium you could dynamically allocate the storage for journal_name and then free it when you've finished with it before dynamically allocating the storage for person_name. Though there is the "overhead" of the pointer to the array.

Another way would be to use local scoping on the arrays:

void myMethod()
{
    ... some code
    {
        char journal_name[25];
        ... some more code
    }
    ... even more code
    {
        char person_name[25];
        ... yet more code
    }
}

Though even with this pseudo code the method is getting quite long and would benefit from refactoring into subroutines which wouldn't have this problem.

If you are worried about memory, and I doubt 25 bytes will be an issue, but then you can just use malloc and free and then you just have an extra 4-8 bytes being used for the pointer.

But, as others mentioned, readability is important, and you may want to decompose your function so that the two buffers are used in functions that actually give more indication as to their uses.

UPDATE:

Now, I have had a buffer called buffer that I would use for reading from a file, for example, and then I would use a function pointer that was passed, to parse the results so that the function reads the file, and handles it appropriately, so that the buffer isn't filled in and then I have to remember that it shouldn't be overwritten yet.

So, yet, reusing a buffer can be useful, when reading from sockets or files, but you want to localize the usage of this buffer otherwise you may have race conditions.