Lecture 4

• Lecture 4 covers C functions, C library, and preprocessors

Functions

• A function, also called a procedure, routine, or subroutine, constitutes a block of code executable with input parameters.
• Functions promote code reuse, modular program design, and library creation.
• They also enable program organization into separate, testable files.
• Functions are the basis of procedural programming.

Memory Management

• When executing a program, it is loaded into the operating system's assigned memory space.
• That space is divided into 4 segments or regions
• Text region: Holds functions.
• Data region: Holds global and static variable data.
• Stack region: Holds runtime function local variable data.
• Heap region: Holds runtime dynamically allocated memory for data storage.

Function Call Stack

• A call stack (or system stack) stores function arguments, local variables, and runtime information; it operates in stack form.
• Upon a function call, argument and local function variables are instanced within the call stack.
• The call stack's top address sets to the call's base address; a variable's relative address is compiler-assigned as an offset from this base.
• When a function completes, the stack's top address resets, popping off local variables and freeing memory for subsequent calls.
• If function f1 calls function f2, the local variables of f2 are pushed to call stack on top of f1's memory space in call stack
• Deeper function calls (f1 calls f2, f2 calls f3, etc.) increase the call stack's memory usage during runtime.

Recursive Functions

• A recursive function calls itself within its own definition.
• Example: To compute factorial n!
• There are iterative and recursive ways to implement this calculation, with different time and space complexities.
• Iterative functions have a space complexity of O(1).
• Recursive functions have a space complexity of O(n).

Passing Arguments

By Value

• When max(a, b) is called, instance space for x, y, z exists in the stack region.
• The values from "a" and "b" are copied (passed by value) to "x" and "y" respectively.
• The result of the computation x>y? x:y; is copied to z.
• The function returns the value of z to c.
• Local variables are then removed from the stack after the call is complete.

By Reference

• When *x is used it can serve as a pointer, indicating that x is being used to hold an address
• &n is the reference of n.
• When the function call add(&n, j) is made: memory is set aside for y and the address of x in stack region. The address of n is written into the stack for x. With j's value also written into memory for y.

Reference and Dereference Operators

• Unary operators: Used to get the variable address or value.
• & (reference operator): Gets the address of a variable
• * (dereference operator): Gets a value at the memory location given by the address

C Libraries

• C libraries consist of predefined macros and functions, organized into 15 header files within the C89 standard.
• C allows users to define their own libraries.
• Some standard "C" Libraries and header files include:
• stdio.h: For standard device and file input/output functions
• stdlib.h: general functions with utilities that don't fit in other headers
• string.h: functions for string operations
• time.h: functions for determining the date an time
• math.h: common math functions including logarithmic, trigonometric etc

stdio Library I/O Functions

• printf function:
  • syntax: printf(format control, list of variables);
• Allows printing the list of variable values according to the format control
• Some formatting options include specifying:
  • The number of decimal places
  • Character alignment
  • Hex values
  • Oct values

Scanf

• Reads, converts, and stores keyboard data, returning successful readings.
• Syntax: int scanf(format control, list of variable references);

Sscanf

• Reads data from a string, converts and stores them in referenced variables, and returns successful reading counts. -Syntax: int sscanf(string, format control, list of variable references);

Preprocessors

• Preprocessor directives start with #.
• They are resolved at the preprocessing stage of compilation.
• Common preprocessor directives:
  • #include: Used to include external files
    • Example #include <file> or #include "file"
  • Define and undefine macros: #define, #undef
    • Used in the form #define Pi 3.1415926 to establish macros, such as constant values.
  • Conditional compilation: #define, #undef, #ifdef, #ifndef, #if, #elif, #else, #endif
    • These are used to mark code blocks for compilation.

Lecture on C functions, libraries, and preprocessors. Focuses on function definition, memory management (text, data, stack, heap regions), and the function call stack. Explains the importance of functions for code reuse and modular design.