Variables in C Programming - Definition and Scope

VARIABLE S BICT1201 VARIABLE DEFINITION WHAT IS A VARIABLE? VARIABLES A variable is a named storage location in the computer's memory that holds a value. This value can be modified and reused during the execution of a program. Variables are fundamental to programming, allowing developers to st...

VARIABLE S BICT1201 VARIABLE DEFINITION WHAT IS A VARIABLE? VARIABLES A variable is a named storage location in the computer's memory that holds a value. This value can be modified and reused during the execution of a program. Variables are fundamental to programming, allowing developers to store, manipulate, and retrieve data dynamically. Without variables, programming would be a rigid, inflexible process, unable to adapt to dynamic data or user input. Characteristics of Variables Variables have names, types, and values. Name – Label or identifier of the symbol. The name of a variable can be composed of letters, digits, and the underscore character. It must begin with either a letter or an underscore. Upper and lowercase letters are distinct because C is case-sensitive. Variables cannot use reserved keywords as variable names. Type – Determines the value that can be assigned the symbol. Each variable has a defined data type (e.g., int, float, char) that determines the kind of data it can hold and the operations that can be performed on it. Value – The value of the symbol at a given moment. Characteristics of Variables Memory Association: A variable is associated with a specific memory address where its value is stored. When the variable’s name (or identifier) is used in the program, the information at the address of the variable is accessed. The memory size allocated for the variable depends on its type, which must be set when the variable is declared. VARIABLE INITIALISATION Syntax For Declaring Variables  In C, variables are declared using the following syntax type variable_name; For instance int grade; Variables can be initialized at the time of declaration. The syntax is as follows; type variable_name = value; For instance Int grade = 50; Variable Initialization Variable Initialization is the process of assigning an initial value to a variable at the time of its declaration. This ensures that the variable has a known value when it is first used, preventing unexpected behaviour due to garbage values. The basic syntax data_type variable_name = initial_value; Methods of Initialization Direct Initialization Assigning a value to a variable at the point of declaration using the assignment operator = int age = 25; float pi = 3.14159; char initial = 'J'; You can also initialize multiple variables of the same type in one line int x = 1, y = 2, z = 3; Methods of Initialization Initialization with Expressions Using expressions to calculate the initial value. int width = 10; int height = 5; int area = width * height; // area is initialized with an expression Initialization during Declaration of Arrays Providing initial values within curly braces {} when declaring an array. int numbers = {1, 2, 3, 4, 5}; char message[] = "Hello"; // String literal initialization Methods of Initialization Initialization of Structures Providing values for structure members in order, within curly braces. struct Point { int x; int y; }; struct Point p1 = {10, 20}; // Initialize x with 10 and y with 20 Examples of Variables int age; Declares an integer variable named age. float temperature; Declares a single-precision floating-point variable named temperature. double pi = 3.14159;: Declares a double-precision floating-point variable named pi and initializes it with the value 3.14159. double provides more precision than float. char initial;: Declares a character variable named initial. It can store a single character (e.g., 'a', 'Z', '7’). What to Avoid When Declaring Variables  Single-letter or Very Short, Uninformative Names i, j, k: While often acceptable as loop counters in small, localized loops, using them for other variables makes it hard to understand their purpose Names That Don't Reflect the Variable's Purpose total: If it stores the average and flag: If it's used to store a count. Overly Long and Verbose Names int thisVariableStoresTheNumberOfPointsEachTeamHas: While descriptiveness is good, extreme length can hinder readability. What to Avoid When Declaring Variables Names That Use Mixed Case Without a Clear Convention (inconsistency) totalRecords and total_records in the same codebase. numberOfRecords and numberofrecords. Names That Shadow Standard Library Functions or Keywords printf: Using this as a variable name will conflict with the standard output function. Variable Scopes Variable Scopes  C supports various types of variables based on their scope, storage duration, and purpose. The two types of scopes are; Local Global Local Variables are declared inside a function or block and are accessible only within that scope. Global Variables are declared outside all functions and are accessible throughout the program. Local Scope The local scope refers to the region inside a block or a function. It is the space enclosed between the { } braces. The variables declared within the local scope are called local variables. Local variables are visible in the block they are declared in and other blocks nested inside that block. Local scope is also called Block scope. Local variables have no linkage. Local Variables They are created upon entering the function and destroyed upon exiting it. For example: void function(){ int localVariable = 30; // local variable declaration printf("%d", localVariable); } Local Scope Example // C program to illustrate the scope of a printf("%d", var); variable return 0; #include } int main() // function where we try to access the var { defined in main() // Scope of this variable is within main() void func() { printf("%d", var); } function int var = 97; Global scope The global scope refers to the region outside any block or function. The variables declared in the global scope are called global variables. Global variables are visible in every part of the program. Global is also called File Scope, as the scope of an identifier starts at the beginning of the file and ends at the end of the file.  Global Variables Global variables are declared outside any function, usually at the top of the program.  They can be accessed by any function within the program. Global Scope Example int main() # include { // variable declared in global scope printf("Before change within main: "); int global = 5; display(); // global variable accessed from within a function // changing value of global void display() // variable from main function { printf("After change within main: "); printf("%d\n", global); global = 10; } display(); //main function } VARIABLE STORAGE CLASSES Storage Classes Storage classes define the memory location, lifetime, scope (visibility), and default initial value of variables.  They specify how long a variable exists in memory and how it can be accessed within a program. C provides the following four storage classes  auto  Register  Static  extern. Auto Storage Class The auto storage class in C is used to declare variables with automatic storage duration- it is the default storage class for local variables.  This means that the variable's memory is allocated when the block in which it is declared is entered, and deallocated when the block is exited. By default, all local variables inside functions are of the auto storage class, so explicitly using the auto keyword is rare in practice Auto Storage Class A variable can be declared using the auto storage class using the following syntax auto type variable_name; #include int main() { auto int num = 105; // 'auto' is optional here as it's the default for local variables printf("%d\n", num); // Output: 105 return 0; } Register Storage Class The register storage class suggests to the compiler that a particular local variable should be stored in a CPU register instead of RAM. This is intended to optimize access speed, but it is just a suggestion and not a guarantee. The register keyword can only be used for local variables. Register Storage Class Using register is only a suggestion; the compiler may ignore it based on hardware constraints or optimization decisions. Modern compilers often make their own choices about register allocation. The scope is local to the block or function where it is declared, just like auto variables. The variable exists only during the execution of the block or function in which it is declared No default initialization; contains garbage value if not explicitly initialized. Here is how a variable can be declared using the register storage class register type variable_name; Register Storage Class #include int main() { register int count; for (count = 0; count < 5; count++) { printf("%d ", count); } return 0; } Static Storage Classes The static storage class is used to maintain the value of a variable across function calls. A static variable retains its value even after the function in which it is declared finishes executing.  static variables are initialized only once, and their lifetime is the entire program runtime. The static storage class is used to extend the lifetime of a variable or function so that it persists for the entire duration of the program, rather than being created and destroyed each time its block is entered or exited Here is how a variable can be declared using the static storage class: static type variable_name; Static Storage Class Static variables are initialized only once and exist until the end of the program.  Their value is preserved between function calls, unlike auto variables, which are destroyed when the block ends. When declared inside a function or block, the variable is accessible only within that function or block, but its value persists across multiple invocations. Static variables are automatically initialized to zero (or NULL for pointers) if not explicitly initialized. Static variables are stored in a special area of memory called the data segment, not on the stack.  Functions can also be declared as static, restricting their visibility to the file in which they are defined Static Storage Class #include int main() { counter(); // Output: Count: 1 void counter() { counter(); // Output: Count: 2 static int count = 0; // This variable counter(); // Output: Count: 3 retains its value across function calls return 0; count++; } printf("Count: %d\n", count); } Extern Storage Class The extern storage class helps declare a variable that is defined in another file or elsewhere in the program. It tells the compiler that the variable exists, but its definition will be provided later. It is used for sharing variables between files. It enables sharing of global variables across multiple source files Here is how a variable can be declared using the extern storage class: extern type variable_name; External Variables  External variables (also known as global variables with external linkage) are variables that are declared outside of any function and are intended to be accessible (referenced) from multiple source files within a project. Declaring an external variable informs the compiler that a variable with a specific name and type exists and is defined in some other source file.  Declarations do not allocate storage. You can have multiple declarations of the same external variable in different source files. Extern Storage Class An extern variable can be accessed from any file that declares it with the extern keyword. The variable’s lifetime lasts during the entire duration of the program (static storage duration). The variable is visible across different files (translation units). The default initialization is Zero if the variable is not explicitly initialized. The purpose of the extern storage class is to reference a global variable or function defined in another file, without allocating new storage.  External Variables Define the variable in one source file // file1.c int globalCounter = 0; // Definition and initialization Declare the variable in other source files: In any other source file where you want to use the globalCounter variable, you need to declare it using the extern keyword // file2.c #include extern int globalCounter; // Declaration void incrementAndPrint() { globalCounter++; printf("Counter in file2: %d\n", globalCounter); }  External Variables // main.c #include extern int globalCounter; // Declaration int main() { printf("Initial counter in main: %d\n", globalCounter); incrementAndPrint(); // Function from file2.c printf("Counter in main after increment: %d\n", globalCounter); return 0; } Extern Storage Class // file1.c // file2.c #include extern int count; // Declaration of count from file1.c int count = 10; // Definition of count int main() { display(); // Output: Count: 10 void display() { return 0; printf("Count: %d\n", count); } } THE END