Call by Value

A copy of the actual argument's value is passed to the formal parameter.
Changes made to the formal parameter inside the function do not affect the original actual argument.
Used when the function does not need to modify the original variable.

void swap(int x, int y) {
  int temp = x;
  x = y;
  y = temp;
}
int main() {
  int a = 10, b = 20;
  swap(a, b); // a and b remain 10, 20
}

Call by Reference (using Pointers)

The address of the actual argument is passed to the formal parameter (which is a pointer).
Changes made to the value at the address pointed to by the formal parameter will affect the original actual argument.
Used when the function needs to modify the original variable(s).

void swap(int *x, int *y) {
  int temp = *x;
  *x = *y;
  *y = temp;
}
int main() {
  int a = 10, b = 20;
  swap(&a, &b); // a becomes 20, b becomes 10
}

6. Recursion

Recursion is a programming technique where a function calls itself directly or indirectly to solve a problem. It involves a base case (termination condition) and a recursive step.

Example Program: Factorial using Recursion

#include <stdio.h>
long int factorial(int n) {
  if (n >= 1)
    return n * factorial(n - 1); // Recursive step
  else
    return 1; // Base case
}
int main() {
  int num = 5;
  printf("Factorial of %d = %ld\n", num, factorial(num));
  return 0;
}

7. Dynamic Memory Allocation

Dynamic memory allocation allows a program to request memory space during runtime. This is useful when the exact memory requirement is not known at compile time. Functions are available in <stdlib.h>.

malloc(): Allocates a block of memory of specified size. Returns a void* pointer to the beginning of the block, or NULL if allocation fails. The allocated memory contains garbage values.
ptr = (castType*) malloc(sizeInBytes);
calloc(): Allocates a block of memory and initializes all bytes to zero.
ptr = (castType*) calloc(numElements, elementSize);
realloc(): Changes the size of the memory block pointed to by ptr.
ptr = (castType*) realloc(ptr, newSizeInBytes);
free(): Deallocates the memory previously allocated by malloc(), calloc(), or realloc().
free(ptr);

Example: Dynamic Array

#include <stdio.h>
#include <stdlib.h>
int main() {
  int *arr;
  int n = 5;
  // Allocate memory for 5 integers
  arr = (int*) malloc(n * sizeof(int));
  if (arr == NULL) {
    printf("Memory allocation failed!\n");
    return 1;
  }
  // Initialize and print
  for (int i = 0; i < n; i++) {
    arr[i] = i + 1;
    printf("%d ", arr[i]);
  }
  printf("\n");
  free(arr); // Deallocate memory
  return 0;
}

8. Strings & String Processing (Library Functions)

In C, a string is an array of characters terminated by a null character ('\0').

Declaration: char str[] = "Hello"; or char str[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

Common String Library Functions (from `<string.h>`):

strlen(str): Returns the length of the string (number of characters before '\0').
strcpy(dest, src): Copies the src string to dest.
strncpy(dest, src, n): Copies at most n characters from src to dest.