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/