C Program to Trim Whitespace From a String

C Program to Trim Whitespace From a String

By /

Trimming whitespace from a string is an essential operation in text processing. Often, user input or data from files contains unwanted spaces at the beginning or end of a string. Removing these spaces is necessary for proper formatting, comparison, or storage.

In C, strings are arrays of characters ending with a null terminator (\0). By scanning the string carefully and adjusting the start and end positions, we can remove leading and trailing whitespace efficiently. This tutorial will guide you step by step, using loops and pointers.

Understanding the Problem

The goal is to remove all whitespace characters (spaces, tabs, newlines) from the start and end of a string while keeping the internal spaces intact. For example, if the input string is " Hello World ", the trimmed string should be "Hello World".

The basic steps are:

  1. Identify the first non-whitespace character from the beginning of the string.
  2. Identify the last non-whitespace character from the end of the string.
  3. Shift the substring between these two positions to the start of the string.
  4. Terminate the string properly with \0.

This problem teaches string traversal, conditional checks, and in-place modification in C.

Program 1: Using Loops

A simple method uses loops to find the start and end indices of the trimmed string and then shifts characters as needed.

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

int main() {

    char str[200];
    int start = 0, end, i;

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

    // Remove newline character
    str[strcspn(str, "\n")] = '\0';

    // Find first non-whitespace
    while (isspace(str[start])) start++;

    // Find last non-whitespace
    end = strlen(str) - 1;

    while (end >= start && isspace(str[end])) end--;

    // Shift trimmed string to beginning
    int j = 0;

    for (i = start; i <= end; i++) {
        str[j++] = str[i];
    }

    str[j] = '\0';

    printf("Trimmed string: '%s'\n", str);

    return 0;

}

This method uses isspace() to detect all kinds of whitespace, including spaces, tabs, and newlines. The string is modified in-place.

Program 2: Using Pointers

Pointers can make trimming more efficient by directly referencing memory locations.

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

int main() {

    char str[200];
    char *start, *end, *dest;

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

    // Remove newline character
    str[strcspn(str, "\n")] = '\0';

    // Find first non-whitespace
    start = str;
    while (isspace(*start)) start++;

    // Find last non-whitespace
    end = str + strlen(str) - 1;
    while (end >= start && isspace(*end)) end--;

    // Shift trimmed string
    dest = str;

    while (start <= end) {
        *dest++ = *start++;
    }

    *dest = '\0';

    printf("Trimmed string: '%s'\n", str);

    return 0;

}

This pointer-based approach highlights the efficiency of using memory addresses for in-place string operations.

Program 3: Using a Function

For modularity, we can create a function to trim any given string.

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

void trimWhitespace(char *str) {

    char *start = str;
    char *end;
    char *dest;

    // Remove newline character
    str[strcspn(str, "\n")] = '\0';

    while (isspace(*start)) start++;

    end = str + strlen(str) - 1;
    while (end >= start && isspace(*end)) end--;

    dest = str;

    while (start <= end) {
        *dest++ = *start++;
    }

    *dest = '\0';

}

int main() {

    char str[200];

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

    trimWhitespace(str);

    printf("Trimmed string: '%s'\n", str);

    return 0;

}

Using a function improves code readability and makes trimming reusable across different programs.

Program 4: Using strncpy() and Manual Indices

We can use indices with strncpy() to copy the trimmed portion of the string. This approach avoids shifting character by character.

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

int main() {

    char str[200];
    int start = 0, end;

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

    // Remove newline character
    str[strcspn(str, "\n")] = '\0';

    while (isspace((unsigned char)str[start])) start++;

    end = strlen(str) - 1;

    while (end >= start && isspace((unsigned char)str[end])) end--;

    int length = end - start + 1;
    strncpy(str, str + start, length);
    str[length] = '\0';

    printf("Trimmed string: '%s'\n", str);

    return 0;

}

Here, strncpy() efficiently copies the trimmed portion, making the code concise.

Program 5: Using Recursion

Although less common, recursion can be applied to trim leading and trailing whitespace.

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

void trimRecursive(char *str) {

    int len = strlen(str);

    if (len == 0) return;

    if (isspace((unsigned char)str[0])) {

        trimRecursive(str + 1); 
        memmove(str, str + 1, strlen(str));

    }
    else if (isspace((unsigned char)str[len - 1])) {

        str[len - 1] = '\0';
        trimRecursive(str);

    }

}

int main() {

    char str[200];

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

    // Remove newline character
    str[strcspn(str, "\n")] = '\0';

    trimRecursive(str);

    printf("Trimmed string: '%s'\n", str);

    return 0;

}

This method shows an alternative way to think about the problem, though recursion is not the most efficient for long strings.

FAQs

1. Can this trimming remove tabs and newlines too?
Yes, by using isspace() from <ctype.h>, all types of whitespace such as spaces, tabs, and newlines are handled.

2. What if the string is entirely whitespace?
In that case, the result will be an empty string (""). The trimming logic ensures no invalid memory operations occur.

3. Is pointer-based trimming faster than loops?
Performance is almost the same since modern compilers optimize both methods well. Pointers mainly make the code cleaner and more flexible.

4. Can I keep only leading spaces and remove trailing ones (or vice versa)?
Yes, by adjusting the logic to check only from the left or right, you can selectively trim whitespace.

5. Is recursion practical for long strings?
Not really. Recursion works, but it is less efficient and can cause stack overflow on very large inputs. Iterative methods are safer.

6. Can I use built-in functions instead of writing trimming logic?
C does not provide a built-in trim() function, but you can write reusable helper functions or use libraries if available.

Conclusion

Trimming whitespace is a fundamental operation in C, essential for cleaning user input, preparing data for processing, and ensuring consistent string handling. By using loops, pointers, functions, and even recursion, you can efficiently remove leading and trailing whitespace in-place.

We explored several approaches: looping with indices, pointer-based traversal, function-based modular trimming, strncpy() with manual indices, and recursion. Understanding these techniques equips you to handle more advanced string processing tasks such as formatting, parsing, and input validation, while maintaining clean and efficient code.

References & Additional Resources

A curated list of reliable textbooks and tutorials for learning string trimming, pointers, and character handling in C.

  1. Kernighan, Brian W., and Dennis M. Ritchie. The C Programming Language, 2nd Edition, Prentice Hall, 1988 – The authoritative text covering core C concepts, including strings, arrays, and pointers.
  2. GeeksforGeeks: C Program to Trim Leading Whitespaces from String – Explains methods to strip whitespace from the beginning and end of strings in C.
  3. Tutorialspoint: C Strings – Overview of string declaration, initialization, and operations in C.
  4. Cprogramming.com: Pointers in C – Beginner-friendly guide to pointers, memory management, and their use in string operations.
  5. cplusplus.com: ctype.h Functions – Reference for standard C library functions to classify and manipulate characters.

Related Posts

Scroll to Top