C Programming: Variable Scope and Storage

• Lecture covers scope of symbol names, precedence of operators, and associativity in C programming.

Scope, Access Control, Storage Class

• Programming languages usually separate scope, access control, and storage class.
• Scope is the region where a variable can be accessed by name.
  • Scope defines a variable's visibility
  • Variables declared within a method are only visible within that method (local scope).
• Storage class determines how long a variable stays "alive".
• Access control determines who can access a visible symbol.

Scope vs Access Control

• Modern languages provide control over function/method and variable accessibility.
• Java has 4 access levels: private, protected, package-level (default), and public.
• Class variables with class-wide scope can be made inaccessible to other classes using access control, such as making them private to the objects of that class.

Scope in C

• C lacks access control; everything is public, but there is some control over variable visibility.
• There are four types of scope in C:
  • Program scope: widest scope
  • File scope
  • Function scope
  • Block scope: narrowest scope.

Scoping Principle

• Always define symbols in the narrowest scope possible.
• Helps to prevent errors and improve security.

Program Scope

• Program scope means the variable is accessible by all source files that make up the executable.
  • All functions in C have program scope.
  • Global (extern) variables have program scope.

Program Symbol Concepts

• Names are used for data and functions, including variable names, typedefs, enums, structs (fields), and classes (data members, methods).
• Definition: where the named thing “lives”, this is the actual memory location of data or function.
• Reference: some use of the thing by name, such as load/store, call, which must be "resolved” to a location.
• Declaration: informs the compiler about the name, to verify the references.

External Symbols

• Program scope symbols are passed to the linker in a .o file.
  • External definition is "extdef".
  • External reference is "extref".
• In a linked executable, each external symbol has:
  • Exactly one extdef.
  • Any number of extrefs.
  • Is substituted with the final memory address of the symbol.

"Externals

• Having program scope is a common requirement in assembly and other programming languages.
• It enables linking of a large program from small modules.
• Each language has its own convention for designating extdef & extref.

Using Program Scope in C: function

• extdef: void insertBack(List* list, void* toBeAdded) {...}
  • Definition appears once, in the .c file.
• Declaration: void insertBack(List* list, void* toBeAdded);
  • Typically appears once in header file, but included in many .c files
  • Include guards prevent re-declarations.
• extref: insertBack(list, data);
  • Call definitely happens in multiple files.

Using Program Scope in C: variable

• extdef: FILE* inputfile;
  • Defined once in a .c file, outside any function.
  • Can be initialized: type varname = initial_value.
• declaration: extern FILE* inputfile;
  • Declaration can appear anywhere in a file, inside or outside functions.
• extref: fclose(inputfile);
  • Appears anywhere the variable is used.

Using Program Scope

• Program scope should be used judiciously.
• Variables should generally not be globally accessible to the end user.
• Program scope functions should be part of the program's public interface.
• It's best to avoid program scope for internal functions whenever possible.

File Scope

• A variable or function with file scope is accessible from its declaration to the end of the file.
• Use the static keyword for file-scope variables and functions.
• Caution: static has multiple uses.
• If a variable is defined outside any function, it would normally have program scope; however, the static keyword prevents the definition from being passed to the linker, making it file scope.

Using File Scope

• File scope in C is between private and package-level in Java.
• Suited for "internal-use-only" functions.
• Avoid using program scope variables and use file scope instead.
• Keep variables local to each function body and pass them as arguments.
• Global variables (whether program or file scope) generally lead to hard-to-find errors.

Function Scope

• Accessible throughout a function.
• In C, only goto labels have function scope.
• "Throughout" means you can jump ahead using goto.

Block (local) Scope

• Is anything between {} braces.
• Variables declared within a block, are considered local variables.
• Includes function's parameters and local variables declared in a function
• Includes loop counters declared in a for(int i=0; ...) statements, and variables declared within loop/branching statement bodies.
• local scope and block scope are the same when interchanging terms

Example

func() {
    int a = 11;
    {
        int b = 10;
    }
    printf(“%d %d\n",a,b); // This won't work!
}

• The variable b is inside a block and is not be visible to the rest of the function.

Using Local Variables

• Declare variables with the narrowest scope.
• Declaring loop counters in a for loop.
• Using temporary variables for multiple loops only when necessary

Example of a local variable used badly

void func() {
    int x = 7;
    for (int i = 0; i < 10; i++){
        int x = i;  // The "outer" x never changes
    }
}

Scope vs. Storage Class

• Storage class applies to where and how long a variable is kept, different from scope which determines who can see a variable.
• Typically, scope and storage class are unrelated.
• It's important to note that declaring a variable static affects both its storage and its scope.

Automatic Storage

• Associated with functions.
  • e.g. arguments
  • Local variables inside functions or other blocks; a block is defined by {}.
• Fresh temporary copy allocated on the stack each time a function is called.
• Allows recursion to work

Automatic Storage - warning

• Never return pointers to automatic variables.
• Because automatic variables go away when the scope ends or the function returns, avoid returning their pointers.
• Returning such pointers leads to pointing to memory that has already been freed.

Automatic Storage - BAD example

char* func(){
    char x[5];
    //Do stuff with x
    return x;  // Never do this!
}

int main(void){
    char* s = func();
    printf("%s\n", s);
}

Static Storage

• Only one instance of the variable exists in the executable program.
• Applies to:
  • program scope (global variables)
  • "static" file scope variables
  • "static" local variables.
• If adding the static keyword, a variable is no longer global and is restricted to the file scope.
• Using the static keyword changes the local variable from automatic to static storage class
• Is only initialized once, when the program starts.

Dynamic Storage

• The third class of storage, as contrasted with static and automatic.
• Created temporarily on the heap using functions like malloc(), calloc(), and realloc().
• . They are usually not on the stack like static storage classes
• Must be explicitly freed by using free().
• The address (pointer) must be stored in a variable that has scope and storage class itself.
• Dynamic storage exists until explicitly freed, and if not freed, may persist even after the program terminates.

TL;DR: General rules of scope and access

• Keep variables local and use the narrowest scope possible.
  • Avoid program scope variables.
  • Use few or no file scope variables.
• Only give the necessary functions program-level access.
• Only return pointers to dynamically allocated storage.
• Do not return pointers to automatic storage variables.
• Remember to manually free any dynamically allocated storage.

Precedence of Operators

• Operator precedence determines the order in which operators are evaluated.
  • Operators are used to calculate values for both numeric and pointer expressions.
  • Operators also have associativity

Associativity

• Applies when there are 2 or more operators with the same precedence.
• Solves question of which operator is done first
• Associativity can be either Left-to-Right or Right-to-Left

Associativity: Left-to-right (aka left associative)

• Is the most common form.
• For example
  • a + b - c;
  • "+" and "-" operators are evaluated from left to right
  • Equivalent to: (a + b) - c;

Associativity: Right-to-left (aka right associative)

• Very rare and uncommon.
• For example
  • a = b = c = 1;
  • This means assign c to b, and then to a
  • a = (b = (c = 1));
• Only meaningful in C, other languages don't return a value and it doesn't work

Problems with Precedence

• The precedence of some operators can lead to unexpected behaviors.
• Use enough parenthesis so that order of operations is clear.

Precedence Problem: pointer to structure

• *p.f
• Expectation: ( *p ).f
• Means what p points to, member f
• Actual: *( p.f )
• Means pointer to memory of what p.f is
• In structure, is a compile error

Reasoning

• . has higher precedence than *
• -> was implemented to avoid such cases.
• p->f

Precedence Problem: int *ap[]

• Expectation:int (*ap)[]
• The array ap expects int pointers, can take elements of int pointers
• Actual: int *(ap[])
  • Array of pointers-to-int
• Why?
  • brackets [] has higher precedence than *

Precedence Problems: int *fp()

• Expectation int (*fp)()

  • fp is a pointer to a function returning an int

• Actual int *(fp())

  • fp is a function returning a ptr-to-int.

• This is particularly bad, since in C, f() means a function with a variable number of arguments, and is not a function with no arguments.

• To declare a pointer to a function with no arguments that returns int code as int (*fp)(void)

• This solution code will be needed often

Precedence Problems: c = getchar() != EOF

• Expectation: ( c = getchar() ) != EOF
• Actual: c = (getchar() != EOF)
  • c is set equal to the true/false value from result Reasoning
• == and != comparators have higher precedence than assignment
  • Solution: ( c = getchar()) != EOF

Solution to Precedence Problems

• When in doubt, use parentheses.
• Always use parentheses even when not in doubt for clarity.
• Resist writing clever code. Clarity is valued in code!

Test your knowledge of variable scope and storage in C programming. The quiz covers program scope, function scope, and the purpose of storage class specifiers. It also addresses the implications of C's lack of access control mechanisms.