XQA
Back to C Programming
2026-01-066 min read

String handling (C Programming)

Learn String handling (C Programming) step by step with clear examples and exercises.

Title: Mastering String Handling in C Programming - A full guide

Why This Matters

In this lesson, we delve into the essentials of string handling in C programming. Understanding how to manipulate strings is crucial for writing efficient and effective programs. It's an important skill that can help you solve real-world problems, excel in coding interviews, and debug common issues in your code.

By mastering string handling, you will be able to:

  1. Read user input and handle it appropriately.
  2. Manipulate strings for various purposes such as data validation, formatting, and error messages.
  3. Work with files containing text data, allowing you to read, write, and manipulate text data from and to files.
  4. Implement advanced algorithms that require string processing, like searching, sorting, and parsing.

Prerequisites

Before diving into string handling, it's essential to have a good grasp of the following topics:

  1. Basic C syntax and variables
  2. Data types (int, char, float, etc.)
  3. Control structures (if-else, loops)
  4. Functions and function prototypes
  5. Pointers and arrays
  6. File I/O (input and output)
  7. Understanding of bitwise operators and shift operations
  8. Familiarity with recursion
  9. Knowledge of basic data structures like stacks and queues
  10. Understanding of dynamic memory allocation using malloc, calloc, realloc, and free

Core Concept

What are Null-Terminated Byte Strings (NTBS)?

A null-terminated byte string (NTBS) is a sequence of nonzero bytes followed by a byte with value zero (the terminating null character). Each byte in a byte string encodes one character of some character set. For example, the character array { 'c', 'a', 't', '\0' } is an NTBS holding the string "cat" in ASCII encoding.

String Manipulation Functions

C provides various functions for manipulating strings. These functions can be broadly categorized into character classification, character manipulation, conversions to and from numeric formats, string manipulation, string examination, character array manipulation, and miscellaneous functions.

Character Classification

Functions like isalnum, isalpha, islower, isupper, isdigit, isxdigit, iscntrl, isgraph, isspace, isblank, isprint, and ispunct are used to classify characters.

Character Manipulation

Functions like tolower and toupper convert a character to its lowercase or uppercase equivalent, respectively.

Conversions to and from numeric formats

Functions like atoi, atol, atoll, atof, strtol, strtoll, strtoul, strtoull, strtoimax, strtoumax, strtof, strtod, and strtold convert a string to various numeric formats.

String Manipulation

Functions like strcpy, strncpy, strcat, strncat, strxfrm, strdup, and strndup are used for copying, concatenating, and transforming strings.

String Examination

Functions like strlen, strnlen_s, strcmp, strncmp, strcoll, strchr, strrchr, strspn, strcspn, strpbrk, strstr, and strtok are used for examining strings.

Character Array Manipulation

Functions like memchr, memcmp, memset, memcpy, memmove, and memccpy manipulate character arrays in memory.

Miscellaneous

Functions like strerror, strerror_s, and strerrorlen_s are used for error handling.

Practical I/O Patterns

In addition to the functions mentioned above, it's essential to understand how to read and write strings from/to files using functions like fgets, puts, printf, and scanf.

Worked Example

Let's consider a simple example of reading a string from the user, converting it to uppercase, and printing the result.

#include <stdio.h>
#include <ctype.h>

void uppercase(char str[]) {
int i;
for (i = 0; str[i] != '\0'; i++) {
str[i] = toupper(str[i]);
}
}

int main() {
char input[100];

printf("Enter a string: ");
fgets(input, sizeof(input), stdin);

uppercase(input);

printf("Uppercase: %s\n", input);

return 0;
}

Common Mistakes

  1. Forgetting to include necessary headers: Make sure you always include the correct header files for the functions you're using, such as `, , and `.
  2. Using incorrect function prototypes: Ensure that your function prototypes match the actual function definitions. For example:
void myFunction(char *str); // Incorrect prototype
void myFunction(char str[]) { ... } // Correct definition
  1. Not handling null characters properly: Remember that strings in C are terminated by a null character (\0). When copying or concatenating strings, make sure to account for the null character.
  2. Ignoring string length limits: Be aware of the maximum length of the strings you're using and ensure that your functions don't exceed these limits.
  3. Misusing scanf for string input: Avoid using scanf for reading strings from the user, as it is prone to issues like buffer overflows. Instead, use fgets.
  4. Not checking the return value of functions: Some functions return error codes or indicators that should be checked and handled appropriately. For example, when using malloc, always check if the returned pointer is null before using it.
  5. Using incorrect string comparison functions: Be aware that strcmp compares strings in lexicographical order, while strcoll considers the current locale when comparing strings.
  6. Not accounting for dynamic memory allocation: When working with large strings or dynamically allocated arrays, make sure to handle memory allocation and deallocation properly using functions like malloc, calloc, realloc, and free.
  7. Using outdated functions: Some string handling functions are considered outdated and should not be used in modern C programming. For example, strrchr can be replaced with memchr or strchr, while gets is dangerous and should never be used due to its buffer overflow vulnerability.

Practice Questions

  1. Write a function that reverses a given string.
  2. Write a program that checks if a given string is a palindrome (reads the same forwards and backwards).
  3. Write a function that counts the number of vowels in a given string.
  4. Write a program that finds the longest common substring between two strings.
  5. Write a function that removes all duplicate characters from a given string.
  6. Write a program that sorts an array of strings lexicographically using qsort.
  7. Write a function that replaces all occurrences of a specific character in a string with another character.
  8. Write a program that counts the number of words in a given string, where a word is defined as any sequence of non-whitespace characters.
  9. Write a function that concatenates two strings using dynamic memory allocation.
  10. Write a program that reads a file containing lines of text and prints each line reversed.

FAQ

  1. Why can't I use scanf for reading strings?

Using scanf for reading strings can lead to buffer overflows, as it doesn't account for the null character (\0) that terminates a string. Instead, use fgets.

  1. What are some common pitfalls when working with strings in C?

Common pitfalls include forgetting to handle null characters properly, ignoring string length limits, misusing scanf for string input, and not accounting for the null character when copying or concatenating strings. Additionally, using outdated functions and failing to check the return values of functions can lead to issues.

  1. Why do we need to use toupper and tolower in C?

We use toupper and tolower to convert characters to uppercase or lowercase, respectively. This can be useful for comparing strings that may have different cases, or for formatting user input.

  1. What is the difference between strcpy, strncpy, and memcpy?

strcpy copies a string from the source to the destination until the null character (\0) is reached. strncpy copies a maximum of n characters from the source to the destination, followed by a null character. memcpy copies a block of memory from the source to the destination without considering null characters or strings.

  1. What are some best practices for handling strings in C?

Best practices include using functions like fgets and strlen for reading and examining strings, being mindful of string length limits, properly handling null characters, and avoiding the use of scanf for string input. Additionally, checking the return values of functions, using modern functions instead of outdated ones, and allocating and deallocating memory appropriately are essential practices.