Typecasting and Memory Manipulation

# CHAPTER 28

Typecasting and Memory Manipulation #

1. Introduction #

2. Learning Objectives #

• Perform Implicit and Explicit Typecasting.

• Understand the dangers of downcasting.

• Use memset() to initialize memory blocks.

• Use memcpy() to copy memory at high speed.

• Use memmove() to safely handle overlapping memory.

3. Implicit Typecasting (Automatic) #

int a = 10;
float b = a; // Implicit cast from int to float. b is now 10.000000

However, converting a float to an int silently truncates the decimal.

float price = 9.99;
int dollars = price; // Implicit downcast. dollars is 9. (Warning often given).

4. Explicit Typecasting (Manual) #

int sum = 17, count = 5;
// Without casting, 17/5 = 3 (Integer division)
// With casting, (float)17 / 5 = 3.4
float average = (float) sum / count; 

5. Memory Manipulation Functions #

#### 1. memset() - Memory Set Fills a block of memory with a specific byte value. Excellent for initializing arrays or structs to 0.

Syntax: memset(pointer, value, sizeinbytes);

#include <stdio.h>
#include <string.h>

int main() {
    int arr[10];
    
    // Set all 10 integers (40 bytes) to 0
    memset(arr, 0, sizeof(arr)); 
    
    printf("%d\n", arr[5]); // Prints 0
    return 0;
}

#### 2. memcpy() - Memory Copy Copies a block of memory from a source to a destination. Much faster than using a for loop to copy an array.

Syntax: memcpy(destination, source, sizeinbytes);

int source[5] = {1, 2, 3, 4, 5};
int dest[5];

// Copies 20 bytes from source to dest
memcpy(dest, source, sizeof(source)); 

#### 3. memmove() - Memory Move (Safe Copy) If the source and destination memory blocks *overlap*, memcpy can corrupt the data. memmove detects overlap and copies the data safely (usually by using a temporary buffer).

char str[] = "abcdefgh";
// Move "abcd" forward by 2 spaces (overlapping occurs!)
memmove(str + 2, str, 4); 
// Result: "ababcdgh"

6. Casting Pointers (Advanced) #

#include <stdio.h>

int main() {
    int num = 300; 
    // 300 in binary (4 bytes): 00000000 00000000 00000001 00101100

    // Cast the int pointer to a char pointer (1 byte at a time)
    char *ptr = (char*)&num; 

    // Prints the first byte (00101100 -> 44)
    printf("First byte: %d\n", *ptr); 

    return 0;
}

7. Common Mistakes #

• Using memset for values other than 0 or -1 (with ints): memset works byte-by-byte. If you do memset(arr, 1, sizeof(arr)); on an integer array, it sets *every byte* to 1 (00000001 00000001 00000001 00000001), which equals the integer 16843009, not 1.

• Forgetting sizeof in memcpy: If you do memcpy(dest, src, 5) expecting to copy 5 integers, you only copied 5 bytes (1 integer and a quarter). It must be 5 * sizeof(int).

8. Exercises #

1. 1. Define a large struct and initialize all its members to 0 using a single memset call.

1. 2. Prove that integer division truncates decimals by writing a program that divides two ints, first without casting, then with (float) casting.

9. MCQ Quiz with Answers #

10. Interview Questions #

• Q: Explain the exact difference between memcpy and memmove.

• Q: Why is casting void* essential in C?

• Q: What is "Endianness" and how does casting an int* to a char* help determine if a machine is Little Endian or Big Endian?

11. Summary #

12. Next Chapter Recommendation #