c
examples
examples.cš§c
/**
* Pointers and Arrays - Examples
*
* This file demonstrates the relationship between pointers and arrays.
*
* Compile: gcc examples.c -o examples
* Run: ./examples
*/
#include <stdio.h>
#include <stdlib.h>
/* ============================================================
* EXAMPLE 1: Array Name as Pointer
* ============================================================ */
void example1_array_as_pointer(void) {
printf("=== EXAMPLE 1: Array Name as Pointer ===\n\n");
int arr[5] = {10, 20, 30, 40, 50};
printf("Array: {10, 20, 30, 40, 50}\n\n");
printf("Address comparisons:\n");
printf(" arr = %p\n", (void*)arr);
printf(" &arr[0] = %p\n", (void*)&arr[0]);
printf(" arr == &arr[0]? %s\n\n", (arr == &arr[0]) ? "Yes" : "No");
printf("Value access:\n");
printf(" *arr = %d (first element)\n", *arr);
printf(" arr[0] = %d (same value)\n", arr[0]);
// Using array name as pointer
int *ptr = arr; // No & needed!
printf("\n int *ptr = arr; (no & needed)\n");
printf(" *ptr = %d\n", *ptr);
}
/* ============================================================
* EXAMPLE 2: Pointer Arithmetic Basics
* ============================================================ */
void example2_pointer_arithmetic(void) {
printf("\n=== EXAMPLE 2: Pointer Arithmetic ===\n\n");
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr;
printf("Array: {10, 20, 30, 40, 50}\n");
printf("Base address (ptr): %p\n\n", (void*)ptr);
printf("Expression Address Value\n");
printf("āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā\n");
for (int i = 0; i < 5; i++) {
printf("ptr + %-8d %p %d\n",
i, (void*)(ptr + i), *(ptr + i));
}
printf("\nAddress difference: %ld bytes per step\n",
(long)((char*)(ptr + 1) - (char*)ptr));
printf("This equals sizeof(int) = %zu\n", sizeof(int));
}
/* ============================================================
* EXAMPLE 3: Four Ways to Access Array Elements
* ============================================================ */
void example3_access_methods(void) {
printf("\n=== EXAMPLE 3: Four Ways to Access Elements ===\n\n");
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr;
printf("Accessing arr[2] (value = 30):\n\n");
printf("Method 1: arr[2] = %d\n", arr[2]);
printf("Method 2: *(arr + 2) = %d\n", *(arr + 2));
printf("Method 3: ptr[2] = %d\n", ptr[2]);
printf("Method 4: *(ptr + 2) = %d\n", *(ptr + 2));
printf("\nBonus (valid but confusing):\n");
printf("Method 5: 2[arr] = %d\n", 2[arr]); // Works!
printf("\nAll five methods produce the same result!\n");
}
/* ============================================================
* EXAMPLE 4: Traversing Array with Pointers
* ============================================================ */
void example4_traversal(void) {
printf("\n=== EXAMPLE 4: Traversing with Pointers ===\n\n");
int arr[5] = {10, 20, 30, 40, 50};
printf("Array: {10, 20, 30, 40, 50}\n\n");
// Method 1: Index variable
printf("Method 1 (ptr + i): ");
int *ptr = arr;
for (int i = 0; i < 5; i++) {
printf("%d ", *(ptr + i));
}
printf("\n");
// Method 2: Incrementing pointer
printf("Method 2 (*ptr++): ");
ptr = arr;
for (int i = 0; i < 5; i++) {
printf("%d ", *ptr++);
}
printf("\n");
// Method 3: Pointer comparison
printf("Method 3 (p < end): ");
for (int *p = arr; p < arr + 5; p++) {
printf("%d ", *p);
}
printf("\n");
// Method 4: While loop with pointer
printf("Method 4 (while): ");
ptr = arr;
int *end = arr + 5;
while (ptr < end) {
printf("%d ", *ptr);
ptr++;
}
printf("\n");
}
/* ============================================================
* EXAMPLE 5: sizeof Difference
* ============================================================ */
void example5_sizeof(void) {
printf("\n=== EXAMPLE 5: sizeof Difference ===\n\n");
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr;
printf("int arr[5]:\n");
printf(" sizeof(arr) = %zu bytes (total array size)\n", sizeof(arr));
printf(" sizeof(arr[0]) = %zu bytes (one element)\n", sizeof(arr[0]));
printf(" Number of elements = %zu\n\n", sizeof(arr) / sizeof(arr[0]));
printf("int *ptr = arr:\n");
printf(" sizeof(ptr) = %zu bytes (just the pointer!)\n", sizeof(ptr));
printf(" sizeof(*ptr) = %zu bytes (what it points to)\n", sizeof(*ptr));
printf("\nKey insight: sizeof(arr) gives array size,\n");
printf("but sizeof(ptr) gives pointer size (not array size).\n");
}
/* ============================================================
* EXAMPLE 6: Modifying Array Through Pointer
* ============================================================ */
void example6_modify(void) {
printf("\n=== EXAMPLE 6: Modifying Through Pointer ===\n\n");
int arr[5] = {10, 20, 30, 40, 50};
int *ptr = arr;
printf("Original: ");
for (int i = 0; i < 5; i++) printf("%d ", arr[i]);
printf("\n");
// Modify using pointer
*ptr = 100; // Change arr[0]
*(ptr + 2) = 300; // Change arr[2]
ptr[4] = 500; // Change arr[4]
printf("Modified: ");
for (int i = 0; i < 5; i++) printf("%d ", arr[i]);
printf("\n");
// Double all elements using pointer
ptr = arr;
for (int i = 0; i < 5; i++) {
*ptr *= 2;
ptr++;
}
printf("Doubled: ");
for (int i = 0; i < 5; i++) printf("%d ", arr[i]);
printf("\n");
}
/* ============================================================
* EXAMPLE 7: Pointer vs Array Assignment
* ============================================================ */
void example7_assignment(void) {
printf("\n=== EXAMPLE 7: Pointer vs Array Assignment ===\n\n");
int arr1[3] = {1, 2, 3};
int arr2[3] = {4, 5, 6};
int *ptr = arr1;
printf("Initial:\n");
printf(" arr1 = {%d, %d, %d}\n", arr1[0], arr1[1], arr1[2]);
printf(" arr2 = {%d, %d, %d}\n", arr2[0], arr2[1], arr2[2]);
printf(" ptr points to arr1, *ptr = %d\n\n", *ptr);
// Pointer can be reassigned
ptr = arr2;
printf("After 'ptr = arr2':\n");
printf(" ptr now points to arr2, *ptr = %d\n\n", *ptr);
// Array cannot be reassigned
printf("Cannot do: arr1 = arr2; // Error!\n");
printf("Array name is a constant - cannot be changed.\n");
}
/* ============================================================
* EXAMPLE 8: &arr vs arr
* ============================================================ */
void example8_address_of_array(void) {
printf("\n=== EXAMPLE 8: &arr vs arr ===\n\n");
int arr[5] = {10, 20, 30, 40, 50};
printf("arr = %p (pointer to first element)\n", (void*)arr);
printf("&arr = %p (pointer to entire array)\n", (void*)&arr);
printf("&arr[0] = %p (pointer to first element)\n\n", (void*)&arr[0]);
printf("Same address, but different types!\n\n");
printf("Pointer arithmetic difference:\n");
printf(" arr + 1 = %p (next int, +4 bytes)\n", (void*)(arr + 1));
printf(" &arr + 1 = %p (past array, +20 bytes)\n", (void*)(&arr + 1));
printf("\n Difference: %ld bytes\n",
(long)((char*)(&arr + 1) - (char*)(arr + 1)));
}
/* ============================================================
* EXAMPLE 9: Pointer to 2D Array
* ============================================================ */
void example9_2d_array(void) {
printf("\n=== EXAMPLE 9: Pointers with 2D Arrays ===\n\n");
int matrix[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
printf("Matrix (3x4):\n");
for (int i = 0; i < 3; i++) {
printf(" ");
for (int j = 0; j < 4; j++) {
printf("%3d ", matrix[i][j]);
}
printf("\n");
}
printf("\nAccessing matrix[1][2] (value = 7):\n");
printf(" matrix[1][2] = %d\n", matrix[1][2]);
printf(" *(*(matrix + 1) + 2) = %d\n", *(*(matrix + 1) + 2));
printf(" *(matrix[1] + 2) = %d\n", *(matrix[1] + 2));
// Flat access
int *flat = &matrix[0][0];
printf(" Flat: *(flat + 1*4 + 2) = %d\n", *(flat + 1 * 4 + 2));
printf("\nRow pointers:\n");
printf(" matrix[0] = %p (row 0)\n", (void*)matrix[0]);
printf(" matrix[1] = %p (row 1)\n", (void*)matrix[1]);
printf(" matrix[2] = %p (row 2)\n", (void*)matrix[2]);
}
/* ============================================================
* EXAMPLE 10: Pointer to Array (Row Pointer)
* ============================================================ */
void example10_pointer_to_array(void) {
printf("\n=== EXAMPLE 10: Pointer to Array ===\n\n");
int matrix[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
// Pointer to array of 4 ints
int (*rowPtr)[4] = matrix;
printf("int (*rowPtr)[4] = matrix;\n\n");
printf("Using rowPtr to access rows:\n");
for (int i = 0; i < 3; i++) {
printf(" Row %d: ", i);
for (int j = 0; j < 4; j++) {
printf("%3d ", rowPtr[i][j]);
}
printf("\n");
}
printf("\nPointer arithmetic:\n");
printf(" rowPtr points to row 0\n");
printf(" rowPtr + 1 points to row 1\n");
printf(" rowPtr[1][2] = %d\n", rowPtr[1][2]);
}
/* ============================================================
* EXAMPLE 11: Array of Pointers
* ============================================================ */
void example11_array_of_pointers(void) {
printf("\n=== EXAMPLE 11: Array of Pointers ===\n\n");
// Array of pointers to strings
const char *names[] = {
"Alice",
"Bob",
"Charlie",
"Diana"
};
int count = sizeof(names) / sizeof(names[0]);
printf("Array of string pointers:\n");
for (int i = 0; i < count; i++) {
printf(" names[%d] = %p ā \"%s\"\n",
i, (void*)names[i], names[i]);
}
// Array of pointers to int arrays (ragged array)
printf("\nRagged array (different length rows):\n");
int row0[] = {1, 2};
int row1[] = {3, 4, 5, 6};
int row2[] = {7, 8, 9};
int *rows[] = {row0, row1, row2};
int sizes[] = {2, 4, 3};
for (int i = 0; i < 3; i++) {
printf(" Row %d (%d elements): ", i, sizes[i]);
for (int j = 0; j < sizes[i]; j++) {
printf("%d ", rows[i][j]);
}
printf("\n");
}
}
/* ============================================================
* EXAMPLE 12: Array of Pointers vs Pointer to Array
* ============================================================ */
void example12_comparison(void) {
printf("\n=== EXAMPLE 12: int *arr[] vs int (*arr)[] ===\n\n");
int a = 1, b = 2, c = 3;
int data[3] = {10, 20, 30};
// Array of 3 pointers to int
int *ptrArray[3] = {&a, &b, &c};
// Pointer to array of 3 ints
int (*arrayPtr)[3] = &data;
printf("int *ptrArray[3] - Array of 3 pointers:\n");
printf(" sizeof(ptrArray) = %zu bytes\n", sizeof(ptrArray));
for (int i = 0; i < 3; i++) {
printf(" *ptrArray[%d] = %d\n", i, *ptrArray[i]);
}
printf("\nint (*arrayPtr)[3] - Pointer to array of 3:\n");
printf(" sizeof(arrayPtr) = %zu bytes\n", sizeof(arrayPtr));
printf(" sizeof(*arrayPtr) = %zu bytes\n", sizeof(*arrayPtr));
for (int i = 0; i < 3; i++) {
printf(" (*arrayPtr)[%d] = %d\n", i, (*arrayPtr)[i]);
}
}
/* ============================================================
* EXAMPLE 13: Passing Array to Function
* ============================================================ */
// These declarations are equivalent
void printArray1(int arr[], int size) {
printf(" printArray1 (arr[]): ");
for (int i = 0; i < size; i++) printf("%d ", arr[i]);
printf("\n");
}
void printArray2(int *arr, int size) {
printf(" printArray2 (*arr): ");
for (int i = 0; i < size; i++) printf("%d ", arr[i]);
printf("\n");
}
void printArray3(int *arr, int size) {
printf(" printArray3 (ptr++): ");
for (int *p = arr; p < arr + size; p++) {
printf("%d ", *p);
}
printf("\n");
}
void example13_function_pass(void) {
printf("\n=== EXAMPLE 13: Passing Array to Function ===\n\n");
int arr[] = {10, 20, 30, 40, 50};
int size = sizeof(arr) / sizeof(arr[0]);
printf("Array: {10, 20, 30, 40, 50}\n\n");
printArray1(arr, size);
printArray2(arr, size);
printArray3(arr, size);
printf("\nAll three methods work because array decays to pointer!\n");
}
/* ============================================================
* EXAMPLE 14: Common Pointer Patterns
* ============================================================ */
// Sum using pointer
int sumArray(const int *arr, int size) {
int sum = 0;
const int *end = arr + size;
while (arr < end) {
sum += *arr++;
}
return sum;
}
// Find element
int* findElement(int *arr, int size, int target) {
int *end = arr + size;
for (int *p = arr; p < end; p++) {
if (*p == target) return p;
}
return NULL;
}
// Copy array
void copyArray(int *dest, const int *src, int size) {
const int *end = src + size;
while (src < end) {
*dest++ = *src++;
}
}
void example14_patterns(void) {
printf("\n=== EXAMPLE 14: Common Pointer Patterns ===\n\n");
int arr[] = {10, 20, 30, 40, 50};
int size = 5;
// Sum
printf("Sum of {10,20,30,40,50} = %d\n", sumArray(arr, size));
// Find
int *found = findElement(arr, size, 30);
if (found) {
printf("Found 30 at index %ld\n", found - arr);
}
// Copy
int copy[5];
copyArray(copy, arr, size);
printf("Copied array: ");
for (int i = 0; i < size; i++) printf("%d ", copy[i]);
printf("\n");
}
/* ============================================================
* MAIN FUNCTION
* ============================================================ */
int main(void) {
printf("āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā\n");
printf("ā POINTERS AND ARRAYS - EXAMPLES ā\n");
printf("āāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā\n");
example1_array_as_pointer();
example2_pointer_arithmetic();
example3_access_methods();
example4_traversal();
example5_sizeof();
example6_modify();
example7_assignment();
example8_address_of_array();
example9_2d_array();
example10_pointer_to_array();
example11_array_of_pointers();
example12_comparison();
example13_function_pass();
example14_patterns();
printf("\nāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāāā\n");
printf("All examples completed!\n");
return 0;
}