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

Best Practices

1. Always check malloc return value before using the pointer
2. Free nested allocations before freeing the main structure
3. Set freed pointers to NULL to prevent dangling pointer usage
4. Use const for input parameters that shouldn't be modified
5. Document ownership (who is responsible for freeing)
6. Initialize pointers to NULL after declaration
7. Check for NULL before dereferencing pointers
8. Use typedef to simplify structure pointer syntax
9. 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.