C Notes
HubApplications of C Programming LanguageFeatures of C Programming LanguageHistory of C Programming LanguageWhat is C Language?Why Learn C Programming in 2024?First C Program - Hello World in C with ExplanationGCC Compiler - Complete Guide to GNU C CompilerInstall C Compiler on Linux - GCC Setup Guide for All DistrosInstall C Compiler on macOS - Xcode Command Line Tools and Homebrew GCCInstall C Compiler on Windows - MinGW, MSYS2, and WSL GuideSetup VS Code for C Programming - Complete Configuration GuideC Syntax Rules — Complete GuideComments in C ProgrammingConstants in C ProgrammingData Types in CIdentifiers in C ProgrammingKeywords in C ProgrammingStructure of a C ProgramVariables in C ProgrammingArithmetic Operators in C ProgrammingAssignment Operators in C ProgrammingBitwise Operators in C ProgrammingIncrement and Decrement Operators in CLogical Operators in C ProgrammingRelational Operators in C ProgrammingTernary Operator in C ProgrammingBreak Statement in C ProgrammingContinue Statement in C ProgrammingDo-While Loop in C ProgrammingFor Loop in C ProgrammingGoto Statement in C Programmingif-else Statement in C Programmingif Statement in C ProgrammingNested if Statements in C ProgrammingSwitch Statement in C ProgrammingWhile Loop in C ProgrammingFunction Arguments in C - Pass by Value vs Pass by ReferenceFunction Call in C ProgrammingFunction Declaration (Prototype) in CFunction Definition in C ProgrammingIntroduction to Functions in C ProgrammingRecursion in C ProgrammingReturn Statement in C ProgrammingStorage Classes in C ProgrammingArray Operations in C - Searching, Sorting, Insert and DeleteArray Programs in C - Reverse, Rotate, Duplicates, MergeIntroduction to Arrays in C ProgrammingMultidimensional Arrays in C ProgrammingOne Dimensional Arrays in C ProgrammingPassing Arrays to Functions in CTwo Dimensional Arrays in C ProgrammingString Comparison in C - strcmp, strncmp, Case-InsensitiveString Functions in C - strlen, strcpy, strcat, strcmpC String Handling Library - Complete string.h ReferenceString Manipulation in C - Reverse, Uppercase, PalindromeString Programs in C - Anagram, Word Count, Vowels, FrequencyStrings in C Programming - Complete IntroductionDouble Pointers in C - Pointer to PointerPointer Arithmetic in C ProgrammingPointer Declaration and Initialization in CPointer Programs in C - Swap, String Reversal, Dynamic AllocationPointers and Arrays in C - The Relationship ExplainedPointers and Functions in C - Pass by ReferenceIntroduction to Pointers in C ProgrammingVoid Pointers in C - Generic Pointers Guidecalloc() in C – Contiguous Memory AllocationDynamic Arrays in C – Runtime-Sized Arraysfree() in C – Releasing Dynamic Memorymalloc() in C – Dynamic Memory AllocationMemory Management Best Practices in Crealloc() in C – Resizing Dynamic MemoryBinary Files in C – fread and fwriteFile Handling in C – IntroductionFile Handling Projects in C – Student Records & Phone BookFile Modes in C – Complete Guidefopen() and fclose() in C – Opening and Closing FilesReading Files in C – fgetc, fgets, fscanf, freadWriting Files in C – fputc, fputs, fprintf, fwriteConditional Compilation in C – #ifdef, #ifndef, #if#define Macros in C – Constants and Macro FunctionsHeader Files in C – Creating Custom Headers#include Directive in C – File InclusionMacro Functions in C – Parameterized MacrosC Preprocessor – Overview and DirectivesGraphs in C – Adjacency Matrix, Adjacency List, BFS, and DFSHash Tables in C – Implementation, Collision Handling, and ChainingLinked List in C – Singly, Doubly, and Circular with ImplementationQueue in C – Linear, Circular, and Priority Queue ImplementationStack in C – Array and Linked List Implementation with ApplicationsTrees in C – Binary Search Tree Implementation with TraversalsC Programming Best Practices – Coding Standards, Safety, and PerformanceBit Fields in C – Definition, Use Cases, and Protocol HeadersC Standard Library Overview – All Headers and Common FunctionsCommand Line Arguments in C – argc and argv ExplainedDebugging Techniques in C – GDB, Valgrind, and SanitizersFunction Pointers in C – Complete Guide with ExamplesMemory Layout of a C Program – Text, Data, BSS, Heap, StackBank Management System in C – Complete Project with File StorageFile Encryption Tool in C – XOR Cipher ImplementationLibrary Management System in C – Complete Project with Source CodeMini Compiler in C – Lexer and Parser for Simple ExpressionsSnake Game in C – Console-Based Game with Source CodeStudent Management System in C – Complete Project with Source CodeC Programming Cheatsheet – Complete Quick Reference GuideTop 50 C Programming Interview Questions with Answers (2025)Memory Management Interview Questions in C with AnswersOutput Prediction Questions in C – What Will This Program Print?Pointer Interview Questions in C – Tricky Problems with AnswersCommon C Programming Errors and Solutions – Debugging GuideImportant C Programs – 50+ Frequently Asked Programs with SolutionsQuick Revision Notes for C Programming – Complete C in 10 MinutesRecommended C Programming Books – From Beginner to ExpertFormat Specifiers in C - Complete Referencegetchar() and putchar() in C Programminggets() and puts() in C ProgrammingC Input Output Programs and Examplesprintf() Function in C Programmingscanf() Function in C ProgrammingArrays of Structures in C – Managing CollectionsEnums in C – Enumerated Data TypesNested Structures in C – Struct Within StructPointers to Structures in C – Arrow OperatorStructures in C – User-Defined Data Typestypedef in C – Creating Type AliasesUnions in C – Shared Memory Data Types
Complete guide to pointers to structures in C — arrow operator (->), dynamic struct allocation, passing structs by pointer, linked list basics, practical examples with output.
Passing large structures by value copies every byte — wasteful for a 200-byte struct. Pointers to structures solve this by passing just an 8-byte address, plus they enable dynamic allocation, linked data structures, and in-place modification. The arrow operator (->) makes accessing members through a pointer clean and readable.
Basic Pointer to Structure
c example
#include <stdio.h>
struct Point {
int x, y;
};
int main() {
struct Point p = {10, 20};
struct Point *ptr = &p; // Pointer to the structure
// Access using arrow operator (->)
printf("Using ->: (%d, %d)\n", ptr->x, ptr->y);
// Equivalent: dereference then dot
printf("Using (*). : (%d, %d)\n", (*ptr).x, (*ptr).y);
// Modify through pointer
ptr->x = 99;
ptr->y = 88;
printf("After modify: (%d, %d)\n", p.x, p.y);
return 0;
}Output
Using ->: (10, 20) Using (*). : (10, 20) After modify: (99, 88)
Arrow Operator vs Dot Operator
| Syntax | When to Use | Example |
|---|---|---|
var.member | When you have the struct directly | student.name |
ptr->member | When you have a pointer to struct | ptr->name |
(*ptr).member | Same as -> but more verbose | (*ptr).name |
The -> operator is just syntactic sugar: ptr->member is exactly equivalent to (*ptr).member.
Passing Structures by Pointer
Example
#include <stdio.h>
#include <string.h>
struct Employee {
int id;
char name[50];
float salary;
};
// Pass by pointer — efficient, can modify original
void give_raise(struct Employee *emp, float percent) {
emp->salary *= (1 + percent / 100.0);
}
// Pass by const pointer — efficient, read-only
void print_employee(const struct Employee *emp) {
printf("ID: %d | Name: %-15s | Salary: $%.2f\n",
emp->id, emp->name, emp->salary);
}
int main() {
struct Employee emp = {101, "Sarah Connor", 75000.00};
printf("Before raise:\n");
print_employee(&emp);
give_raise(&emp, 15); // 15% raise
printf("After 15%% raise:\n");
print_employee(&emp);
return 0;
}
Output
Before raise: ID: 101 | Name: Sarah Connor | Salary: $75000.00 After 15% raise: ID: 101 | Name: Sarah Connor | Salary: $86250.00
Dynamic Allocation of Structures
Example
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Book {
char title[100];
char author[50];
int year;
float price;
};
struct Book *create_book(const char *title, const char *author, int year, float price) {
struct Book *b = (struct Book *)malloc(sizeof(struct Book));
if (b == NULL) return NULL;
strncpy(b->title, title, 99);
strncpy(b->author, author, 49);
b->year = year;
b->price = price;
return b;
}
void print_book(const struct Book *b) {
printf(" \"%s\" by %s (%d) - $%.2f\n", b->title, b->author, b->year, b->price);
}
int main() {
struct Book *library[3];
library[0] = create_book("The C Programming Language", "K&R", 1978, 45.99);
library[1] = create_book("Clean Code", "Robert Martin", 2008, 39.99);
library[2] = create_book("SICP", "Abelson & Sussman", 1985, 55.00);
printf("Library:\n");
for (int i = 0; i < 3; i++) {
if (library[i]) print_book(library[i]);
}
// Cleanup
for (int i = 0; i < 3; i++) {
free(library[i]);
}
return 0;
}
Output
Library: "The C Programming Language" by K&R (1978) - $45.99 "Clean Code" by Robert Martin (2008) - $39.99 "SICP" by Abelson & Sussman (1985) - $55.00
Simple Linked List with Struct Pointers
c example
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node *next; // Self-referential pointer
};
struct Node *create_node(int value) {
struct Node *node = (struct Node *)malloc(sizeof(struct Node));
if (node == NULL) return NULL;
node->data = value;
node->next = NULL;
return node;
}
void print_list(struct Node *head) {
struct Node *current = head;
while (current != NULL) {
printf("%d -> ", current->data);
current = current->next;
}
printf("NULL\n");
}
void free_list(struct Node *head) {
struct Node *temp;
while (head != NULL) {
temp = head;
head = head->next;
free(temp);
}
}
int main() {
// Build: 10 -> 20 -> 30 -> NULL
struct Node *head = create_node(10);
head->next = create_node(20);
head->next->next = create_node(30);
printf("Linked List: ");
print_list(head);
free_list(head);
return 0;
}Output
Linked List: 10 -> 20 -> 30 -> NULL
Array of Struct Pointers
Example
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct Student {
char name[50];
int grade;
};
int main() {
// Array of pointers — each points to a separately allocated struct
struct Student *class_list[3];
const char *names[] = {"Alice", "Bob", "Charlie"};
int grades[] = {95, 82, 91};
for (int i = 0; i < 3; i++) {
class_list[i] = (struct Student *)malloc(sizeof(struct Student));
strcpy(class_list[i]->name, names[i]);
class_list[i]->grade = grades[i];
}
// Access via pointer array
for (int i = 0; i < 3; i++) {
printf("%s scored %d\n", class_list[i]->name, class_list[i]->grade);
}
// Free
for (int i = 0; i < 3; i++) free(class_list[i]);
return 0;
}
Output
Alice scored 95 Bob scored 82 Charlie scored 91
Memory Diagram: Pointer vs Embedded
Embedded struct (value)
┌──────────────────────────────┐
│ struct Employee emp; │
│ ┌────┬────────────┬────────┐ │
│ │ id │ name[50] │ salary │ │
│ └────┴────────────┴────────┘ │
└──────────────────────────────┘
Pointer to struct
┌──────────────┐ ┌────┬────────────┬────────┐
│ struct Emp *p │──────→│ id │ name[50] │ salary │ (on heap)
└──────────────┘ └────┴────────────┴────────┘
(8 bytes) (56+ bytes on heap)
Interview Questions
Q1: Why use pointers to structures instead of passing by value?
Efficiency: passing a 200-byte struct by value copies all 200 bytes onto the stack. A pointer is only 8 bytes (on 64-bit). Pointers also allow the function to modify the original struct. For read-only access, use const struct *.
Q2: What is a self-referential structure?
A structure that contains a pointer to its own type: struct Node { int data; struct Node *next; };. This can't be a direct member (infinite size), only a pointer. It's the basis for linked lists, trees, and graphs.
Q3: What happens if you forget to dereference a struct pointer?
You get a compilation error. ptr.member won't compile because ptr is a pointer, not a struct. You must use ptr->member or (*ptr).member.
Q4: Can you have a pointer to a struct that hasn't been fully defined yet?
Yes! This is called an opaque pointer or forward declaration. You declare struct Widget; and use struct Widget *ptr without knowing the struct's contents. The full definition is hidden in the implementation file — this is the basis of information hiding in C.
Summary
- Use
->(arrow operator) to access members through a pointer ptr->memberis equivalent to(*ptr).member- Pass large structures by pointer for efficiency
- Use
const struct *for read-only pointer parameters - Dynamic allocation with malloc enables flexible, heap-based structures
- Self-referential struct pointers enable linked lists, trees, and graphs
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Pointers to Structures in C – Arrow Operator.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this C Programming topic.
Search Terms
c-programming, c programming, programming, structures, and, unions, pointers, pointers to structures in c – arrow operator
Related C Programming Topics
Continue learning this concept
Structures And UnionsArrays of Structures in C – Managing CollectionsComplete guide to arrays of structures in C — declaring and initializing struct arrays, student database example, sorting, searching, passing to functions, practical examples with output.Structures And UnionsEnums in C – Enumerated Data TypesComplete guide to enums in C programming — definition, syntax, automatic and custom values, enum vs #define, use in switch statements, bit flags, practical examples with output.Structures And UnionsNested Structures in C – Struct Within StructComplete guide to nested structures in C — defining structures inside structures, accessing nested members, practical examples like address within employee, date within record, with output.Structures And UnionsStructures in C – User-Defined Data TypesComplete guide to structures in C programming — definition, declaration, initialization, accessing members with dot operator, struct memory layout, size and padding, practical examples with output.Structures And Unionstypedef in C – Creating Type AliasesComplete guide to typedef in C programming — creating type aliases, typedef with structures, typedef with pointers and arrays, function pointer typedefs, improving code readability, practical examples.Structures And UnionsUnions in C – Shared Memory Data TypesComplete guide to unions in C programming — definition, syntax, shared memory concept, difference between struct and union, practical examples, type punning, tagged unions, and interview questions.