c
examples
examples.cš§c
/**
* 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;
}