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
Master double pointers (pointer to pointer) in C including declaration, usage with functions, dynamic 2D arrays, and practical applications with memory diagrams.
A double pointer (or pointer to pointer) is a variable that stores the address of another pointer. Just as a regular pointer stores the address of a variable, a double pointer stores the address of a pointer variable. This concept extends naturally — you can have triple pointers, quadruple pointers, and so on — though in practice, you rarely need more than two levels of indirection.
What is a Double Pointer?
c example
int x = 42;
int *p = &x; // p stores address of x
int **pp = &p; // pp stores address of pMemory Layout:
┌──────────┐ ┌──────────┐ ┌──────────┐
│ pp │ │ p │ │ x │
│ ──────── │ │ ──────── │ │ ──────── │
│ &p ────┼──────→│ &x ────┼──────→│ 42 │
│ │ │ │ │ │
│(addr: │ │(addr: │ │(addr: │
│ 0x3000) │ │ 0x2000) │ │ 0x1000) │
└──────────┘ └──────────┘ └──────────┘
pp = 0x2000 (address of p)
*pp = 0x1000 (value of p = address of x)
**pp = 42 (value of x)
Declaration and Usage
c example
#include <stdio.h>
int main() {
int x = 100;
int *p = &x;
int **pp = &p;
printf("x = %d\n", x);
printf("*p = %d\n", *p);
printf("**pp = %d\n", **pp);
printf("\n&x = %p\n", (void*)&x);
printf("p = %p\n", (void*)p);
printf("*pp = %p\n", (void*)*pp);
printf("\n&p = %p\n", (void*)&p);
printf("pp = %p\n", (void*)pp);
// Modify x through double pointer
**pp = 200;
printf("\nAfter **pp = 200: x = %d\n", x);
return 0;
}Output
x = 100 *p = 100 **pp = 100 &x = 0x7ffd1000 p = 0x7ffd1000 *pp = 0x7ffd1000 &p = 0x7ffd1008 pp = 0x7ffd1008 After **pp = 200: x = 200
Why Do We Need Double Pointers?
Use Case 1: Modifying a Pointer Inside a Function
Just as you need a pointer to modify an int inside a function, you need a pointer-to-pointer to modify a pointer inside a function:
Example
#include <stdio.h>
#include <stdlib.h>
// This DOES NOT work — local copy of pointer
void allocateWrong(int *ptr, int size) {
ptr = (int *)malloc(size * sizeof(int)); // Only modifies local copy!
}
// This WORKS — modifies the original pointer
void allocateRight(int **ptr, int size) {
*ptr = (int *)malloc(size * sizeof(int)); // Modifies the actual pointer
}
int main() {
int *arr1 = NULL;
int *arr2 = NULL;
allocateWrong(arr1, 5);
printf("After allocateWrong: arr1 = %p (still NULL!)\n", (void*)arr1);
allocateRight(&arr2, 5);
printf("After allocateRight: arr2 = %p (allocated!)\n", (void*)arr2);
if (arr2) {
arr2[0] = 42;
printf("arr2[0] = %d\n", arr2[0]);
free(arr2);
}
return 0;
}
Output
After allocateWrong: arr1 = (nil) (still NULL!) After allocateRight: arr2 = 0x55a4e0001260 (allocated!) arr2[0] = 42
Use Case 2: Dynamic 2D Arrays
Double pointers are the standard way to create dynamically sized 2D arrays:
Example
#include <stdio.h>
#include <stdlib.h>
int** create2DArray(int rows, int cols) {
int **matrix = (int **)malloc(rows * sizeof(int *));
for (int i = 0; i < rows; i++) {
matrix[i] = (int *)malloc(cols * sizeof(int));
}
return matrix;
}
void free2DArray(int **matrix, int rows) {
for (int i = 0; i < rows; i++) {
free(matrix[i]);
}
free(matrix);
}
int main() {
int rows = 3, cols = 4;
int **matrix = create2DArray(rows, cols);
// Fill with values
int count = 1;
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
matrix[i][j] = count++;
}
}
// Print
printf("Dynamic 2D Array (%dx%d):\n", rows, cols);
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
printf("%3d", matrix[i][j]);
}
printf("\n");
}
free2DArray(matrix, rows);
return 0;
}
Output
Dynamic 2D Array (3x4): 1 2 3 4 5 6 7 8 9 10 11 12
Memory Layout of Dynamic 2D Array
| matrix | ┌─────────┐ |
| │ row0_ptr─┼── | [1][2][3][4] |
| │ row1_ptr─┼── | [5][6][7][8] |
| │ row2_ptr─┼── | [9][10][11][12] |
| Note | Each row can be at a DIFFERENT location in heap memory. |
Use Case 3: Array of Strings (Command-Line Arguments)
The main function's argv parameter is a classic double pointer:
Example
#include <stdio.h>
int main(int argc, char **argv) { // char **argv = char *argv[]
printf("Program: %s\n", argv[0]);
printf("Arguments (%d total):\n", argc);
for (int i = 1; i < argc; i++) {
printf(" argv[%d] = \"%s\"\n", i, argv[i]);
}
return 0;
}
Output
Program: ./myprogram Arguments (3 total): argv[1] = "hello" argv[2] = "world"
Use Case 4: Linked List Operations
Double pointers simplify linked list insertion/deletion by avoiding special cases for the head pointer:
c example
#include <stdio.h>
#include <stdlib.h>
typedef struct Node {
int data;
struct Node *next;
} Node;
// Without double pointer: need to return new head
Node* insertFront(Node *head, int value) {
Node *newNode = (Node *)malloc(sizeof(Node));
newNode->data = value;
newNode->next = head;
return newNode; // Caller must update head
}
// With double pointer: modifies head directly
void insertFrontDP(Node **head, int value) {
Node *newNode = (Node *)malloc(sizeof(Node));
newNode->data = value;
newNode->next = *head;
*head = newNode; // Directly modifies the caller's head pointer
}
void printList(Node *head) {
while (head) {
printf("%d → ", head->data);
head = head->next;
}
printf("NULL\n");
}
int main() {
Node *list = NULL;
insertFrontDP(&list, 30);
insertFrontDP(&list, 20);
insertFrontDP(&list, 10);
printList(list);
// Cleanup (simplified)
while (list) {
Node *temp = list;
list = list->next;
free(temp);
}
return 0;
}Output
10 → 20 → 30 → NULL
Triple Pointers (Rare but Valid)
c example
#include <stdio.h>
int main() {
int x = 5;
int *p = &x;
int **pp = &p;
int ***ppp = &pp;
printf("x = %d\n", x);
printf("*p = %d\n", *p);
printf("**pp = %d\n", **pp);
printf("***ppp = %d\n", ***ppp);
***ppp = 99;
printf("\nAfter ***ppp = 99: x = %d\n", x);
return 0;
}Output
x = 5 *p = 5 **pp = 5 ***ppp = 5 After ***ppp = 99: x = 99
Common Mistakes with Double Pointers
Example
// Mistake 1: Not allocating the inner pointers
int **matrix = (int **)malloc(3 * sizeof(int *));
// matrix[0][0] = 5; // CRASH! matrix[0] is uninitialized
// Correct: Allocate each row
for (int i = 0; i < 3; i++)
matrix[i] = (int *)malloc(4 * sizeof(int));
// Mistake 2: Freeing only the outer pointer
free(matrix); // Memory leak! Inner allocations not freed
// Correct: Free inner first, then outer
for (int i = 0; i < 3; i++) free(matrix[i]);
free(matrix);
Interview Questions
Q1: When would you use a double pointer instead of a single pointer?
When you need to modify a pointer itself inside a function (not just the value it points to). Common cases: dynamic memory allocation functions, linked list operations that change the head pointer, and creating dynamic 2D arrays.
Q2: What's the difference between a 2D array and a double pointer in terms of memory layout?
A static 2D array (int arr[3][4]) stores all elements contiguously in a single block. A double pointer (int **arr) stores row pointers contiguously, but each row's data can be scattered across the heap. This means static 2D arrays have better cache performance.
Q3: How does char argv work in main?**
argv is a pointer to an array of char* strings. argv[0] is the program name, argv[1] through argv[argc-1] are the command-line arguments. Each argv[i] is itself a char* pointing to a null-terminated string.
Q4: Can you have a pointer to a pointer to a pointer? When is it useful?
Yes (int ***ppp). It's occasionally useful for dynamic 3D arrays or when a function needs to modify a double pointer. However, beyond two levels of indirection, code becomes hard to read, and alternative designs (like structs) are usually preferred.
Summary
- A double pointer (
int **pp) stores the address of a pointer variable - Use double pointers when a function needs to modify a pointer (not just the pointed-to value)
- Dynamic 2D arrays use
int **with separatemallocfor each row main'sargvparameter is a classic double pointer (char **argv)- Always free inner allocations before outer ones to prevent memory leaks
- Double pointers simplify linked list operations by avoiding head-pointer special cases
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Double Pointers in C - Pointer to Pointer.
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, pointers, double, double pointers in c - pointer to pointer
Related C Programming Topics
Continue learning this concept
PointersPointer Arithmetic in C ProgrammingLearn pointer arithmetic in C including increment, decrement, addition, subtraction, pointer difference, and comparison with detailed memory diagrams and examples.PointersPointer Declaration and Initialization in CLearn how to declare and initialize pointers in C using * and & operators, pointer types, multiple pointer declarations, and const pointers with examples.PointersPointer Programs in C - Swap, String Reversal, Dynamic AllocationPractice essential pointer programs in C including swap using pointers, string operations with pointers, dynamic memory allocation, and pointer-based data manipulation.PointersPointers and Arrays in C - The Relationship ExplainedUnderstand the deep connection between pointers and arrays in C, array name as pointer, pointer-based array access, and key differences with practical examples.PointersPointers and Functions in C - Pass by ReferenceLearn how to use pointers with functions in C for pass-by-reference, returning pointers, function pointers, and callback patterns with practical examples.PointersIntroduction to Pointers in C ProgrammingUnderstand what pointers are in C, why they are essential, how memory addresses work, and the fundamentals of pointer concepts with visual memory diagrams.