Table of Contents

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 terminator
strtok() modifies original string (use copy if needed)
strtok() is not thread-safe (consider strtok_r())
String literals are read-only when using pointers
Use fgets() instead of gets() for input safety
memcpy() and memmove() work with any data type

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/