Table of Contents

What are Strings in C?

In C, a string is a sequence of characters stored in a character array, terminated by a null character (\0) . Unlike other languages, C has no built-in string data type—strings are just arrays of char.

String Representation in Memory

char str[] = "Hello";
// Memory layout:
// [H][e][l][l][o][\0]
// 0  1  2  3  4   5
// The null character marks the end

Declaring and Initializing Strings

#include <stdio.h>
int main() {
// Method 1: String literal (automatically adds \0)
char str1[] = "Hello";
// Method 2: Character array with size
char str2[10] = "Hello";
// Method 3: Character array without size
char str3[] = {'H', 'e', 'l', 'l', 'o', '\0'};
// Method 4: Fixed size (remaining are \0)
char str4[10] = {'H', 'e', 'l', 'l', 'o', '\0'};
// Method 5: Empty string
char empty[10] = "";
char empty2[10] = {'\0'};
printf("str1: %s\n", str1);
printf("str2: %s\n", str2);
printf("str3: %s\n", str3);
return 0;
}

String Input and Output

Basic Input/Output

#include <stdio.h>
int main() {
char name[50];
// Simple output
printf("Enter your name: ");
// Input (stops at first whitespace)
scanf("%s", name);  // Note: no & for array
printf("Hello, %s!\n", name);
return 0;
}

Problem with scanf (stops at space)

#include <stdio.h>
int main() {
char fullname[50];
printf("Enter full name: ");
scanf("%s", fullname);  // Only reads first word
printf("You entered: %s\n", fullname);  // "John" only, not "John Doe"
return 0;
}

Solution: fgets() for Full Line Input

#include <stdio.h>
int main() {
char fullname[50];
printf("Enter full name: ");
fgets(fullname, sizeof(fullname), stdin);  // Reads spaces
printf("Hello, %s", fullname);  // Note: fgets includes newline
return 0;
}

Removing Newline from fgets

#include <stdio.h>
#include <string.h>
int main() {
char fullname[50];
printf("Enter full name: ");
fgets(fullname, sizeof(fullname), stdin);
// Remove trailing newline
size_t len = strlen(fullname);
if(len > 0 && fullname[len-1] == '\n') {
fullname[len-1] = '\0';
}
printf("Hello, %s!\n", fullname);
return 0;
}

String Functions (string.h Library)

1. strlen() - Get String Length

#include <stdio.h>
#include <string.h>
int main() {
char str[] = "Hello World";
int len = strlen(str);  // Returns 11 (doesn't count \0)
printf("Length: %d\n", len);
// Manual way (without string.h)
int manual_len = 0;
while(str[manual_len] != '\0') {
manual_len++;
}
printf("Manual length: %d\n", manual_len);
return 0;
}

2. strcpy() - Copy String

#include <stdio.h>
#include <string.h>
int main() {
char source[] = "Hello C Programming";
char destination[50];
// Copy source to destination
strcpy(destination, source);
printf("Source: %s\n", source);
printf("Destination: %s\n", destination);
// Manual copy
char manual[50];
int i = 0;
while(source[i] != '\0') {
manual[i] = source[i];
i++;
}
manual[i] = '\0';
printf("Manual copy: %s\n", manual);
return 0;
}

3. strcat() - Concatenate Strings

#include <stdio.h>
#include <string.h>
int main() {
char str1[50] = "Hello ";
char str2[] = "World!";
// Append str2 to str1
strcat(str1, str2);
printf("Concatenated: %s\n", str1);  // "Hello World!"
// Manual concatenation
char manual[50] = "Hello ";
char str3[] = "C Programming";
int j = strlen(manual);
int k = 0;
while(str3[k] != '\0') {
manual[j] = str3[k];
j++;
k++;
}
manual[j] = '\0';
printf("Manual: %s\n", manual);
return 0;
}

4. strcmp() - Compare Strings

#include <stdio.h>
#include <string.h>
int main() {
char str1[] = "Apple";
char str2[] = "Apple";
char str3[] = "Banana";
// Returns 0 if strings are equal
if(strcmp(str1, str2) == 0) {
printf("str1 and str2 are equal\n");
}
// Returns negative if str1 < str3
int result = strcmp(str1, str3);
printf("Compare Apple vs Banana: %d\n", result);  // Negative
// Returns positive if str3 > str1
result = strcmp(str3, str1);
printf("Compare Banana vs Apple: %d\n", result);  // Positive
// Manual comparison
int i = 0;
while(str1[i] == str2[i] && str1[i] != '\0') {
i++;
}
if(str1[i] == str2[i]) {
printf("Manually equal\n");
}
return 0;
}

5. strchr() - Find Character

#include <stdio.h>
#include <string.h>
int main() {
char str[] = "Hello World";
// Find first occurrence of 'o'
char *ptr = strchr(str, 'o');
if(ptr != NULL) {
printf("Found 'o' at position: %ld\n", ptr - str);  // 4
printf("Rest of string: %s\n", ptr);
}
return 0;
}

6. strstr() - Find Substring

#include <stdio.h>
#include <string.h>
int main() {
char str[] = "The quick brown fox jumps";
// Find substring "brown"
char *ptr = strstr(str, "brown");
if(ptr != NULL) {
printf("Found at position: %ld\n", ptr - str);
printf("From found point: %s\n", ptr);
} else {
printf("Substring not found\n");
}
return 0;
}

Common String Operations

Reading and Manipulating Strings

#include <stdio.h>
#include <string.h>
#include <ctype.h>
int main() {
char str[100];
printf("Enter a sentence: ");
fgets(str, sizeof(str), stdin);
// Remove newline
str[strcspn(str, "\n")] = '\0';
// Convert to uppercase
for(int i = 0; str[i] != '\0'; i++) {
str[i] = toupper(str[i]);
}
printf("Uppercase: %s\n", str);
// Count vowels
int vowels = 0;
for(int i = 0; str[i] != '\0'; i++) {
char c = tolower(str[i]);
if(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
vowels++;
}
}
printf("Vowels: %d\n", vowels);
// Reverse string
int len = strlen(str);
for(int i = 0; i < len/2; i++) {
char temp = str[i];
str[i] = str[len-1-i];
str[len-1-i] = temp;
}
printf("Reversed: %s\n", str);
return 0;
}

Practical Example 1: String Palindrome Check

#include <stdio.h>
#include <string.h>
#include <ctype.h>
int isPalindrome(char str[]) {
int left = 0;
int right = strlen(str) - 1;
while(left < right) {
// Skip non-alphabetic characters
while(left < right && !isalpha(str[left])) left++;
while(left < right && !isalpha(str[right])) right--;
// Compare ignoring case
if(tolower(str[left]) != tolower(str[right])) {
return 0;  // Not palindrome
}
left++;
right--;
}
return 1;  // Is palindrome
}
int main() {
char str1[] = "A man a plan a canal panama";
char str2[] = "Hello World";
// Remove spaces for testing
printf("Testing: \"%s\"\n", str1);
if(isPalindrome(str1)) {
printf("Is a palindrome!\n");
} else {
printf("Not a palindrome\n");
}
printf("\nTesting: \"%s\"\n", str2);
if(isPalindrome(str2)) {
printf("Is a palindrome!\n");
} else {
printf("Not a palindrome\n");
}
return 0;
}

Practical Example 2: String Tokenization

#include <stdio.h>
#include <string.h>
int main() {
char str[] = "Apple,Banana,Cherry,Date";
char *token;
printf("Original: %s\n", str);
printf("Tokens:\n");
// strtok modifies the original string
token = strtok(str, ",");
while(token != NULL) {
printf("- %s\n", token);
token = strtok(NULL, ",");
}
return 0;
}

Output:

Original: Apple,Banana,Cherry,Date
Tokens:
- Apple
- Banana
- Cherry
- Date

Array of Strings (2D Character Array)

#include <stdio.h>
#include <string.h>
int main() {
// Array of strings (3 strings, max 20 chars each)
char fruits[3][20] = {
"Apple",
"Banana",
"Cherry"
};
// Print all fruits
for(int i = 0; i < 3; i++) {
printf("Fruit %d: %s\n", i+1, fruits[i]);
}
// Modify a string
strcpy(fruits[1], "Blueberry");
printf("\nAfter modification:\n");
for(int i = 0; i < 3; i++) {
printf("Fruit %d: %s\n", i+1, fruits[i]);
}
return 0;
}

String Literals vs Character Arrays

#include <stdio.h>
#include <string.h>
int main() {
// Character array (modifiable)
char str1[] = "Hello";
str1[0] = 'J';  // OK - becomes "Jello"
printf("str1: %s\n", str1);
// String literal (read-only - can cause crash)
char *str2 = "World";
// str2[0] = 'J';  // BAD! Undefined behavior
// Correct way: str2 points to first character
printf("str2: %s\n", str2);
// Copy literal to array for modification
char buffer[20];
strcpy(buffer, "Hello World");
buffer[0] = 'M';  // OK
printf("buffer: %s\n", buffer);
return 0;
}

Common String Pitfalls

#include <stdio.h>
#include <string.h>
int main() {
// PITFALL 1: Forgetting null terminator
char bad[3] = {'A', 'B', 'C'};  // No \0 - NOT a string!
// printf("%s", bad);  // Dangerous! Prints until random \0
char good[4] = {'A', 'B', 'C', '\0'};  // Proper string
printf("Good: %s\n", good);
// PITFALL 2: Buffer overflow
char small[5];
// strcpy(small, "This is too long");  // BAD! Overflow
// Use strncpy for safety
strncpy(small, "This is too long", 4);
small[4] = '\0';  // Manually null terminate
printf("Safe copy: %s\n", small);
// PITFALL 3: Comparing strings with ==
char str1[] = "Hello";
char str2[] = "Hello";
if(str1 == str2) {  // WRONG! Compares addresses, not content
printf("This won't print\n");
}
if(strcmp(str1, str2) == 0) {  // CORRECT
printf("Correct comparison\n");
}
return 0;
}

Quick Reference Table

Function	Purpose	Example
`strlen(s)`	Length of string	`int len = strlen("Hi");` // 2
`strcpy(dest, src)`	Copy src to dest	`strcpy(dest, "Hello");`
`strcat(dest, src)`	Append src to dest	`strcat(str, " World");`
`strcmp(s1, s2)`	Compare strings	`if(strcmp(a, b) == 0)`
`strchr(s, c)`	Find char in string	`char *p = strchr(str, 'a');`
`strstr(s, sub)`	Find substring	`char *p = strstr(str, "sub");`
`strtok(s, del)`	Split string	`token = strtok(str, ",");`
`strncpy(dest, src, n)`	Copy n chars	`strncpy(dest, src, 5);`
`strncat(dest, src, n)`	Append n chars	`strncat(dest, src, 3);`
`strncmp(s1, s2, n)`	Compare n chars	`if(strncmp(a, b, 3) == 0)`

Key Points

Strings are char arrays terminated by \0 (null character)
Use double quotes for string literals: "text"
Include <string.h> for string functions
Always ensure enough space for null terminator
fgets() is safer than scanf() for input with spaces
Strings are 0-indexed like arrays
Never compare strings with ==—use strcmp()

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

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/