Definition: A pointer is a special variable that stores the memory address of another variable rather than a data value. It points to the location where the data is stored in memory.

Operators:

1. Address-of Operator ($\&`):

   • It is a unary operator that returns the memory address of a variable.
   • Example: &x gives the address of variable x.

2. *Indirection (or Dereference) Operator ($`):**

   • It is a unary operator used to access the value stored at the address a pointer is holding.
   • Example: *ptr gives the value stored at the address contained in ptr.

Example:
c
int x = 10;
int *ptr;
ptr = &x; // ptr holds address of x

printf("Address of x: %p", ptr);
printf("Value of x: %d", *ptr); // Dereferencing

Generic (Void) Pointer:

• A void pointer is a pointer that has no associated data type. It is declared using the keyword void.
• It can hold the address of any type of variable (int, char, float, etc.).
• Syntax: void *ptr;

Dereferencing:

• A void pointer cannot be dereferenced directly because the compiler does not know the size of the data type it points to.
• It must be typecasted to the appropriate data type pointer before dereferencing.

Example:
c
int a = 10;
void ptr = &a;
printf("%d", (int)ptr); // Typecasting to int

1. Wild Pointer:

• Definition: A pointer that has been declared but not initialized to point to any valid memory location is called a wild pointer. It points to a random (garbage) memory location.
• Example:
  c
  int p; // Wild pointer
  p = 10; // Risky, might crash the program

2. Dangling Pointer:

• Definition: A pointer that points to a memory location that has been deleted (freed) or has gone out of scope.
• Causes:
  • Deallocating memory using free().
  • Function returning the address of a local variable.
• Example:
  c
  int ptr = (int )malloc(sizeof(int));
  free(ptr);
  // ptr is now a dangling pointer

Pointer Arithmetic:
Unlike normal arithmetic, pointer arithmetic depends on the data type the pointer points to. When we perform arithmetic operations, the address changes based on the size of the data type.

Rules:

1. Increment/Addition: When we add an integer to a pointer, the address increases by .
   • Formula:
2. Decrement/Subtraction: When we subtract , the address decreases similarly.
3. Subtraction of two pointers: Returns the number of elements between them (valid only if both point to the same array).

Example:
Assuming int is 4 bytes and ptr is at address 1000.
c
int ptr = 1000;
ptr = ptr + 2;
// New Address = 1000 + (2 4) = 1008

Call by Reference:
In this method, the address of the actual arguments is passed to the formal parameters. This allows the function to modify the actual variables in the calling function, as the function operates directly on memory addresses.

C Program to Swap Two Numbers:
c

include <stdio.h>

void swap(int x, int y) {
int temp;
temp = x; // Store value at address x in temp
x = y; // Copy value at address y to address x
y = temp; // Copy temp to address y
}

int main() {
int a = 10, b = 20;
printf("Before: a=%d, b=%d
", a, b);

swap(&a, &b); // Passing addresses

printf("After: a=%d, b=%d

", a, b);
return 0;
}

Output:
Before: a=10, b=20
After: a=20, b=10

Relationship:

• The name of an array represents the base address (address of the first element) of the array.
• It acts like a constant pointer.
• If arr is an array, arr is equivalent to &arr[0].

Accessing Elements:

• Array Subscript Notation: arr[i]
• Pointer Notation: *(arr + i)

Explanation:

• arr points to index 0.
• arr + 1 points to index 1.
• arr + i points to index .
• *(arr + i) retrieves the value at that address.

Example:
c
int arr[] = {10, 20, 30};
int ptr = arr;
printf("%d", (ptr + 1)); // Prints 20

Null Pointer:

• A null pointer is a pointer that points to nothing. It is assigned the value NULL (defined in <stdio.h> or <stddef.h>), which typically represents memory address 0.
• Syntax: int *ptr = NULL;

Difference from Uninitialized Pointer:

• Uninitialized (Wild): Contains a garbage address. Dereferencing it causes undefined behavior or crashes.
• Null: Explicitly states it points nowhere. It is safe to check against (e.g., if (ptr != NULL)).

Utility:

1. To initialize a pointer when a valid address isn't available yet.
2. To check if dynamic memory allocation (malloc) was successful.
3. To mark the end of data structures like linked lists.

Comparison:

Dynamic Memory Functions (defined in <stdlib.h>):

1. malloc(): Allocates a block of memory.
2. calloc(): Allocates contiguous blocks and initializes to zero.
3. realloc(): Resizes previously allocated memory.
4. free(): Deallocates memory.

1. malloc() (Memory Allocation):

• Allocates a single large block of memory.
• Contains garbage values initially.
• Syntax: void* malloc(size_t size);
• Example: ptr = (int*)malloc(5 * sizeof(int));

2. calloc() (Contiguous Allocation):

• Allocates multiple blocks of memory of the same size.
• Initializes all bytes to zero.
• Syntax: void* calloc(size_t n, size_t size);
• Example: ptr = (int*)calloc(5, sizeof(int));

Differences:

• Initialization: malloc leaves garbage values; calloc initializes to zero.
• Arguments: malloc takes 1 argument (total size); calloc takes 2 (number of elements, size of each).

realloc():

• Used to change the size of the memory block pointed to by a previously allocated pointer (via malloc/calloc).
• Syntax: void *realloc(void *ptr, size_t new_size);
• It preserves the existing data while expanding or shrinking.

free():

• Releases the dynamically allocated memory back to the heap so it can be reused.
• Syntax: void free(void *ptr);
• Crucial to prevent memory leaks.

Memory Leak:

• Occurs when programmers create memory in the heap and forget to delete it (using free()).
• The memory remains occupied even though it's no longer needed, eventually exhausting available memory and causing system slowdowns or crashes.

Definition:
In C, a string is a one-dimensional array of characters terminated by a null character (\0).

Initialization Methods:

1. String Literal: char str[] = "Hello"; (Compiler adds \0 automatically).
2. Character Array: char str[] = {'H', 'e', 'l', 'l', 'o', '\0'}; (Must explicitly add \0).
3. Pointer: char *str = "Hello"; (Stored in read-only memory).

Significance of Null Character (\0):

• It acts as a sentinel value indicating the end of the string.
• Functions like printf, strlen, and strcpy rely on \0 to know where to stop processing.
• Without it, functions would read adjacent memory until a crash occurs.

1. scanf("%s", str):

• Reads a string from input.
• Limitation: It terminates reading at the first whitespace (space, tab, newline). It cannot read multi-word strings like "Hello World".

2. gets(str) (Deprecated):

• Reads a line including spaces until a newline is found.
• Risk: Does not check array bounds, leading to buffer overflow attacks. Removed in C11.

3. fgets(str, size, stdin) (Recommended):

• Reads a line including spaces.
• Safety: Takes the maximum size as an argument, preventing buffer overflow.
• Note: It may include the newline character at the end.

Comparison:
scanf is for single words; fgets is safe for sentences.

Internal Handling:
C treats characters as integers based on their ASCII values. For example, 'A' is 65, 'a' is 97, '0' is 48.

Character Arithmetic Operations:
Since they are stored as integers, we can perform arithmetic on them.

1. Case Conversion:
   • Lowercase to Uppercase: 'a' - 32 -> 'A'
   • Uppercase to Lowercase: 'A' + 32 -> 'a'
2. Digit Character to Integer:
   • '5' - '0' results in the integer 5.
3. Next Character:
   • 'A' + 1 results in 'B'.

Example:
c
char c = 'A';
printf("%d", c); // Prints 65
printf("%c", c + 1); // Prints 'B'

Logic:

1. Initialize a counter variable to 0.
2. Loop through the character array.
3. Continue the loop as long as the current character is not the null terminator (\0).
4. Increment the counter in each iteration.
5. Return the counter.

Code:
c

include <stdio.h>

int stringLength(char *str) {
int length = 0;
// Iterate until null terminator is found
while (str[length] != '\0') {
length++;
}
return length;
}

int main() {
char s[] = "Computer";
printf("Length: %d", stringLength(s));
return 0;
}

strcpy(dest, src):
It copies the content of the source string (src) (including the null terminator) to the destination buffer (dest). The destination array must be large enough to hold the source string.

Custom Implementation using Pointers:

c

include <stdio.h>

void myStrcpy(char dest, char src) {
// Loop while the value pointed by src is not null
while (src != '\0') {
dest = src; // Copy char from src to dest
src++; // Increment src pointer
dest++; // Increment dest pointer
}
dest = '\0'; // Explicitly append null terminator
}

int main() {
char source[] = "Source";
char destination[20];
myStrcpy(destination, source);
printf("Copied string: %s", destination);
return 0;
}

Logic:

1. Traverse the first string (destination) to find the null terminator (\0).
2. Once the end of the first string is reached, start copying characters from the second string (source) to the destination.
3. After copying the source, append \0 to the end.

Code:
c

include <stdio.h>

void myStrcat(char dest, char src) {
// 1. Move dest pointer to the end of the string
while (*dest != '\0') {
dest++;
}

// 2. Copy src to end of dest
while (*src != '\0') {
    *dest = *src;
    dest++;
    src++;
}

// 3. Null terminate
*dest = '\0';

}

int main() {
char str1[50] = "Hello ";
char str2[] = "World";
myStrcat(str1, str2);
printf("%s", str1); // Output: Hello World
return 0;
}

Logic:
strcmp(str1, str2) compares two strings character by character based on their ASCII values.

Process:

1. It iterates through both strings simultaneously.
2. If characters at the current index match, it moves to the next.
3. The loop stops when a mismatch is found or \0 is reached.

Return Values:

• 0: If strings are identical (str1 == str2).
• Positive (> 0): If the ASCII value of the first unmatched character in str1 is greater than in str2 (e.g., "Banana" vs "Apple").
• Negative (< 0): If the ASCII value in str1 is less than in str2 (e.g., "Apple" vs "Banana").

Equation:

Definition:
A pointer to a pointer is a variable that stores the address of another pointer. It is used in dynamic memory allocation for multi-dimensional arrays or changing the address stored in a pointer within a function.

Declaration:
type **ptr_name;

Visual:
Variable Pointer 1 Pointer 2

Example:
c
int a = 10;
int *p1 = &a; // p1 holds address of a
int **p2 = &p1; // p2 holds address of p1

printf("%d", **p2);
// Dereference p2 -> gets p1.
// Dereference p1 -> gets a (10).

1. Array of Pointers:

• An array where each element is a pointer.
• Often used to store an array of strings.
• Syntax: int *arr[5]; (Array of 5 integer pointers).
• Usage: char *names[] = {"John", "Doe"};

2. Pointer to an Array:

• A single pointer that points to a whole array, not just the first element type.
• Syntax: int (*ptr)[5]; (Pointer to an array of 5 integers).
• Usage: Used when passing 2D arrays to functions.

Key Syntax Difference:

• *arr[5] vs (*ptr)[5] (Parentheses make the difference).

1. strrev(str):

   • Reverses the given string in place.
   • Note: Non-standard function (available in some compilers like Turbo C, but not standard GCC).

2. strlwr(str):

   • Converts all uppercase characters in the string to lowercase.
   • Note: Non-standard.

3. strupr(str):

   • Converts all lowercase characters in the string to uppercase.
   • Note: Non-standard.

4. strncpy(dest, src, n):

   • Standard library function.
   • Copies exactly n characters from src to dest.
   • Safer than strcpy as it prevents buffer overflows if n is chosen correctly. If src is shorter than n, the rest is padded with null bytes.