String Basics

/**
 * String Basics - Examples
 * 
 * This file demonstrates fundamental string concepts in C.
 * 
 * Compile: gcc examples.c -o examples
 * Run: ./examples
 */

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

/* ============================================================
 * EXAMPLE 1: String Declaration Methods
 * ============================================================ */

void example1_declaration(void) {
    printf("=== EXAMPLE 1: String Declaration Methods ===\n\n");
    
    // Method 1: Character array with size
    char str1[20] = "Hello";
    printf("Method 1 - char str1[20] = \"Hello\";\n");
    printf("  Value: \"%s\"\n", str1);
    printf("  strlen: %zu\n", strlen(str1));
    printf("  sizeof: %zu\n\n", sizeof(str1));
    
    // Method 2: Auto-sized array
    char str2[] = "Hello";
    printf("Method 2 - char str2[] = \"Hello\";\n");
    printf("  Value: \"%s\"\n", str2);
    printf("  strlen: %zu\n", strlen(str2));
    printf("  sizeof: %zu (auto-sized to fit)\n\n", sizeof(str2));
    
    // Method 3: Pointer to literal
    const char *str3 = "Hello";
    printf("Method 3 - const char *str3 = \"Hello\";\n");
    printf("  Value: \"%s\"\n", str3);
    printf("  strlen: %zu\n", strlen(str3));
    printf("  sizeof(str3): %zu (pointer size)\n\n", sizeof(str3));
    
    // Method 4: Character by character
    char str4[6];
    str4[0] = 'H';
    str4[1] = 'e';
    str4[2] = 'l';
    str4[3] = 'l';
    str4[4] = 'o';
    str4[5] = '\0';
    printf("Method 4 - Character by character\n");
    printf("  Value: \"%s\"\n", str4);
    printf("  strlen: %zu\n\n", strlen(str4));
    
    // Method 5: Brace initialization
    char str5[] = {'H', 'e', 'l', 'l', 'o', '\0'};
    printf("Method 5 - char str5[] = {'H','e','l','l','o','\\0'};\n");
    printf("  Value: \"%s\"\n", str5);
    printf("  strlen: %zu\n", strlen(str5));
}


/* ============================================================
 * EXAMPLE 2: The Null Terminator
 * ============================================================ */

void example2_null_terminator(void) {
    printf("\n=== EXAMPLE 2: The Null Terminator ===\n\n");
    
    char str[] = "Hello";
    
    printf("String: \"%s\"\n\n", str);
    printf("Memory contents:\n");
    printf("Index  Char  ASCII\n");
    printf("─────────────────────\n");
    
    for (int i = 0; i <= 5; i++) {
        if (str[i] == '\0') {
            printf("  [%d]  '\\0'   %d (null terminator)\n", i, str[i]);
        } else {
            printf("  [%d]   '%c'   %d\n", i, str[i], str[i]);
        }
    }
    
    printf("\nKey facts about '\\0':\n");
    printf("  '\\0' == 0?    %s\n", ('\0' == 0) ? "true" : "false");
    printf("  '\\0' == '0'?  %s (\\0 is ASCII 0, '0' is ASCII 48)\n", 
           ('\0' == '0') ? "true" : "false");
}


/* ============================================================
 * EXAMPLE 3: strlen vs sizeof
 * ============================================================ */

void example3_strlen_vs_sizeof(void) {
    printf("\n=== EXAMPLE 3: strlen vs sizeof ===\n\n");
    
    char arr1[100] = "Hello";
    char arr2[] = "Hello";
    const char *ptr = "Hello";
    
    printf("Declaration              strlen   sizeof\n");
    printf("───────────────────────────────────────────\n");
    printf("char arr1[100] = \"Hello\"   %-8zu %zu\n", 
           strlen(arr1), sizeof(arr1));
    printf("char arr2[] = \"Hello\"      %-8zu %zu\n", 
           strlen(arr2), sizeof(arr2));
    printf("const char *ptr = \"Hello\"  %-8zu %zu (pointer size)\n", 
           strlen(ptr), sizeof(ptr));
    
    printf("\nKey differences:\n");
    printf("  strlen() - Counts characters until '\\0'\n");
    printf("  sizeof() - Returns total allocated size\n");
}


/* ============================================================
 * EXAMPLE 4: Modifiable vs Read-Only Strings
 * ============================================================ */

void example4_modifiable(void) {
    printf("\n=== EXAMPLE 4: Modifiable vs Read-Only ===\n\n");
    
    // Modifiable (array)
    char arr[] = "Hello";
    printf("char arr[] = \"Hello\" (modifiable):\n");
    printf("  Before: \"%s\"\n", arr);
    arr[0] = 'J';  // Safe - modifying stack memory
    printf("  After arr[0] = 'J': \"%s\"\n\n", arr);
    
    // Read-only (pointer to literal)
    const char *ptr = "Hello";
    printf("const char *ptr = \"Hello\" (read-only):\n");
    printf("  Value: \"%s\"\n", ptr);
    printf("  Modifying ptr[0] = 'J' would cause UNDEFINED BEHAVIOR!\n");
    printf("  The 'const' keyword helps prevent this mistake.\n");
}


/* ============================================================
 * EXAMPLE 5: String Output Methods
 * ============================================================ */

void example5_output(void) {
    printf("\n=== EXAMPLE 5: String Output Methods ===\n\n");
    
    char str[] = "Hello, World!";
    
    printf("Using printf with different format specifiers:\n");
    printf("  %%s:     |%s|\n", str);
    printf("  %%.5s:   |%.5s| (first 5 chars)\n", str);
    printf("  %%20s:   |%20s| (right-aligned)\n", str);
    printf("  %%-20s:  |%-20s| (left-aligned)\n", str);
    printf("  %%20.5s: |%20.5s| (5 chars, right-aligned)\n\n", str);
    
    printf("Using puts():\n  ");
    puts(str);  // Automatically adds newline
    
    printf("\nUsing putchar() (character by character):\n  ");
    for (int i = 0; str[i]; i++) {
        putchar(str[i]);
    }
    putchar('\n');
}


/* ============================================================
 * EXAMPLE 6: Accessing Characters
 * ============================================================ */

void example6_access(void) {
    printf("\n=== EXAMPLE 6: Accessing Characters ===\n\n");
    
    char str[] = "Hello";
    
    printf("String: \"%s\"\n\n", str);
    
    // Array indexing
    printf("Array indexing:\n");
    printf("  str[0] = '%c'\n", str[0]);
    printf("  str[4] = '%c'\n", str[4]);
    printf("  str[5] = '\\0' (value: %d)\n\n", str[5]);
    
    // Pointer arithmetic
    char *ptr = str;
    printf("Pointer arithmetic:\n");
    printf("  *ptr       = '%c'\n", *ptr);
    printf("  *(ptr + 1) = '%c'\n", *(ptr + 1));
    printf("  *(ptr + 4) = '%c'\n", *(ptr + 4));
}


/* ============================================================
 * EXAMPLE 7: Iterating Through Strings
 * ============================================================ */

void example7_iteration(void) {
    printf("\n=== EXAMPLE 7: Iterating Through Strings ===\n\n");
    
    char str[] = "Hello";
    
    // Method 1: Index with length
    printf("Method 1 - Index with strlen:\n  ");
    size_t len = strlen(str);
    for (size_t i = 0; i < len; i++) {
        printf("%c ", str[i]);
    }
    printf("\n\n");
    
    // Method 2: Index until null
    printf("Method 2 - Index until null:\n  ");
    for (int i = 0; str[i] != '\0'; i++) {
        printf("%c ", str[i]);
    }
    printf("\n\n");
    
    // Method 3: Pointer-based
    printf("Method 3 - Pointer:\n  ");
    char *ptr = str;
    while (*ptr != '\0') {
        printf("%c ", *ptr);
        ptr++;
    }
    printf("\n\n");
    
    // Method 4: Compact pointer
    printf("Method 4 - Compact pointer:\n  ");
    for (char *p = str; *p; p++) {
        printf("%c ", *p);
    }
    printf("\n");
}


/* ============================================================
 * EXAMPLE 8: String Length Calculation
 * ============================================================ */

// Custom strlen implementations
size_t my_strlen_index(const char *str) {
    size_t len = 0;
    while (str[len] != '\0') {
        len++;
    }
    return len;
}

size_t my_strlen_pointer(const char *str) {
    const char *s = str;
    while (*s) {
        s++;
    }
    return s - str;
}

void example8_length(void) {
    printf("\n=== EXAMPLE 8: String Length ===\n\n");
    
    char str[] = "Hello, World!";
    
    printf("String: \"%s\"\n\n", str);
    printf("strlen(str):        %zu\n", strlen(str));
    printf("my_strlen_index:    %zu\n", my_strlen_index(str));
    printf("my_strlen_pointer:  %zu\n", my_strlen_pointer(str));
    
    printf("\nEmpty string \"\":\n");
    printf("  strlen: %zu\n", strlen(""));
    
    printf("\nString with spaces \"Hi There\":\n");
    printf("  strlen: %zu (spaces count!)\n", strlen("Hi There"));
}


/* ============================================================
 * EXAMPLE 9: Escape Sequences
 * ============================================================ */

void example9_escape(void) {
    printf("\n=== EXAMPLE 9: Escape Sequences ===\n\n");
    
    printf("Common escape sequences:\n\n");
    
    printf("\\n (newline):\n");
    printf("  Line 1\n  Line 2\n\n");
    
    printf("\\t (tab):\n");
    printf("  Col1\tCol2\tCol3\n\n");
    
    printf("\\\\ (backslash):\n");
    printf("  C:\\Users\\Name\n\n");
    
    printf("\\\" (double quote):\n");
    printf("  She said \"Hello\"\n\n");
    
    printf("\\' (single quote):\n");
    printf("  It\\'s working\n\n");
    
    printf("\\0 (null character):\n");
    char test[] = "Hello\0World";
    printf("  \"Hello\\0World\" prints as: \"%s\" (stops at null)\n", test);
}


/* ============================================================
 * EXAMPLE 10: String Concatenation at Compile Time
 * ============================================================ */

void example10_concatenation(void) {
    printf("\n=== EXAMPLE 10: Compile-Time Concatenation ===\n\n");
    
    // Adjacent string literals are concatenated
    const char *msg = "This is a "
                      "very long "
                      "message "
                      "split across "
                      "multiple lines.";
    
    printf("Adjacent string literals:\n");
    printf("  const char *msg = \"This is a \"\n");
    printf("                    \"very long \"\n");
    printf("                    \"message\";\n\n");
    printf("Result: \"%s\"\n", msg);
}


/* ============================================================
 * EXAMPLE 11: Common String Mistakes
 * ============================================================ */

void example11_mistakes(void) {
    printf("\n=== EXAMPLE 11: Common Mistakes ===\n\n");
    
    // Mistake 1: Comparing with ==
    char str1[] = "Hello";
    char str2[] = "Hello";
    
    printf("Mistake 1: Comparing strings with ==\n");
    printf("  char str1[] = \"Hello\";\n");
    printf("  char str2[] = \"Hello\";\n");
    printf("  str1 == str2?  %s (compares addresses!)\n", 
           str1 == str2 ? "true" : "false");
    printf("  strcmp(str1, str2) == 0?  %s (correct way)\n\n",
           strcmp(str1, str2) == 0 ? "true" : "false");
    
    // Mistake 2: Forgetting null terminator
    printf("Mistake 2: Forgetting null terminator\n");
    printf("  char arr[] = {'H','i'}; // NOT a string!\n");
    printf("  char str[] = {'H','i','\\0'}; // IS a string\n\n");
    
    // Mistake 3: Buffer too small
    printf("Mistake 3: Buffer too small\n");
    printf("  char str[5] = \"Hello\"; // No room for \\0!\n");
    printf("  char str[6] = \"Hello\"; // Correct\n\n");
    
    // Mistake 4: Direct assignment
    printf("Mistake 4: Cannot assign strings with =\n");
    printf("  char str[20];\n");
    printf("  str = \"Hello\";  // ERROR! Use strcpy instead\n");
}


/* ============================================================
 * EXAMPLE 12: Empty vs Null String
 * ============================================================ */

void example12_empty_null(void) {
    printf("\n=== EXAMPLE 12: Empty vs Null String ===\n\n");
    
    // Empty string
    char empty[] = "";
    printf("Empty string: char empty[] = \"\";\n");
    printf("  strlen(empty): %zu\n", strlen(empty));
    printf("  empty[0]: %d (it's just \\0)\n\n", empty[0]);
    
    // NULL pointer
    char *null_ptr = NULL;
    printf("NULL pointer: char *null_ptr = NULL;\n");
    printf("  null_ptr: %p\n", (void *)null_ptr);
    printf("  WARNING: strlen(null_ptr) would crash!\n\n");
    
    // Checking for both
    printf("Safe string check pattern:\n");
    printf("  if (str != NULL && str[0] != '\\0') {\n");
    printf("      // String is not null and not empty\n");
    printf("  }\n");
}


/* ============================================================
 * EXAMPLE 13: Memory Layout Visualization
 * ============================================================ */

void example13_memory(void) {
    printf("\n=== EXAMPLE 13: Memory Layout ===\n\n");
    
    char str[] = "Hi";
    
    printf("char str[] = \"Hi\";\n\n");
    printf("Memory layout:\n");
    printf("┌───────┬───────┬───────┐\n");
    printf("│  'H'  │  'i'  │ '\\0'  │\n");
    printf("│  72   │  105  │   0   │ (ASCII values)\n");
    printf("└───────┴───────┴───────┘\n");
    printf("  [0]     [1]     [2]\n\n");
    
    printf("Actual addresses:\n");
    for (int i = 0; i <= 2; i++) {
        printf("  str[%d] at %p = ", i, (void *)&str[i]);
        if (str[i] == '\0') {
            printf("'\\0'\n");
        } else {
            printf("'%c'\n", str[i]);
        }
    }
}


/* ============================================================
 * MAIN FUNCTION
 * ============================================================ */

int main() {
    printf("╔═══════════════════════════════════════════════════════════════╗\n");
    printf("║              STRING BASICS - EXAMPLES                         ║\n");
    printf("╚═══════════════════════════════════════════════════════════════╝\n\n");
    
    example1_declaration();
    example2_null_terminator();
    example3_strlen_vs_sizeof();
    example4_modifiable();
    example5_output();
    example6_access();
    example7_iteration();
    example8_length();
    example9_escape();
    example10_concatenation();
    example11_mistakes();
    example12_empty_null();
    example13_memory();
    
    printf("\n═══════════════════════════════════════════════════════════════\n");
    printf("All examples completed!\n");
    printf("═══════════════════════════════════════════════════════════════\n");
    
    return 0;
}