A variable declared inside the `main()` function can be accessed directly from another function `my_func()`. Is this true or false?

• True
• FALSE
• Only if `my_func()` is called by `main()`
• Only if passed as an argument

Answer explanation

Variables declared inside a function have local scope and are not accessible outside that function unless explicitly passed.

Which type of variable has its lifetime restricted to the block in which it is declared?

• Global variable
• Static variable
• Local variable
• External variable

Answer explanation

Local variables are created upon entry to their block and destroyed upon exit.

If a function `foo()` declares a local variable `x`, and another function `bar()` also declares a local variable `x`, are these two variables the same?

• Yes, they refer to the same memory location
• No, they are distinct variables in different scopes
• Only if `foo()` calls `bar()`
• Only if `x` is also a global variable

Answer explanation

Local variables with the same name in different functions are completely independent.

What happens if you try to access a local variable outside its defined scope?

• Compiler error
• Runtime error
• Undefined behavior
• It will be initialized to zero

Answer explanation

The compiler will generate an error because the variable is not visible outside its scope.

Where are global variables typically declared in a C program?

• Inside a function
• Inside the `main()` function only
• Outside of any function, usually at the beginning of the source file
• In a header file only

Answer explanation

Global variables are declared outside of any function and have file scope or external linkage.

What is the default value of a global variable if it is not explicitly initialized?

• Garbage value
• Zero
• Null
• Undefined

Answer explanation

Global variables (and static variables) are automatically initialized to zero if not explicitly given a value.

What is the storage duration of an `auto` variable?

• Static storage duration
• Dynamic storage duration
• Automatic storage duration
• Thread local storage duration

Answer explanation

`auto` variables have automatic storage duration, meaning they are created when their block is entered and destroyed when it's exited.

Can an `auto` variable be used before its declaration within the same scope?

• Yes
• No
• Only if it's a global variable
• Only if it's initialized later

Answer explanation

Like all variables, `auto` variables must be declared before they are used.

When declaring a global variable that will be used in multiple source files, which keyword should be used in the files where it's *declared* (defined)?

• `extern`
• `static`
• `auto`
• No keyword is needed for definition

Answer explanation

No keyword is needed for the definition (first declaration with initialization) of a global variable. `extern` is for subsequent declarations in other files.

What happens if you declare an `extern` variable but never define it in any compilation unit?

• Compiler error
• Linker error
• Runtime error
• Warning only

Answer explanation

The compiler will allow the `extern` declaration, but the linker will fail because it cannot find the definition of the variable.