C Programming Variables & Scope

• C Programming Lecture 5 covers advanced C programming concepts.
• The topics discussed are scope of symbol names (including 4 flavors), precedence of operators, associativity, and the syntax of declarations.

Scope, Access Control, Storage Class

• Most programming languages separate the concepts of scope, access control, and storage class.
• The scope of a variable is the region over which you can access the variable by name.
• The code defines where a variable is "visible".
• Variables declared within a method are only visible within that method, making them local in scope.
• Storage class determines how long a variable stays "alive".
• Access control determines who can access a symbol that is visible to everyone.

Scope vs. Access Control

• Most modern languages provide additional accessibility control for functions, methods, and variables.
• Java has 4 access levels for methods and class/instance variables: private, protected, package-level (default), and public.
• A class variable with class-wide scope is visible to all classes/objects within a program.
• The use of access control can make a variable inaccessible to various other classes.
• Use "private" to make a class variable visible only to the objects of that class.

Scope in C

• C has no access control; everything is "public".
• C provides some control over who can see a specific variable.
• There are 4 types of scope in C, ordered from widest to narrowest: Program Scope, File Scope, Function Scope, and Block Scope.

Scoping Principle

• The Scoping principle states that you should always define a symbol in the narrowest scope that works.
• This is for error prevention.
• The narrowest scope that works is used to control access in OO Programming and for a lesser extent security.

Program Scope

• Program Scope makes a declared variable accessible in all source files within the final executable file
• In C, all functions have Program Scope.
• Global (extern) variables have Program Scope.

Program Symbol Concepts

• Names are used for both data and functions, including variable names, typedefs, enums, structs (fields), and classes (data members, methods).
• Definition indicates where the named thing "lives," referring to the actual memory location of data or a function.
• Reference refers to some use of the thing by name, requiring load/store operations or calls to be "resolved" to a location
• Declaration tells the compiler about the name, so the compiler can verify the references are correct.

External Symbols

• Program scope symbols are passed to the linker in a ".o" file and are also known as external symbols.
• External definition, "extdef"
• External reference, "extref"
• In a linked executable, each external symbol must have exactly one extdef; otherwise, there will be an error, such as "undefined external".
• There can be any number of extrefs for symbols
• Extrefs are substituted with the final memory address of the symbol.

"Externals"

• Having "program scope" (external symbols) is used in Assembly language.
• Having "program scope" (external symbols) is common in many programming languages
• Program scope allows big programs to be linked together out of modules.
• Each language has its own way of designating extdef and extref.

Using Program Scope in C: Function

• Example of "extdef"

void insertBack(List* list, void* tobeAdded) {...}

• "extdef" definition appears only in one .c file (e.g., LinkedListAPI.c).
• "Declaration" example:

void insertBack(List* list, void* tobeAdded);

• "Declaration" seems to appear only once in LinkedListAPI.h but is in many .c files if the prototype is declared.
• Include guards prevent recursive re-declarations.
• "extref" example:

insertBack(list, data);

• "extref" calls definitely happens in multiple files

Using Program Scope in C: Variable

• Example: "extdef"

FILE* inputfile;

• "extdef" definition appears only in one .c file, outside of any function.
• "extdef" definitions can be initialized :

type varname = initial_value;

• Declaration example:

extern FILE* inputfile;

• Declaration appears anywhere in a file(inside / outside functions)
• An extref example is the code:

fclose(inputfile);

• extref appears anywhere the variable is used

Using Program Scope

• It's necessary to decide when to use program scope.
• Variables should usually not be globally accessible.
• Program scope functions should be part of the program's public interface.

File Scope

• A variable or function has file scope when its declaration is accessible from the point of declaration (definition) to the end of the file.
• Using the static keyword allows things to be global within a file, but not globally to the whole program.
• The static keyword has multiple uses.
• If a variable is defined outside any function, it gets the "program scope" (Global Scope) and "static" keyword keeps definition from being passed to linker (Does not become external)

Using File Scope

• In C the File scope is between private and package level in Java
• It works well with internal use only functions
• Local variables will restrict the local function body scope and require manual passing of the function arguments.
• "file scope" and "program scope" global variables are usually a bad idea.

Function Scope

• Function scope means something is accessible throughout a function.
• Only goto labels have function scope.
• Throughout a function, you can jump ahead using the goto label.

goto bummer;
...
bummer:  printf(“Outta here!”);

Block (local) scope

• The variable is accessible after its declaration point to the end of the block in which it was declared.
• A 'block is anything between {} braces
• Variables inside the block are local
• The terms local scope and block scope are used interchangeably.
• The "block" includes the function’s parameters and local parameters, a statements in the loop.

What happens?

func() {
    int a = 11;
    {
        int b = 10;
    }
    printf(“%d %d\n",a,b);
}

• Won't work!
• The variable b is inside a block and is not accessible to the rest of the function.

Using Local Variables Badly

• As a rule, declare variables with the narrowest scope.
• Loop counters can be declared right in the for-loop statement.
• Temporary variables used only inside one loop can be declared within that loop. Avoid re-using the same variable names.

Scope vs Storage Class

• Storage class applies to where and how long a variable is kept.
• Storage class is different from scope, which defines accessibility.
• Generally scope and storage class are unrelated
• Declaring a static variable affects both its storage and its scope.

Automatic Storage

• Associated with functions
• Arguments
• Local variables inside functions or inside another block
• remember a block is stuff between a pair of {}s
• Fresh temporary copy is created on the stack at the point that the function gets called.
• Stack copies get initialized
• Copies go once function returns to caller
• Recursion is allowed!

Automatic Storage Warning

• Never return pointers to automatic variables.
• Automatic variables are terminated the scope ends / Function Returns
• A pointer to freed memory will return if its to an automatic variable
• To make the matters worse, this will sometimes "work"

Static Storage

• Means there is only one instance of variable in executable program
• Applies to program scope (global variables) and "static" variables ("static file scope, “"static" local variables)
• Adding the static keyword to restricts the variables and is no longer global
• static keyword allows variable to initialize once

Using Static Storage

• Use static when we want restrict variables to file scope
• We want to have a function that "remembers" a local value between function calls.
• Declare "static" with block to achieve scope and storage

Global / External storage

• Program scope variables are in memory as long as the variable remains in scope

All .C File Example

int i;  // Program scope program storage
static int j; /* File scope, static storage */
func(int k) { /* func is Program scope K is block scope*/
    int m; //block/local scope, automatic storage
    static int x; //block/local scope, static storage
}

Dynamic Storage

• Contrasted with static and automation storage, this is the third class of storage
• Created (temporarily) on the heap via malloc(), calloc(), realloc().
• Explicit release of memory achieved via free()
• Address (pointer) to memory has scope and storage class itself
• Memory persists even after program ends
• Need to reboot/log to clear memory

General Rules of Scope and Access

• Keep variables local, use the narrowest scope.
• No program scope variables
• Few to no file scope variables.
• Give the internal, utility functions file-scope, if possible.
• Only return pointers to dynamically allocated storage
• Never return pointer to automatic (statically allocated) variables from functions.
• Remember to manually free dynamically allocated storage.

Precedence of Operators

• Operator precedence determines the order in which operators are evaluated.
• Operators are used to evaluate for both numeric and pointer expressions.
• Operators can have an associativity used to determine which operands are grouped with similar operators.

Associativity

• Applies with operators of same precedence.

A op1 B op2 C op3 D
// Which *op* is done first?

• Is either left to right or right to left

Left-to-Right Associativity

• Is most common

a + b - c;
// evaluate expression from left to right
== (a+b) - c

Right-to-Left Associativity

• Is rare

a = b = c = 1;
// "assign c to b and B to a"
== a = (b = (c = 1))

• Only meaningful in C due to returning assigned value
• Assignment operator does not have return value in some languages.

Problems with Precedence

• Is is unexpected
• Use parentheses to evaluate

Problems With Examples

- p.f == (*p).f //Expectation
     == *(p.f) //Actual

• . operator takes precedence over *
• Solution: Use the -> or include the parens

Second Problem example

int *ap[];
// Expectation: ap is a pointer to an array of ints.
// What is actually happening: ap is a pointer to an array of ints

• The second [] takes precedence over the * first.
• Commonly found in declarations.

What happens with this?

int *fp();
// Expectation: fp is a pointer to a function returning an int.
// What is actually happening: fp (is a function returning a ptr to int)

• The parans take precendce
• in C f() means accepts variable number of args
• To get a function pointer you can declare as such

Explore variable scope, storage classes, and enums in C. Learn about best practices for variable declaration, risks of shadowing, and advantages of using enums over magic constants in C programming.