Article

Structures allow us to group related data together, but pointers to structures are what enable dynamic memory allocation, efficient parameter passing, and the creation of complex data structures like linked lists, trees, and graphs. Understanding structure pointers is essential for building sophisticated C programs that can handle real-world data efficiently.

What Are Structure Pointers?

A structure pointer is a pointer variable that stores the memory address of a structure. Just like pointers to basic types, structure pointers allow you to access and modify structure members indirectly, pass structures efficiently to functions, and create dynamic data structures.

struct Person { char name[50]; int age; float height; }; struct Person person; // Structure variable struct Person *ptr; // Pointer to structure ptr = &person; // ptr now points to person

Basic Structure Pointer Operations

1. Declaring and Using Structure Pointers

#include <stdio.h> #include <string.h> struct Student { int id; char name[50]; float gpa; }; int main() { // Declare a structure variable struct Student student1 = {101, "Alice Smith", 3.85}; // Declare a pointer to the structure struct Student *ptr; // Point to the structure ptr = &student1; // Access members using the pointer (arrow operator) printf("Student ID: %d\n", ptr->id); printf("Student Name: %s\n", ptr->name); printf("Student GPA: %.2f\n", ptr->gpa); // Modify members through pointer ptr->gpa = 3.92; printf("Updated GPA: %.2f\n", student1.gpa); // Original changed // Alternative syntax using dereference and dot printf("ID (alternative): %d\n", (*ptr).id); return 0; }

2. Arrow Operator vs Dereference

#include <stdio.h> struct Point { int x; int y; }; int main() { struct Point p = {10, 20}; struct Point *ptr = &p; // These are equivalent: printf("Using arrow: x = %d, y = %d\n", ptr->x, ptr->y); printf("Using deref: x = %d, y = %d\n", (*ptr).x, (*ptr).y); // Parentheses are necessary because . has higher precedence than * // *ptr.x would be interpreted as *(ptr.x) - which is wrong! return 0; }

Passing Structures to Functions

1. Passing by Value (Inefficient for Large Structures)

#include <stdio.h> #include <string.h> typedef struct { char name[100]; int age; char address[200]; char phone[20]; } Person; // Pass by value - creates a copy (inefficient for large structures) void printPersonByValue(Person p) { printf("Name: %s\n", p.name); printf("Age: %d\n", p.age); printf("Address: %s\n", p.address); printf("Phone: %s\n", p.phone); printf("Size of copy: %lu bytes\n\n", sizeof(p)); } int main() { Person person = { "John Doe", 30, "123 Main St, City, Country", "555-1234" }; printf("Original size: %lu bytes\n", sizeof(person)); printPersonByValue(person); // Entire structure is copied return 0; }

2. Passing by Pointer (Efficient)

#include <stdio.h> #include <string.h> typedef struct { char name[100]; int age; char address[200]; char phone[20]; } Person; // Pass by pointer - only the address is passed (8 bytes on 64-bit) void printPersonByPointer(const Person *p) { printf("Name: %s\n", p->name); printf("Age: %d\n", p->age); printf("Address: %s\n", p->address); printf("Phone: %s\n", p->phone); printf("Size of pointer: %lu bytes\n\n", sizeof(p)); } // Function that modifies the structure void updatePerson(Person *p, int newAge, const char *newPhone) { p->age = newAge; strcpy(p->phone, newPhone); } int main() { Person person = { "John Doe", 30, "123 Main St, City, Country", "555-1234" }; printf("Original size: %lu bytes\n", sizeof(person)); printPersonByPointer(&person); // Only address is passed updatePerson(&person, 31, "555-5678"); printf("After update:\n"); printPersonByPointer(&person); return 0; }

Dynamic Allocation of Structures

1. Single Structure on Heap

#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { int id; char *name; // Will point to dynamically allocated string float salary; } Employee; Employee* createEmployee(int id, const char *name, float salary) { Employee *emp = (Employee*)malloc(sizeof(Employee)); if (!emp) return NULL; emp->id = id; emp->salary = salary; // Dynamically allocate space for name emp->name = (char*)malloc(strlen(name) + 1); if (!emp->name) { free(emp); return NULL; } strcpy(emp->name, name); return emp; } void destroyEmployee(Employee *emp) { if (emp) { free(emp->name); // Free the nested allocation first free(emp); // Then free the structure } } void printEmployee(const Employee *emp) { if (emp) { printf("ID: %d, Name: %s, Salary: $%.2f\n", emp->id, emp->name, emp->salary); } } int main() { Employee *emp = createEmployee(101, "Bob Wilson", 75000.50); if (emp) { printEmployee(emp); destroyEmployee(emp); } return 0; }

2. Array of Structures on Heap

#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { int x; int y; } Point; Point* createPointArray(int size) { // Allocate array of Points Point *points = (Point*)malloc(size * sizeof(Point)); return points; } void initializePoints(Point *points, int size) { for (int i = 0; i < size; i++) { points[i].x = i * 10; points[i].y = i * 10 + 5; } } void printPoints(const Point *points, int size) { for (int i = 0; i < size; i++) { printf("Point[%d]: (%d, %d)\n", i, points[i].x, points[i].y); } } int main() { int numPoints = 5; Point *points = createPointArray(numPoints); if (points) { initializePoints(points, numPoints); printPoints(points, numPoints); free(points); // Free the entire array } return 0; }

3. Array of Structure Pointers

#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { char title[100]; char author[50]; int year; } Book; Book** createBookArray(int size) { // Allocate array of Book pointers Book **books = (Book**)malloc(size * sizeof(Book*)); return books; } void addBook(Book **books, int index, const char *title, const char *author, int year) { books[index] = (Book*)malloc(sizeof(Book)); if (books[index]) { strcpy(books[index]->title, title); strcpy(books[index]->author, author); books[index]->year = year; } } void destroyBookArray(Book **books, int size) { for (int i = 0; i < size; i++) { free(books[i]); // Free each book } free(books); // Free the array of pointers } void printLibrary(Book **books, int size) { for (int i = 0; i < size; i++) { if (books[i]) { printf("Book %d: '%s' by %s (%d)\n", i + 1, books[i]->title, books[i]->author, books[i]->year); } } } int main() { int numBooks = 3; Book **library = createBookArray(numBooks); addBook(library, 0, "The C Programming Language", "Kernighan & Ritchie", 1978); addBook(library, 1, "Clean Code", "Robert Martin", 2008); addBook(library, 2, "The Pragmatic Programmer", "Hunt & Thomas", 1999); printLibrary(library, numBooks); destroyBookArray(library, numBooks); return 0; }

Self-Referential Structures (Linked Lists)

#include <stdio.h> #include <stdlib.h> // Self-referential structure - contains pointer to same type typedef struct Node { int data; struct Node *next; // Pointer to next node } Node; // Create a new node Node* createNode(int data) { Node *newNode = (Node*)malloc(sizeof(Node)); if (!newNode) return NULL; newNode->data = data; newNode->next = NULL; return newNode; } // Insert at beginning void insertAtBeginning(Node **head, int data) { Node *newNode = createNode(data); if (newNode) { newNode->next = *head; *head = newNode; } } // Insert at end void insertAtEnd(Node **head, int data) { Node *newNode = createNode(data); if (!newNode) return; if (*head == NULL) { *head = newNode; return; } Node *current = *head; while (current->next != NULL) { current = current->next; } current->next = newNode; } // Delete a node int deleteNode(Node **head, int data) { if (*head == NULL) return 0; Node *current = *head; Node *prev = NULL; // Search for node while (current != NULL && current->data != data) { prev = current; current = current->next; } if (current == NULL) return 0; // Not found if (prev == NULL) { // Deleting head node *head = current->next; } else { prev->next = current->next; } free(current); return 1; // Success } // Print list void printList(Node *head) { printf("List: "); while (head != NULL) { printf("%d -> ", head->data); head = head->next; } printf("NULL\n"); } // Free entire list void freeList(Node **head) { Node *current = *head; while (current != NULL) { Node *temp = current; current = current->next; free(temp); } *head = NULL; } int main() { Node *head = NULL; insertAtEnd(&head, 10); insertAtEnd(&head, 20); insertAtBeginning(&head, 5); insertAtEnd(&head, 30); printList(head); deleteNode(&head, 20); printf("After deleting 20: "); printList(head); freeList(&head); return 0; }

Pointer to Pointer to Structure

Useful for modifying the pointer itself in functions:

#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { char name[50]; int value; } Item; // Function that can change where the pointer points void reassignPointer(Item **ptr, const char *newName, int newValue) { // Free old item if needed if (*ptr) { free(*ptr); } // Create new item *ptr = (Item*)malloc(sizeof(Item)); if (*ptr) { strcpy((*ptr)->name, newName); (*ptr)->value = newValue; } } // Function that creates and returns an array of pointers Item** createItemArray(int size) { Item **array = (Item**)malloc(size * sizeof(Item*)); // Initialize all pointers to NULL for (int i = 0; i < size; i++) { array[i] = NULL; } return array; } // Function that frees the array and all items void destroyItemArray(Item ***array, int size) { if (!array || !*array) return; for (int i = 0; i < size; i++) { free((*array)[i]); } free(*array); *array = NULL; } int main() { Item *item = NULL; // Pass pointer to pointer so function can modify the original pointer reassignPointer(&item, "First Item", 100); printf("Item: %s = %d\n", item->name, item->value); reassignPointer(&item, "Second Item", 200); printf("Item: %s = %d\n", item->name, item->value); free(item); // Working with array of pointers int size = 3; Item **array = createItemArray(size); // Initialize some items array[0] = malloc(sizeof(Item)); strcpy(array[0]->name, "A"); array[0]->value = 1; array[1] = malloc(sizeof(Item)); strcpy(array[1]->name, "B"); array[1]->value = 2; printf("\nArray items:\n"); for (int i = 0; i < size; i++) { if (array[i]) { printf(" [%d]: %s = %d\n", i, array[i]->name, array[i]->value); } } destroyItemArray(&array, size); return 0; }

Structure Pointers and Function Pointers

#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { char name[50]; int (*compare)(const void *, const void *); void (*print)(const void *); } DataType; // Comparison functions int compareInt(const void *a, const void *b) { return *(int*)a - *(int*)b; } int compareDouble(const void *a, const void *b) { double diff = *(double*)a - *(double*)b; return (diff > 0) - (diff < 0); } // Print functions void printInt(const void *data) { printf("%d", *(int*)data); } void printDouble(const void *data) { printf("%.2f", *(double*)data); } // Generic container using structure pointers typedef struct { void *data; DataType *type; } Container; Container* createContainer(void *data, DataType *type) { Container *c = (Container*)malloc(sizeof(Container)); if (c) { c->data = data; c->type = type; } return c; } void printContainer(Container *c) { if (c && c->type && c->type->print) { printf("%s: ", c->type->name); c->type->print(c->data); printf("\n"); } } int main() { // Define data types DataType intType = {"Integer", compareInt, printInt}; DataType doubleType = {"Double", compareDouble, printDouble}; // Create containers int i = 42; double d = 3.14159; Container *c1 = createContainer(&i, &intType); Container *c2 = createContainer(&d, &doubleType); printContainer(c1); printContainer(c2); free(c1); free(c2); return 0; }

Const Correctness with Structure Pointers

#include <stdio.h> #include <string.h> typedef struct { char name[50]; int age; } Person; // Function promises not to modify the structure void printPerson(const Person *p) { printf("Name: %s, Age: %d\n", p->name, p->age); // p->age = 30; // Error! Can't modify const } // Function may modify the structure void updatePerson(Person *p, int newAge) { p->age = newAge; // OK - non-const pointer } // Constant pointer to constant data void processConstPerson(const Person *const p) { printf("Processing: %s\n", p->name); // p->age = 40; // Error: can't modify data // p = NULL; // Error: can't modify pointer } int main() { Person person = {"Alice", 25}; printPerson(&person); updatePerson(&person, 26); printPerson(&person); processConstPerson(&person); return 0; }

Practical Examples

Example 1: Binary Tree Implementation

#include <stdio.h> #include <stdlib.h> typedef struct TreeNode { int data; struct TreeNode *left; struct TreeNode *right; } TreeNode; TreeNode* createNode(int data) { TreeNode *node = (TreeNode*)malloc(sizeof(TreeNode)); if (node) { node->data = data; node->left = node->right = NULL; } return node; } void insert(TreeNode **root, int data) { if (*root == NULL) { *root = createNode(data); return; } if (data < (*root)->data) { insert(&(*root)->left, data); } else if (data > (*root)->data) { insert(&(*root)->right, data); } } TreeNode* search(TreeNode *root, int data) { if (root == NULL || root->data == data) { return root; } if (data < root->data) { return search(root->left, data); } else { return search(root->right, data); } } void inorderTraversal(TreeNode *root) { if (root) { inorderTraversal(root->left); printf("%d ", root->data); inorderTraversal(root->right); } } void freeTree(TreeNode **root) { if (*root) { freeTree(&(*root)->left); freeTree(&(*root)->right); free(*root); *root = NULL; } } int main() { TreeNode *root = NULL; int values[] = {50, 30, 70, 20, 40, 60, 80}; for (int i = 0; i < 7; i++) { insert(&root, values[i]); } printf("Inorder traversal: "); inorderTraversal(root); printf("\n"); TreeNode *found = search(root, 40); if (found) { printf("Found: %d\n", found->data); } freeTree(&root); return 0; }

Example 2: Employee Database

#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Employee { int id; char name[50]; char department[30]; double salary; struct Employee *next; // For linked list } Employee; typedef struct { Employee *head; // Head of linked list int count; } EmployeeDB; // Initialize database void initDB(EmployeeDB *db) { db->head = NULL; db->count = 0; } // Create new employee Employee* createEmployee(int id, const char *name, const char *dept, double salary) { Employee *emp = (Employee*)malloc(sizeof(Employee)); if (!emp) return NULL; emp->id = id; strcpy(emp->name, name); strcpy(emp->department, dept); emp->salary = salary; emp->next = NULL; return emp; } // Add employee to database void addEmployee(EmployeeDB *db, Employee *emp) { if (!db || !emp) return; emp->next = db->head; db->head = emp; db->count++; } // Find employee by ID Employee* findEmployee(const EmployeeDB *db, int id) { Employee *current = db->head; while (current) { if (current->id == id) { return current; } current = current->next; } return NULL; } // Delete employee by ID int deleteEmployee(EmployeeDB *db, int id) { if (!db || !db->head) return 0; Employee *current = db->head; Employee *prev = NULL; while (current) { if (current->id == id) { if (prev) { prev->next = current->next; } else { db->head = current->next; } free(current); db->count--; return 1; } prev = current; current = current->next; } return 0; // Not found } // Print all employees void printAllEmployees(const EmployeeDB *db) { if (!db || !db->head) { printf("No employees in database\n"); return; } printf("\n=== Employee Database (%d employees) ===\n", db->count); Employee *current = db->head; while (current) { printf("ID: %d\n", current->id); printf("Name: %s\n", current->name); printf("Dept: %s\n", current->department); printf("Salary: $%.2f\n", current->salary); printf("---\n"); current = current->next; } } // Calculate average salary double averageSalary(const EmployeeDB *db) { if (!db || !db->head) return 0; double total = 0; Employee *current = db->head; while (current) { total += current->salary; current = current->next; } return total / db->count; } // Free entire database void freeDB(EmployeeDB *db) { Employee *current = db->head; while (current) { Employee *temp = current; current = current->next; free(temp); } db->head = NULL; db->count = 0; } int main() { EmployeeDB db; initDB(&db); // Add some employees addEmployee(&db, createEmployee(101, "Alice Johnson", "Engineering", 85000)); addEmployee(&db, createEmployee(102, "Bob Smith", "Marketing", 65000)); addEmployee(&db, createEmployee(103, "Carol Davis", "Engineering", 92000)); addEmployee(&db, createEmployee(104, "David Wilson", "Sales", 72000)); printAllEmployees(&db); printf("\nAverage salary: $%.2f\n", averageSalary(&db)); printf("\nFinding employee 103:\n"); Employee *found = findEmployee(&db, 103); if (found) { printf("Found: %s from %s\n", found->name, found->department); } printf("\nDeleting employee 102...\n"); deleteEmployee(&db, 102); printAllEmployees(&db); freeDB(&db); return 0; }

Example 3: Matrix Using Structure Pointers

#include <stdio.h> #include <stdlib.h> typedef struct { int rows; int cols; int **data; // Pointer to array of row pointers } Matrix; // Create matrix Matrix* createMatrix(int rows, int cols) { Matrix *m = (Matrix*)malloc(sizeof(Matrix)); if (!m) return NULL; m->rows = rows; m->cols = cols; // Allocate array of row pointers m->data = (int**)malloc(rows * sizeof(int*)); if (!m->data) { free(m); return NULL; } // Allocate each row for (int i = 0; i < rows; i++) { m->data[i] = (int*)malloc(cols * sizeof(int)); if (!m->data[i]) { // Clean up already allocated rows for (int j = 0; j < i; j++) { free(m->data[j]); } free(m->data); free(m); return NULL; } } return m; } // Free matrix void freeMatrix(Matrix *m) { if (!m) return; for (int i = 0; i < m->rows; i++) { free(m->data[i]); } free(m->data); free(m); } // Initialize matrix with values void initMatrix(Matrix *m, int value) { for (int i = 0; i < m->rows; i++) { for (int j = 0; j < m->cols; j++) { m->data[i][j] = value; } } } // Set element void setElement(Matrix *m, int row, int col, int value) { if (row >= 0 && row < m->rows && col >= 0 && col < m->cols) { m->data[row][col] = value; } } // Get element int getElement(const Matrix *m, int row, int col) { if (row >= 0 && row < m->rows && col >= 0 && col < m->cols) { return m->data[row][col]; } return 0; } // Print matrix void printMatrix(const Matrix *m) { for (int i = 0; i < m->rows; i++) { for (int j = 0; j < m->cols; j++) { printf("%4d ", m->data[i][j]); } printf("\n"); } } // Add two matrices Matrix* addMatrices(const Matrix *a, const Matrix *b) { if (a->rows != b->rows || a->cols != b->cols) { printf("Matrix dimensions don't match!\n"); return NULL; } Matrix *result = createMatrix(a->rows, a->cols); if (!result) return NULL; for (int i = 0; i < a->rows; i++) { for (int j = 0; j < a->cols; j++) { result->data[i][j] = a->data[i][j] + b->data[i][j]; } } return result; } // Multiply matrices Matrix* multiplyMatrices(const Matrix *a, const Matrix *b) { if (a->cols != b->rows) { printf("Cannot multiply: a->cols != b->rows\n"); return NULL; } Matrix *result = createMatrix(a->rows, b->cols); if (!result) return NULL; for (int i = 0; i < a->rows; i++) { for (int j = 0; j < b->cols; j++) { int sum = 0; for (int k = 0; k < a->cols; k++) { sum += a->data[i][k] * b->data[k][j]; } result->data[i][j] = sum; } } return result; } int main() { // Create first matrix Matrix *a = createMatrix(2, 3); initMatrix(a, 1); // All ones printf("Matrix A (2x3):\n"); printMatrix(a); printf("\n"); // Create second matrix Matrix *b = createMatrix(3, 2); for (int i = 0; i < 3; i++) { for (int j = 0; j < 2; j++) { setElement(b, i, j, i * 2 + j); } } printf("Matrix B (3x2):\n"); printMatrix(b); printf("\n"); // Add matrices (if dimensions allow) // Matrix *sum = addMatrices(a, a); // Would work: 2x3 + 2x3 // Multiply matrices Matrix *product = multiplyMatrices(a, b); if (product) { printf("A * B (2x2):\n"); printMatrix(product); freeMatrix(product); } freeMatrix(a); freeMatrix(b); return 0; }

Common Pitfalls

// Pitfall 1: Forgetting to allocate memory for nested pointers struct Node { int data; struct Node *next; }; struct Node *head; head->data = 5; // ERROR: head is not allocated! // Correct: struct Node *head = malloc(sizeof(struct Node)); head->data = 5; head->next = NULL; // Pitfall 2: Memory leak when freeing structure with nested pointers struct Person { char *name; int age; }; struct Person *p = malloc(sizeof(struct Person)); p->name = malloc(50); strcpy(p->name, "Alice"); free(p); // Memory leak: p->name not freed! // Correct: free(p->name); free(p); // Pitfall 3: Dangling pointer after free struct Point *p = malloc(sizeof(struct Point)); p->x = 10; p->y = 20; free(p); p->x = 30; // ERROR: Using freed memory! // Pitfall 4: Forgetting to check allocation success struct BigStruct *ptr = malloc(sizeof(struct BigStruct) * 1000000); // Should check if ptr is NULL before using // Pitfall 5: Pointer arithmetic with structure pointers struct Point points[5]; struct Point *ptr = points; ptr++; // Moves to next Point, not next byte (good) int *bad = (int*)ptr; bad++; // Now points to middle of a Point - dangerous!

Structure Pointers Cheat Sheet

Operation	Syntax	Description
Declare pointer	`struct S *ptr;`	Pointer to structure
Point to variable	`ptr = &s;`	Get address
Access member	`ptr->member`	Using arrow operator
Dereference + dot	`(*ptr).member`	Alternative syntax
Dynamic allocation	`ptr = malloc(sizeof(struct S));`	Create on heap
Array of structures	`ptr = malloc(n * sizeof(struct S));`	Allocate array
Array of pointers	`ptr = malloc(n * sizeof(struct S*));`	Allocate pointer array
Function parameter	`void func(struct S *p)`	Pass by pointer
Return pointer	`struct S* func(void)`	Return pointer

Best Practices

Always check malloc return value before using the pointer
Free nested allocations before freeing the main structure
Set freed pointers to NULL to prevent dangling pointer usage
Use const for input parameters that shouldn't be modified
Document ownership (who is responsible for freeing)
Initialize pointers to NULL after declaration
Check for NULL before dereferencing pointers
Use typedef to simplify structure pointer syntax
Be consistent with pointer notation throughout the code

Conclusion

Structure pointers are fundamental to C programming, enabling:

Efficient parameter passing (avoid copying large structures)
Dynamic data structures (linked lists, trees, graphs)
Flexible memory management (allocate only what's needed)
Polymorphic behavior (function pointers in structures)
Real-world data modeling (complex relationships)

Key principles to remember:

Arrow operator (->) is syntactic sugar for dereference and dot
Always manage memory carefully, especially with nested allocations
Pass structures by pointer for efficiency and modification capability
Self-referential structures enable powerful data structures
Const-correctness helps prevent unintended modifications

Mastering structure pointers is essential for any serious C programmer. They provide the foundation for building complex, efficient, and maintainable systems that can handle real-world data and relationships.

Complete C Programming Guide + Compilers Collection

1. C srand() Function – Understanding Seed Initialization

https://macronepal.com/understanding-the-c-srand-function
Explains how srand() initializes the pseudo-random number generator in C by setting a seed value. Using the same seed produces the same sequence, while time(NULL) gives different results each run.

2. C rand() Function Mechanics and Limitations

https://macronepal.com/c-rand-function-mechanics-and-limitations
Explains how rand() generates pseudo-random numbers between 0 and RAND_MAX, its deterministic nature, and limitations for security use cases.

3. C log() Function

https://macronepal.com/c-log-function-2
Covers natural logarithm calculation using <math.h> and its applications.

4. Mastering Date and Time in C

https://macronepal.com/mastering-date-and-time-in-c
Explains <time.h> functions like time(), clock(), difftime(), and struct tm.

5. Mastering time_t Type in C

https://macronepal.com/mastering-the-c-time_t-type-for-time-management
Explains time representation as seconds since Unix epoch and conversion functions.

6. C exp() Function

https://macronepal.com/c-exp-function-mechanics-and-implementation
Explains exponential function exp(x) and its scientific applications.

7. C log() Function (Alternate Guide)

https://macronepal.com/c-log-function
Comparison of log() and log10() with usage examples.

8. C log10() Function

https://macronepal.com/mastering-the-log10-function-in-c
Explains base-10 logarithm for engineering and scientific applications.

9. C tan() Function

https://macronepal.com/understanding-the-c-tan-function
Explains tangent function and radian-based calculations.

10. Random Numbers in C (Secure vs Predictable)

https://macronepal.com/mastering-c-random-numbers-for-secure-and-predictable-applications
Explains difference between rand() and secure randomness methods.

11. Free Online C Compiler

https://macronepal.com/free-online-c-code-compiler-2
Browser-based compiler for testing C programs instantly.

C Functions, Arguments, Parameters & Flow

Mastering Functions in C – Complete Guide

https://macronepal.com/c/mastering-functions-in-c-a-complete-guide/
Covers function structure, modular programming, and real-world usage.

Function Arguments in C

https://macronepal.com/c-function-arguments/
Explains how arguments are passed and used in function calls.

Function Parameters in C

https://macronepal.com/c-function-parameters/
Explains defining inputs for functions and matching them with arguments.

Function Declarations in C

https://macronepal.com/c-function-declarations-syntax-rules-and-best-practices/
Covers prototypes, syntax rules, and best practices.

Function Calls in C

https://macronepal.com/understanding-function-calls-in-c-syntax-mechanics-and-best-practices/
Explains execution flow and parameter handling during function calls.

Void Functions in C

https://macronepal.com/understanding-void-functions-in-c-syntax-patterns-and-best-practices/
Explains functions that do not return values.

Return Values in C

https://macronepal.com/c-return-values-mechanics-types-and-best-practices/
Explains different return types and how functions return results.

Pass-by-Value in C

https://macronepal.com/aws/understanding-pass-by-value-in-c-mechanics-implications-and-best-practices/
Explains how copies of variables are passed into functions.

Pass-by-Reference in C

https://macronepal.com/c/understanding-pass-by-reference-in-c-pointers-semantics-and-safe-practices/
Explains using pointers to modify original variables.

C strstr() Function

https://macronepal.com/aws/c-strstr-function/
Explains substring search inside strings in C.

C Preprocessor & Macros

C Structures, Memory, Scope & Linkage

C Scope, Storage Classes & Typedef

Extra Articles

https://macronepal.com/13757-2/
https://macronepal.com/13748-2/
https://macronepal.com/13747-2/
https://macronepal.com/13746-2/
https://macronepal.com/13745-2/
https://macronepal.com/13708-2/
https://macronepal.com/13707-2/
https://macronepal.com/13702-2/

Online Compilers