What are String Functions?
C provides a rich set of built-in string functions in the <string.h> header file to perform common string operations like copying, concatenating, comparing, searching, and more.
Include Header
#include <string.h>
Complete String Functions Reference
1. strlen() - String Length
Syntax: size_t strlen(const char *str);
Returns the number of characters in a string (excluding null terminator).
#include <stdio.h>
#include <string.h>
int main() {
char str1[] = "Hello";
char str2[] = "Cloud Computing";
char str3[] = "";
printf("Length of '%s': %lu\n", str1, strlen(str1)); // 5
printf("Length of '%s': %lu\n", str2, strlen(str2)); // 15
printf("Length of empty: %lu\n", strlen(str3)); // 0
// Manual implementation
int len = 0;
while(str1[len] != '\0') len++;
printf("Manual length: %d\n", len); // 5
return 0;
}
2. strcpy() - String Copy
Syntax: char *strcpy(char *dest, const char *src);
Copies string from source to destination (including null terminator).
#include <stdio.h>
#include <string.h>
int main() {
char source[] = "Cloud Computing";
char dest[50];
strcpy(dest, source);
printf("Source: %s\n", source); // Cloud Computing
printf("Destination: %s\n", dest); // Cloud Computing
// Chaining
char dest2[50];
strcpy(dest2, strcpy(dest, "Hello"));
printf("Chained: %s, %s\n", dest, dest2); // Hello, Hello
return 0;
}
3. strncpy() - Safe String Copy
Syntax: char *strncpy(char *dest, const char *src, size_t n);
Copies at most n characters from source to destination.
#include <stdio.h>
#include <string.h>
int main() {
char source[] = "CloudComputing";
char dest[10];
strncpy(dest, source, 5);
dest[5] = '\0'; // MUST add null terminator
printf("First 5 chars: %s\n", dest); // Cloud
// Without manual null termination
char dest2[5];
strncpy(dest2, source, 5);
// dest2[5] = '\0'; // If omitted, prints garbage
printf("Without null: %s\n", dest2); // Undefined behavior
return 0;
}
4. strcat() - String Concatenation
Syntax: char *strcat(char *dest, const char *src);
Appends source string to the end of destination string.
#include <stdio.h>
#include <string.h>
int main() {
char str1[50] = "Hello ";
char str2[] = "World";
strcat(str1, str2);
printf("%s\n", str1); // Hello World
// Multiple concatenations
char str3[100] = "C";
strcat(str3, " Programming");
strcat(str3, " Language");
printf("%s\n", str3); // C Programming Language
return 0;
}
5. strncat() - Safe Concatenation
Syntax: char *strncat(char *dest, const char *src, size_t n);
Appends at most n characters from source to destination.
#include <stdio.h>
#include <string.h>
int main() {
char str1[50] = "Hello ";
char str2[] = "Beautiful World";
strncat(str1, str2, 9); // Append only 9 chars
printf("%s\n", str1); // Hello Beautiful
// Automatically adds null terminator
char dest[20] = "Hi ";
strncat(dest, "there everyone", 5);
printf("%s\n", dest); // Hi there
return 0;
}
6. strcmp() - String Compare
Syntax: int strcmp(const char *str1, const char *str2);
Compares two strings lexicographically.
Return Values:
0→ strings are equal<0→ str1 < str2>0→ str1 > str2
#include <stdio.h>
#include <string.h>
int main() {
char str1[] = "Apple";
char str2[] = "Apple";
char str3[] = "Banana";
char str4[] = "Apple pie";
printf("str1 vs str2: %d\n", strcmp(str1, str2)); // 0 (equal)
printf("str1 vs str3: %d\n", strcmp(str1, str3)); // Negative
printf("str3 vs str1: %d\n", strcmp(str3, str1)); // Positive
printf("str1 vs str4: %d\n", strcmp(str1, str4)); // Negative (space < null)
// Practical use
char input[20];
printf("Enter 'quit' to exit: ");
scanf("%s", input);
if(strcmp(input, "quit") == 0) {
printf("Exiting...\n");
} else {
printf("You entered: %s\n", input);
}
return 0;
}
7. strncmp() - Compare First n Characters
Syntax: int strncmp(const char *str1, const char *str2, size_t n);
Compares only first n characters.
#include <stdio.h>
#include <string.h>
int main() {
char str1[] = "Computer";
char str2[] = "Computing";
// Compare first 4 characters
if(strncmp(str1, str2, 4) == 0) {
printf("First 4 chars are same: 'Comp'\n");
}
// Compare first 7 characters
printf("First 7 chars: %d\n", strncmp(str1, str2, 7)); // Different
// Check file extension
char filename[] = "document.txt";
if(strncmp(filename + 8, "txt", 3) == 0) { // filename+8 points to "txt"
printf("It's a text file\n");
}
return 0;
}
8. strchr() - Find Character in String
Syntax: char *strchr(const char *str, int c);
Returns pointer to first occurrence of character c in string.
#include <stdio.h>
#include <string.h>
int main() {
char str[] = "Cloud Computing";
char *ptr = strchr(str, 'C');
if(ptr != NULL) {
printf("First 'C' found at position: %ld\n", ptr - str); // 0
printf("From 'C' onwards: %s\n", ptr); // Cloud Computing
}
// Find second occurrence
ptr = strchr(ptr + 1, 'C');
if(ptr != NULL) {
printf("Second 'C' at position: %ld\n", ptr - str); // 6
printf("From second 'C': %s\n", ptr); // Computing
}
// Character not found
ptr = strchr(str, 'z');
if(ptr == NULL) {
printf("Character 'z' not found\n");
}
return 0;
}
9. strrchr() - Find Last Occurrence
Syntax: char *strrchr(const char *str, int c);
Returns pointer to last occurrence of character.
#include <stdio.h>
#include <string.h>
int main() {
char str[] = "C programming is powerful";
char *ptr = strrchr(str, 'p');
if(ptr != NULL) {
printf("Last 'p' at position: %ld\n", ptr - str);
printf("From last 'p': %s\n", ptr); // powerful
}
// Extract file extension
char filename[] = "archive.tar.gz";
char *dot = strrchr(filename, '.');
if(dot != NULL) {
printf("Extension: %s\n", dot + 1); // gz
}
return 0;
}
10. strstr() - Find Substring
Syntax: char *strstr(const char *haystack, const char *needle);
Returns pointer to first occurrence of substring.
#include <stdio.h>
#include <string.h>
int main() {
char text[] = "The cloud computing is the future of computing";
char *found = strstr(text, "cloud");
if(found != NULL) {
printf("Found 'cloud' at position: %ld\n", found - text); // 4
printf("Remaining: %s\n", found); // cloud computing...
}
// Count occurrences
char search[] = "computing";
int count = 0;
char *ptr = text;
while((ptr = strstr(ptr, search)) != NULL) {
count++;
ptr++; // Move to next character
}
printf("'%s' appears %d times\n", search, count); // 2 times
return 0;
}
11. strtok() - Tokenize String
Syntax: char *strtok(char *str, const char *delim);
Breaks string into tokens based on delimiters.
#include <stdio.h>
#include <string.h>
int main() {
char str[] = "Apple,Banana,Orange,Grape";
char str2[] = "Hello World | Cloud Computing | C Programming";
// First call with string
char *token = strtok(str, ",");
// Subsequent calls with NULL
while(token != NULL) {
printf("%s\n", token);
token = strtok(NULL, ",");
}
printf("\n");
// Multiple delimiters
char *token2 = strtok(str2, " |");
while(token2 != NULL) {
printf("%s\n", token2);
token2 = strtok(NULL, " |");
}
return 0;
}
/* Output:
Apple
Banana
Orange
Grape
Hello
World
Cloud
Computing
C
Programming
*/
12. memset() - Fill Memory with Value
Syntax: void *memset(void *ptr, int value, size_t num);
Fills block of memory with specified value.
#include <stdio.h>
#include <string.h>
int main() {
char str[50] = "Hello World";
printf("Before: %s\n", str); // Hello World
// Fill first 5 characters with '*'
memset(str, '*', 5);
printf("After: %s\n", str); // ***** World
// Clear entire array
char buffer[20];
memset(buffer, 0, sizeof(buffer)); // Initialize to zeros
printf("Buffer cleared\n");
// Fill with specific character
char stars[20];
memset(stars, '*', 19);
stars[19] = '\0';
printf("%s\n", stars); // *******************
return 0;
}
13. memcpy() - Copy Memory Block
Syntax: void *memcpy(void *dest, const void *src, size_t n);
Copies n bytes from source to destination (no null termination check).
#include <stdio.h>
#include <string.h>
int main() {
char src[] = "Cloud Computing";
char dest[20];
memcpy(dest, src, strlen(src) + 1); // Copy including null
printf("Copied: %s\n", dest); // Cloud Computing
// Copy only part
char partial[10];
memcpy(partial, src, 5);
partial[5] = '\0';
printf("Partial: %s\n", partial); // Cloud
// Arrays
int numbers[] = {1, 2, 3, 4, 5};
int copy[5];
memcpy(copy, numbers, sizeof(numbers));
for(int i = 0; i < 5; i++) {
printf("%d ", copy[i]); // 1 2 3 4 5
}
return 0;
}
14. memmove() - Overlapping Memory Copy
Syntax: void *memmove(void *dest, const void *src, size_t n);
Same as memcpy() but handles overlapping memory regions safely.
#include <stdio.h>
#include <string.h>
int main() {
char str[] = "1234567890";
// Overlapping regions (memcpy might fail here)
memmove(str + 2, str, 5);
printf("After memmove: %s\n", str); // 1212345890
// Shift right
char shift[] = "Hello";
memmove(shift + 1, shift, 5);
printf("Shifted: %s\n", shift); // HHello
// memcpy with overlapping = undefined behavior
// memcpy(str + 2, str, 5); // DON'T DO THIS
return 0;
}
15. memcmp() - Compare Memory Blocks
Syntax: int memcmp(const void *ptr1, const void *ptr2, size_t n);
Compares two blocks of memory.
#include <stdio.h>
#include <string.h>
int main() {
char str1[] = "Hello";
char str2[] = "Hello";
char str3[] = "World";
int result = memcmp(str1, str2, 5);
printf("str1 vs str2: %d\n", result); // 0 (equal)
result = memcmp(str1, str3, 5);
printf("str1 vs str3: %d\n", result); // Non-zero
// Compare integers
int arr1[] = {1, 2, 3};
int arr2[] = {1, 2, 3};
if(memcmp(arr1, arr2, sizeof(arr1)) == 0) {
printf("Arrays are identical\n");
}
return 0;
}
String Conversion Functions (<stdlib.h>)
atoi() - String to Integer
#include <stdio.h>
#include <stdlib.h>
int main() {
char num1[] = "123";
char num2[] = "45.67";
char invalid[] = "abc";
int a = atoi(num1);
int b = atoi(num2); // Stops at decimal
int c = atoi(invalid); // Returns 0
printf("atoi('123'): %d\n", a); // 123
printf("atoi('45.67'): %d\n", b); // 45
printf("atoi('abc'): %d\n", c); // 0
return 0;
}
atof() - String to Float/Double
#include <stdio.h>
#include <stdlib.h>
int main() {
char str[] = "3.14159";
double pi = atof(str);
printf("atof: %f\n", pi); // 3.141590
return 0;
}
itoa() - Integer to String (Non-standard)
#include <stdio.h>
#include <stdlib.h>
int main() {
int num = 12345;
char str[20];
sprintf(str, "%d", num); // Standard way
printf("Converted: %s\n", str); // 12345
return 0;
}
Complete Example: Practical String Manipulation
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int main() {
char sentence[200] = " Hello World from C Programming! ";
// Remove leading/trailing spaces
char *start = sentence;
while(isspace(*start)) start++;
char *end = sentence + strlen(sentence) - 1;
while(end > start && isspace(*end)) end--;
end[1] = '\0';
// Copy trimmed string
char trimmed[200];
strcpy(trimmed, start);
printf("Original: '%s'\n", sentence);
printf("Trimmed: '%s'\n", trimmed);
// Convert to uppercase
for(int i = 0; trimmed[i]; i++) {
trimmed[i] = toupper(trimmed[i]);
}
printf("Uppercase: %s\n", trimmed);
// Tokenize
printf("\nTokens:\n");
char *token = strtok(trimmed, " ");
while(token != NULL) {
printf("- %s\n", token);
token = strtok(NULL, " ");
}
// Check if contains "WORLD"
if(strstr(trimmed, "WORLD")) {
printf("\nFound 'WORLD' in string\n");
}
return 0;
}
Quick Reference Table
| Function | Purpose | Return Value |
|---|---|---|
strlen(s) | Length of s | Number of chars |
strcpy(d,s) | Copy s to d | Pointer to d |
strncpy(d,s,n) | Copy n chars | Pointer to d |
strcat(d,s) | Append s to d | Pointer to d |
strncat(d,s,n) | Append n chars | Pointer to d |
strcmp(s1,s2) | Compare strings | 0, <0, >0 |
strncmp(s1,s2,n) | Compare n chars | 0, <0, >0 |
strchr(s,c) | Find char c | Pointer or NULL |
strrchr(s,c) | Find last c | Pointer or NULL |
strstr(s1,s2) | Find substring | Pointer or NULL |
strtok(s,d) | Tokenize | Token or NULL |
memset(p,v,n) | Fill memory | Pointer to p |
memcpy(d,s,n) | Copy memory | Pointer to d |
memmove(d,s,n) | Copy (overlap) | Pointer to d |
memcmp(p1,p2,n) | Compare memory | 0, <0, >0 |
Key Points
- Always include
<string.h>for string functions - Destination arrays must be large enough to hold result
strncpy()does NOT automatically add null terminatorstrtok()modifies original string (use copy if needed)strtok()is not thread-safe (considerstrtok_r())- String literals are read-only when using pointers
- Use
fgets()instead ofgets()for input safety memcpy()andmemmove()work with any data type
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/