Why do variables declared with the same name in different scopes get assigned the same memory addresses?

Question

I know that declaring a char[] variable in a while loop is scoped, having seen this post: Redeclaring variables in C.

Going through a tutorial on creating a simple web server in C, I'm finding that I have to manually clear memory assigned to responseData in the example below, otherwise the contents of index.html are just continuously appended to the response and the response contains duplicated contents from index.html:

while (1)
{
  int clientSocket = accept(serverSocket, NULL, NULL);
  char httpResponse[8000] = "HTTP/1.1 200 OK\r\n\n";
  FILE *htmlData = fopen("index.html", "r");
  char line[100];
  char responseData[8000];
  while(fgets(line, 100, htmlData) != 0)
  {
      strcat(responseData, line);
  }
  strcat(httpResponse, responseData);
  send(clientSocket, httpResponse, sizeof(httpResponse), 0);
  close(clientSocket);
}

Correct by:

while (1)
{
  ...
  char responseData[8000];
  memset(responseData, 0, strlen(responseData));
  ...
}

Coming from JavaScript, this was surprising. Why would I want to declare a variable and have access to the memory contents of a variable declared in a different scope with the same name? Why wouldn't C just reset that memory behind the scenes?

Also... Why is it that variables of the same name declared in different scopes get assigned the same memory addresses?

According to this question: Variable declared interchangebly has the same pattern of memory address that ISN'T the case. However, I'm finding that this is occurring pretty reliably.

Answer 1

Not completely correct. You don't need to clear the whole responseData array - clearing its first byte is just enough:

 responseData[0] = 0;

As Gabriel Pellegrino notes in the comment, a more idiomatic expression is

 responseData[0] = '\0';

It explicitly defines a character via its code point of zero value, while the former uses an int constant zero. In both cases the right-side argument has type int which is implicitly converted (truncated) to char type for assignment. (Paragraph fixed thx to the pmg's comment.)

You could know that from the strcat documentation: the function appends its second argument string to the first one. If you need the very first chunk to get stored into the buffer, you want to append it to an empty string, so you need to ensure the string in the buffer is empty. That is, it consists of the terminating NUL character only. memset-ting the whole array is an overkill, hence a waste of time.

Additionally, using a strlen on the array is asking for troubles. You can't know what the actual contents of the memory block allocated for the array is. If it was not used yet or was overwritten with some other data since your last use, it may contain no NUL character. Then strlen will run out of the array causing Undefined Behavior. And even if it returns successfuly, it will give you the string's length bigger than the size of the array. As a result memset will run out of the array, possibly overwriting some vital data!

Use sizeof whenever you memset an array!

memset(responseData, 0, sizeof(responseData));

EDIT

In the above I tried to explain how to fix the issue with your code, but I didn't answer your questions. Here they are:

1. Why do variables (...) in different scopes get assigned the same memory addresses?

In regard of execution each iteration of the while(1) { ... } loop indeed creates a new scope. However, each scope terminates before the new one is created, so the compiler reserves appropriate block of memory on the stack and the loop re-uses it in every iteration. That also simplifies a compiled code: every iteration is executed by exactly the same code, which simply jumps at the end to the beginning. All instructions within the loop that access local variables use exactly the same addressing (relative to the stack) in each iteration. So, each variable in the next iteration has precisely the same location in memory as in all previous iterations.

2. I'm finding that I have to manually clear memory

Yes, automatic variables, allocated on the stack, are not initialized in C by default. We always need to explicitly assign an initial value before we use it – otherwise the value is undefined and may be incorrect (for example, a floating-point variable can appear not-a-number, a character array may appear not terminated, an enum variable may have a value out of the enum's definition, a pointer variable may not point at a valid, accessible location, etc.).

3. otherwise the contents (...) are just continuously appended

This one was answered above.

4. Coming from JavaScript, this was surprising

Yes, JavaScript apparently creates new variables at the new scope, hence each time you get a brand new array – and it is empty. In C you just get the same area of a previously allocated memory for an automatic variable, and it's your responsibility to initialize it.

Additionally, consider two consecutive loops:

void test()
{
    int i;

    for (i=0; i<5; i++) {
        char buf1[10];
        sprintf(buf1, "%d", i);
    }

    for (i=0; i<1; i++) {
        char buf2[10];
        printf("%s\n", buf2);
    }
}

The first one prints a single-digit, character representation of five numbers into the character array, overwriting it each time - hence the last value of buf1[] (as a string) is "4".

What output do you expect from the second loop? Generally speaking, we can't know what buf2[] will contain, and printf-ing it causes UB. However we may suppose the same set of variables (namely a single 10-items character array) from both disjoint scopes will get allocated the same way in the same part of a stack. If this is the case, we'll get a digit 4 as an output from a (formally uninitialized) array.

This result depends on the compiler construction and should be considered a coincidence. Do not rely on it as this is UB!

5. Why wouldn't C just reset that memory behind the scenes?

Because it's not told to. The language was created to compile to effective, compact code. It does as little 'behind the scenes' as possible. Among others things it does not do is not initializing automatic variables unless it's told to. Which means you need to add an explicit initializer to a local variable declaration or add an initializing instruction (e.g. an assignment) before the first use. (This does not apply to global, module-scope variables; those are initialized to zeros by default.)

In higher-level languages some or all variables are initialized on creation, but not in C. That's its feature and we must live with it – or just not use this language.

Answer 2

With this line:

char responseData[8000];

You are saying to your compiler: Hey big C, give me a 8000 bytes chunk and name it responseData.

In runtime, if you don't specify, no one will ever clean or give you a "brand-new" chunk of memory. That means that the 8000 bytes chunk you get in every single execution can hold all the possible permutations of bits in this 8000 bytes. Something extraordinary that can happens, is that you're getting in every execution the same memory region and thus, the same bits in this 8000 bytes your big C gave to you in the first time. So, if you don't clean, you have the impression that you're using the same variable, but you're not! You're just using the same (never cleaned) memory region.

I'd add that it's part of the programmer's responsibilities to clean, if you need to, the memory you're allocating, in dynamic or static way.

Answer 3

Why would I want to declare a variable and have access to the memory contents of a variable declared in a different scope with the same name? Why wouldn't C just reset that memory behind the scenes?

Objects with auto storage duration (i.e., block-scope variables) are not automatically initialized - their initial contents are indeterminate. Remember that C is a product of the early 1970s, and errs on the side of runtime speed over convenience. The C philosophy is that the programmer is in the best position to know whether something should be initialized to a known value or not, and is smart enough to do it themselves if needed.

While you're logically creating and destroying a new instance of responseData on each loop iteration, it turns out the same memory location is being reused each time through. We like to think that space is allocated for each block-scope object as we enter the block and released as we leave it, but in practice that's (usually) not the case - space for all block-scope objects within a function is allocated on function entry, and released on function exit¹.

Different objects in different scopes may map to the same memory behind the scenes. Consider something like

void bletch( void )
{
  if ( some_condition )
  {
    int foo = some_function();
    printf( "%d\n", foo );
  } 
  else
  {
    int bar = some_other_function();
    printf( "%d\n", bar );
  }

It's impossible for both foo and bar to exist at the same time, so there's no reason to allocate separate space for both - the compiler will (usually) allocate space for one int object at function entry, and that space gets used for either foo or bar depending on which branch is taken.

So, what happens with responseData is that space for one 8000-character array is allocated on function entry, and that same space gets used for each iteration of the loop. That's why you need to clear it out on each iteration, either with a memset call or with an initializer like

char responseData[8000] = {0}; 

---

1. As M.M points out in a comment, this isn't true for variable-length arrays (and potentially other variably modified types) - space for those is set aside as needed, although where that space is taken from isn't specified by the language definition. For all other types, though, the usual practice is to allocate all necessary space on function entry.