Interesting Scope Problem, Explanation?

Question

I just discovered a bug where the code looked something like this:

char *foo = malloc(SOME_NUM * sizeof(char));
if (!processReturnsTrueOrFalse(foo)) {
    free(foo);
    char *foo = malloc(SOME_NUM * sizeof(char));
    // More stuff, whatever
}

This compiles, but it's weird that I am allowed to define two variables within the same function, but the compiler appears to scope them differently.

If this were the case, how do I differentiate the inner foo with the outer one? How did the compiler know that in the free before my second declaration, I was trying to free the outer foo, but then when I redeclared the inner foo, it didn't give me an error?

Thanks for any info. This is probably a pretty obvious, newbie question.

Answer 1

The scope of your second 'foo' starts at its declaration and continues until the end of the block it is declared in. When you call free(foo) it is acting on the first 'foo' because the second foo has not been declared yet.

After declaring the second 'foo' there is no way to access the outer 'foo'. You have essentially masked the name.

Answer 2

This is not an error, it is possible to declare variables with the same names in different scopes.

The compiler knows that the foo inside the free function is the outer one because at that point it is the only foo of the program.

After the declaration of the second foo you should use

::foo = ...

to access the outer foo, (edit) if the outer foo is declared as global (outside any function).

Answer 3

Hi

This because of scoping and symbol tables.

The example you have here is more wired than normal scoping (and i would strongly advice not to use such constructs). But the explanation is that the compiler updates the symbol table at the point you declare the new variable, until then the symbol table lookup falls trough to the outer scope.

As you can see with this example the address of the pointer changes:

void *var = NULL;
{
    std::cout << "From outer scope: " << &var << std::endl;

    void *var = NULL;

    std::cout << "From inner scope: " << &var << std::endl;
}

Answer 4

C++ defines a new scope for variables every time you use { }. Take a look at this example here.

const char *foo = "global";

int main(int argc, char* argv[])
{
    const char *foo = "hello";

    {
     cout << foo << endl;
     const char *foo = "world";
     cout << foo << endl;
     cout << ::foo << endl;
    }
    cout << foo << endl;
}

When you run this, you get:

 hello
 world 
 global 
 hello

When you open a new scope and declare a variable with the same name as a variable in an enclosing scope, you hide the variable in the outer scope as long as you remain in the current scope. Once you leave the inner scope, the outer variable becomes visible again. If the outer variable happens to be a globabl variable, you can access with the global namespace ::foo. If the outer variable is a class variable, you can use className::foo. If the outer variable is just a local variable, there is no way to access it until you leave the scope where you declared the variable that hid it.

I haven't used C in a while, so C99 will likely be different, but in the older C, there is no way to access a hidden name.

const char *foo = "global";

int main(int argc, char* argv[])
{
    const char *foo = "hello";

    {
        char *foo = "world";
        printf("%s\n", foo);
    }
    printf("%s\n", foo);
    return 0;
}

When you run this, you get:

 world 
 hello

Answer 5

As other posters wrote, you shadow the variable when declare the variable with the same name within inner scope, e.g. function or block.

But there is a way to access shadowed global non-static variable in C:

int foo = 1;                       // global

int bar(void) {

    printf ("%d", foo);            // print global
    {
        int foo = 2;               // global foo shadowed
        printf ("%d", foo);        // print local
        {
             extern int foo;       // local foo shadowed
             printf("%d", foo);    // print global
        }                          // global foo shadowed
        printf ("%d", foo);        // print local
    }                              // end of scope for local foo
}

I made some dummy blocks because with pre-C99 compilers you cannot declare the variable in the middle of the block.