C Programming Week 3

C Programming - Week 3: Functions and Arrays

• Functionalizing a Program:

  • Motivation: Divide-and-conquer (breaking problems into smaller functions), software reusability (reusing functions), abstraction (hiding complex details), single responsibility principle (each function has one clear task). Decomposition (breaking down functions into smaller ones) is a key technique for better organization.

• Declaring and Defining Functions:

  • Function Prototype (declaration): Specifies a function's name, return type, and parameters without the implementation. Used to tell the compiler about this function before it's defined.
  • Function Definition: Contains the actual implementation of the function.
  • Functions are defined once and can be used multiple times (called) in a program. This modularity helps organize code.

• Calling and Returning from Functions:

  • Functions are invoked using a function call.
  • A function call requests the function to perform a task.
  • The function executes and can return a value to the calling function.

• Putting it all together

  • Include header files to declare functions.
  • Implement functions based on the declarations.

• Function Prototypes – Mixed Type Expressions

  • Arithmetic Conversions: type promotion rules in mixed-type expressions
    • long double operands > double > float > integers
  • Integer promotion: char and short values are usually promoted to int before evaluation.

• Mixed Type Expressions

  • Summary of print and scanf conversion specifications for different data types. (Lists all data types: long double, double, float, long long int, long int, etc., with relevant printf and scanf specifiers.)

• Best Practices:

  • Include function prototypes.
  • Use header files.
  • Functions with global scope are used across multiple files.
  • Functions with local scope are only relevant within a specific function.

• Arrays:

  • Fundamental data structure to store a collection of elements of the same data type. Used to store collections of data.

• Declaration and Initialization of Arrays:

  • Declare arrays by specifying element type and the number of elements.
  • Initialize arrays at declaration. Initializing with fewer values sets the rests as zero.

• Defining and Allocating Space for Arrays:

  • When declaring an array, space is reserved for the identifier and elements.
  • The size of pointer depends on the architecture.
  • Array elements get their allocated space as well.

• Variable Length Arrays (VLAs):

  • VLAs are declared using a variable to determine the array's size.
  • Variable-length arrays are declared using a variable to represent size
  • Can be initialized similarly to fixed-size arrays.

• Benefits and Limitations of VLAs:

  • Benefits: Dynamic sizing, Memory Efficiency, Flexibility.
  • Limitations: Arrays are allocated on the stack, so they cause stack overflow if too big. The size is not checked at compile time so runtime checks are necessary.

• Example of VLAs

• Character Arrays Initialization

  • Characters arrays can be initialized with individual constants. String literals automatically add a null character '\0' at the end.
  • Reading input with scanf: The input should be limited to avoid buffer overflow
  • Reading input with fgets: A safer alternative to scanf for strings that may contain spaces or newlines.
  • Printing strings with printf: The %s format specifier is used for strings in printf.

• Handling Special Characters:

  • scanf stops reading at whitespace (space, tab, newline).
  • Use fgets for reading strings including white spaces. fgets is usually preferred when input might contain spaces and new lines.

• Multi-Dimensional Arrays:

  • Multi-dimensional arrays are used to create arrays of arrays. Used to represent tables or matrices of data. Example shown.

• Array Identifiers:

  • A single identifier holds the starting memory address where the data is stored. Example presented demonstrating how the memory is allocated in memory (address and value).

• Two-Dimensional Arrays

  • Declaring, storing, and accessing data in 2D arrays. Shows how to store data in 2D and get the address and its value in memory using examples

• Defining vs. Declaring 2-D Arrays

  • Difference in defining and declaring two-dimensional arrays.

• Memory Concepts:

  • Every variable has a name, a type, value, and a location in memory.
  • When a value is placed in a memory location, it replaces the existing value. Locales are not necessarily adjacent in memory. Example illustrated..

• Stack:

  • Purpose: Static memory allocation (local variables, function parameters, function calls).
  • Allocation: Automatic allocation and deallocation as functions are called/returned.
  • Characteristics: Fixed size determined during compile time ,Fast access (push/pop), Scope and lifetime limited to function duration (destroyed when returned).
  • Limitations: Size limitation : deep or large local variables and recursion can lead to overflow.

• Heap:

  • Purpose: Dynamic memory allocation; memory allocated runtime.
  • Allocation: use functions like malloc, calloc, realloc, or free. Memory must be explicitly allocated and deallocated.
  • Characteristics: Variable size, Manual management (must allocate and free), Slower access, Scope/Lifetime: accessible from anywhere in the program (until explicitly freed)
  • Advantages: dynamic sizing, lifetime control.

• Disadvantages of Heap:

  • Manual management, Performance overhead (slower than stack) ,improper management leads to memory leaks or undefined behavior.