An array of strings is a two-dimensional array of characters where each row stores one string. Alternatively, it can be an array of pointers to strings.
Two Ways to Create Array of Strings
| Method | Syntax | Memory Location | Can Modify? |
|---|---|---|---|
| 2D char array | char names[3][20] | Stack/Data segment | Yes |
| Array of pointers | char *names[3] | Pointers on stack, strings in read-only memory | Depends |
Method 1: 2D Character Array (Fixed Size)
#include <stdio.h>
int main() {
// 3 strings, each max 20 characters (including null terminator)
char fruits[3][20] = {
"Apple",
"Banana",
"Cherry"
};
// Accessing and printing
printf("First fruit: %s\n", fruits[0]);
printf("Second fruit: %s\n", fruits[1]);
printf("Third fruit: %s\n", fruits[2]);
return 0;
}
Output:
First fruit: Apple Second fruit: Banana Third fruit: Cherry
Method 2: Array of Pointers (Flexible)
#include <stdio.h>
int main() {
// Array of pointers to string literals
char *colors[] = {
"Red",
"Green",
"Blue",
"Yellow"
};
int size = sizeof(colors) / sizeof(colors[0]);
for(int i = 0; i < size; i++) {
printf("%s\n", colors[i]);
}
return 0;
}
Output:
Red Green Blue Yellow
Example 1: Loop Through All Strings
#include <stdio.h>
int main() {
char cities[4][15] = {
"New York",
"London",
"Tokyo",
"Paris"
};
int rows = 4;
for(int i = 0; i < rows; i++) {
printf("City %d: %s\n", i + 1, cities[i]);
}
return 0;
}
Output:
City 1: New York City 2: London City 3: Tokyo City 4: Paris
Example 2: User Input into String Array
#include <stdio.h>
int main() {
char names[5][50];
printf("Enter 5 names:\n");
for(int i = 0; i < 5; i++) {
printf("Name %d: ", i + 1);
fgets(names[i], 50, stdin); // Read with spaces
// Remove newline character if present
size_t len = strlen(names[i]);
if(len > 0 && names[i][len-1] == '\n') {
names[i][len-1] = '\0';
}
}
printf("\nYou entered:\n");
for(int i = 0; i < 5; i++) {
printf("Name %d: %s\n", i + 1, names[i]);
}
return 0;
}
Example 3: Modify Strings in Array
#include <stdio.h>
#include <string.h>
int main() {
char words[3][20] = {
"Hello",
"World",
"Coding"
};
printf("Before modification:\n");
for(int i = 0; i < 3; i++) {
printf("%s\n", words[i]);
}
// Modify strings
strcpy(words[0], "Hi");
strcpy(words[1], "Universe");
strcat(words[2], " is fun");
printf("\nAfter modification:\n");
for(int i = 0; i < 3; i++) {
printf("%s\n", words[i]);
}
return 0;
}
Output:
Before modification: Hello World Coding After modification: Hi Universe Coding is fun
Example 4: Passing Array of Strings to Function
#include <stdio.h>
#include <string.h>
void printStrings(char arr[][20], int rows) {
for(int i = 0; i < rows; i++) {
printf("%s\n", arr[i]);
}
}
void convertToUpper(char arr[][20], int rows) {
for(int i = 0; i < rows; i++) {
for(int j = 0; arr[i][j]; j++) {
if(arr[i][j] >= 'a' && arr[i][j] <= 'z') {
arr[i][j] = arr[i][j] - 32;
}
}
}
}
int main() {
char words[3][20] = {
"apple",
"banana",
"cherry"
};
printf("Original:\n");
printStrings(words, 3);
convertToUpper(words, 3);
printf("\nUppercase:\n");
printStrings(words, 3);
return 0;
}
Output:
Original: apple banana cherry Uppercase: APPLE BANANA CHERRY
Example 5: Sorting Array of Strings
#include <stdio.h>
#include <string.h>
void sortStrings(char arr[][50], int count) {
char temp[50];
for(int i = 0; i < count - 1; i++) {
for(int j = i + 1; j < count; j++) {
if(strcmp(arr[i], arr[j]) > 0) {
// Swap strings
strcpy(temp, arr[i]);
strcpy(arr[i], arr[j]);
strcpy(arr[j], temp);
}
}
}
}
int main() {
char fruits[5][50] = {
"Mango",
"Apple",
"Grape",
"Banana",
"Cherry"
};
printf("Before sorting:\n");
for(int i = 0; i < 5; i++) {
printf("%s\n", fruits[i]);
}
sortStrings(fruits, 5);
printf("\nAfter sorting:\n");
for(int i = 0; i < 5; i++) {
printf("%s\n", fruits[i]);
}
return 0;
}
Output:
Before sorting: Mango Apple Grape Banana Cherry After sorting: Apple Banana Cherry Grape Mango
Example 6: Array of Pointers (String Literals)
#include <stdio.h>
int main() {
// String literals - stored in read-only memory
char *months[] = {
"January",
"February",
"March",
"April",
"May",
"June"
};
int size = 6;
printf("Months of the year:\n");
for(int i = 0; i < size; i++) {
printf("%d. %s\n", i + 1, months[i]);
}
// months[0][0] = 'J'; // ❌ WRONG - Cannot modify string literal
return 0;
}
Output:
Months of the year: 1. January 2. February 3. March 4. April 5. May 6. June
Memory Comparison
// Method 1: 2D Array - Memory allocated contiguously
char arr1[3][10] = {"One", "Two", "Three"};
// Memory layout:
// [O][n][e][\0][ ][ ][ ][ ][ ][ ]
// [T][w][o][\0][ ][ ][ ][ ][ ][ ]
// [T][h][r][e][e][\0][ ][ ][ ][ ]
// Method 2: Array of Pointers
char *arr2[3] = {"One", "Two", "Three"};
// Memory layout:
// arr2[0] → "One" (somewhere in read-only memory)
// arr2[1] → "Two"
// arr2[2] → "Three"
String Array Operations Table
| Operation | Code | Notes |
|---|---|---|
| Declare 2D array | char arr[10][50] | 10 strings, max 49 chars each |
| Declare pointer array | char *arr[10] | 10 pointers to strings |
| Access string | arr[i] | Returns entire string |
| Access character | arr[i][j] | Returns single character |
| Copy string | strcpy(arr[i], "text") | Use for 2D arrays |
| Compare strings | strcmp(arr[i], arr[j]) | Returns 0 if equal |
| Get string length | strlen(arr[i]) | Length without null terminator |
| Input with spaces | fgets(arr[i], size, stdin) | Safer than scanf |
Common Mistakes
// ❌ WRONG - No space for null terminator
char arr[3][5] = {"Hello", "World"}; // "Hello" needs 6 bytes (5+1)
// ✅ CORRECT - Always allocate extra space
char arr[3][10] = {"Hello", "World"};
// ❌ WRONG - Trying to modify string literal
char *ptr[] = {"Apple", "Banana"};
ptr[0][0] = 'a'; // CRASH - String literal is read-only
// ✅ CORRECT - Use 2D array for modifiable strings
char arr[2][10] = {"Apple", "Banana"};
arr[0][0] = 'a'; // Works fine
// ❌ WRONG - Forgetting & in scanf
char names[5][20];
scanf("%s", names[0]); // ✅ Correct (array name is address)
scanf("%s", &names[0]); // Also works but & is optional
// ✅ CORRECT - fgets is safer
fgets(names[0], 20, stdin);
When to Use Each Method
| Use Case | Recommended Method | Reason |
|---|---|---|
| Need to modify strings | 2D char array char arr[10][50] | Strings are modifiable |
| Fixed list of constants | Array of pointers char *arr[] | Saves memory |
| Unknown string lengths | Array of pointers + dynamic allocation | More flexible |
| Pass to functions | Either works | Depends on needs |
| Small embedded systems | 2D char array | Fixed, predictable memory |
Quick Summary
| Concept | Syntax | Example |
|---|---|---|
| Declare 2D array | char arr[rows][cols] | char names[5][50] |
| Declare pointer array | char *arr[size] | char *colors[10] |
| Access string | arr[i] | printf("%s", names[2]) |
| Access character | arr[i][j] | char ch = names[0][1] |
| Loop through | for(i=0; i<rows; i++) | Iterate all strings |
| String input | fgets(arr[i], size, stdin) | Safe input |
| String copy | strcpy(arr[i], source) | Use for 2D arrays |
Complete Guide to Core & Advanced C Programming Concepts (Functions, Strings, Arrays, Loops, I/O, Control Flow)
https://macronepal.com/bash/building-blocks-of-c-a-complete-guide-to-functions/
Explains how functions in C work as reusable blocks of code, including declaration, definition, parameters, return values, and modular programming structure.
https://macronepal.com/bash/the-heart-of-text-processing-a-complete-guide-to-strings-in-c-2/
Explains how strings are handled in C using character arrays, string manipulation techniques, and common library functions for text processing.
https://macronepal.com/bash/the-cornerstone-of-data-organization-a-complete-guide-to-arrays-in-c/
Explains arrays in C as structured memory storage for multiple values, including indexing, initialization, and efficient data organization.
https://macronepal.com/bash/guaranteed-execution-a-complete-guide-to-the-do-while-loop-in-c/
Explains the do-while loop in C, where the loop body executes at least once before checking the condition.
https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-the-for-loop-in-c/
Explains the for loop in C, including initialization, condition checking, and increment/decrement for controlled iteration.
https://macronepal.com/bash/mastering-iteration-a-complete-guide-to-while-loops-in-c/
Explains the while loop in C, focusing on condition-based repetition and proper loop control mechanisms.
https://macronepal.com/bash/beyond-if-else-a-complete-guide-to-switch-case-in-c/
Explains switch-case statements in C, enabling multi-branch decision-making based on variable values.
https://macronepal.com/bash/mastering-conditional-logic-a-complete-guide-to-if-else-statements-in-c/
Explains if-else statements in C for decision-making and controlling program flow based on conditions.
https://macronepal.com/bash/mastering-the-fundamentals-a-complete-guide-to-arithmetic-operations-in-c/
Explains arithmetic operations in C such as addition, subtraction, multiplication, division, and operator precedence.
https://macronepal.com/bash/foundation-of-c-programming-a-complete-guide-to-basic-input-output/
Explains basic input and output in C using scanf and printf for interacting with users and displaying results.
Online C Code Compiler
https://macronepal.com/free-online-c-code-compiler-2/