Program To Replace A Substring In A String In C

Manipulating strings in C can often be more involved than in higher-level languages due to manual memory management and null-termination requirements. In this article, you will learn various robust methods to replace a specific substring within a larger string in C.

Problem Statement

The challenge of replacing a substring in C arises from the fact that C strings are essentially null-terminated character arrays. Unlike languages with built-in string objects and dynamic resizing, C requires explicit memory management when the replacement substring has a different length than the original substring. A common scenario might be sanitizing user input by replacing offensive words, or dynamically updating configuration file entries.

Example

Imagine you have the string "Hello world, hello C!" and you want to replace "hello" with "greetings". The desired output would be:

"Greetings world, greetings C!"

Background & Knowledge Prerequisites

To effectively understand and implement substring replacement in C, you should be familiar with the following:

• C String Basics: How strings are represented as char arrays and null-termination (\0).
• Pointers: Understanding pointer arithmetic and how pointers are used to traverse strings.
• Dynamic Memory Allocation: Functions like malloc(), calloc(), realloc(), and free() for managing memory on the heap.
• Standard String Library Functions:
• strlen(): Calculates the length of a string.
• strstr(): Finds the first occurrence of a substring.
• strcpy()/strncpy(): Copies strings.
• strcat()/strncat(): Concatenates strings.
• memcpy(): Copies a block of memory.
• snprintf(): Writes formatted data to a string buffer with size limit.

Use Cases or Case Studies

Substring replacement is a fundamental operation with numerous applications:

• Text Processing: Replacing keywords in documents, sanitizing user input by removing or replacing specific patterns (e.g., profanity filters).
• Configuration File Management: Updating values in a configuration file, such as changing SERVER_IP=192.168.1.1 to SERVER_IP=10.0.0.1.
• Data Transformation: Formatting data by replacing delimiters or specific markers (e.g., changing "date-month-year" to "date/month/year").
• URL Manipulation: Rewriting parts of a URL, such as replacing a domain name or path segment.
• Templating Engines: Substituting placeholders in a template string with actual data (e.g., replacing {{name}} with "John Doe").

Solution Approaches

Here, we explore three distinct approaches to replacing a substring in C, ranging from simpler fixed-length replacements to more robust dynamic solutions.

Approach 1: Replacing a Substring of the Same Length (In-Place)

This approach is suitable when the replacement string has the exact same length as the substring being replaced. It can often be done in-place without reallocating memory.

• Summary: Locates the substring and overwrites it directly with the new substring.

// Substring Replacement (Same Length)
#include <stdio.h>
#include <string.h> // For strlen, strstr, strncpy

// Function to replace the first occurrence of a substring
// Assumes replace_with has the same length as find_str
void replace_same_length(char *text, const char *find_str, const char *replace_with) {
    char *match = strstr(text, find_str); // Step 1: Find the first occurrence of find_str

    if (match != NULL) { // Step 2: If found
        // Step 3: Copy replace_with into the location where find_str was found
        // Use strncpy to prevent buffer overflow if lengths mismatch (though assumed same here)
        strncpy(match, replace_with, strlen(replace_with));
    }
}

int main() {
    char buffer[100] = "Hello world, hello C!";
    const char *find = "hello";
    const char *replace = "greet"; // "greetings" is longer, "greet" is same length as "hello"

    printf("Original string: %s\\n", buffer);

    replace_same_length(buffer, find, replace); // Step 1: Call the replacement function

    printf("String after replacement: %s\\n", buffer);

    // Another example
    char sentence[100] = "The quick brown fox jumps over the lazy dog.";
    replace_same_length(sentence, "fox", "cat");
    printf("Sentence after 'fox' -> 'cat': %s\\n", sentence);

    return 0;
}

Run

• Sample Output:

Original string: Hello world, hello C!
String after replacement: Greet world, greet C!
Sentence after 'fox' -> 'cat': The quick brown cat jumps over the lazy dog.

• Stepwise Explanation:

1. The replace_same_length function takes the main string, the substring to find, and the replacement string.
2. strstr(text, find_str) is used to locate the first occurrence of find_str within text. If found, it returns a pointer to the start of the substring; otherwise, it returns NULL.
3. If a match is found, strncpy(match, replace_with, strlen(replace_with)) is used to copy the replace_with string directly over the matched portion. This works because both strings are of the same length, ensuring no overflow or shifting of subsequent characters is needed.

Approach 2: Replacing a Substring with Different Lengths (Dynamic Allocation)

This is a more general and common scenario where the replacement string can be shorter or longer than the original substring. It requires dynamic memory allocation for the new string.

• Summary: Calculates the new string length, allocates memory, then constructs the new string by copying parts of the original string and the replacement string.

// Substring Replacement (Different Lengths)
#include <stdio.h>
#include <stdlib.h> // For malloc, free
#include <string.h> // For strlen, strstr, memcpy, strcpy

// Function to replace all occurrences of a substring
char* replace_substring(const char *original, const char *find, const char *replace) {
    char *result;
    char *ins;    // Pointer to current insertion point in `result`
    char *tmp;    // Current search position in `original`
    int len_find = strlen(find);
    int len_replace = strlen(replace);
    int len_original = strlen(original);
    int count;    // Number of matches
    int new_len = 0;

    // Step 1: Count occurrences of 'find' to calculate the new total length
    for (count = 0, ins = (char*)original; (tmp = strstr(ins, find)) != NULL; count++) {
        ins = tmp + len_find;
    }

    // Step 2: Calculate the new string length
    new_len = len_original + (len_replace - len_find) * count;

    // Step 3: Allocate memory for the new string (+1 for null terminator)
    result = (char*)malloc(new_len + 1);
    if (!result) return NULL; // Handle allocation failure

    // Step 4: Construct the new string
    ins = result;
    tmp = (char*)original;
    while (count--) { // Loop through each match
        char *match = strstr(tmp, find); // Find the next match
        int len_prefix = match - tmp;   // Length of the segment before the match

        // Copy prefix
        memcpy(ins, tmp, len_prefix);
        ins += len_prefix;

        // Copy replacement string
        memcpy(ins, replace, len_replace);
        ins += len_replace;

        // Move `tmp` past the current `find` occurrence
        tmp = match + len_find;
    }

    // Step 5: Copy the remaining part of the original string
    strcpy(ins, tmp);

    return result; // Return the newly allocated string
}

int main() {
    const char *str = "Hello world, hello C! This is a hello world example.";
    const char *find = "hello";
    const char *replace = "greetings"; // Longer replacement

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

    char *new_str = replace_substring(str, find, replace); // Step 1: Call replacement function

    if (new_str) {
        printf("String after replacement: %s\\n", new_str);
        free(new_str); // Step 2: Free the dynamically allocated memory
    } else {
        printf("Memory allocation failed or no replacements made.\\n");
    }

    const char *str2 = "aaabbbaaa";
    const char *find2 = "bbb";
    const char *replace2 = "c"; // Shorter replacement

    printf("Original string 2: %s\\n", str2);
    char *new_str2 = replace_substring(str2, find2, replace2);
    if (new_str2) {
        printf("String 2 after replacement: %s\\n", new_str2);
        free(new_str2);
    }

    return 0;
}

Run

• Sample Output:

Original string: Hello world, hello C! This is a hello world example.
String after replacement: Greetings world, greetings C! This is a greetings world example.
Original string 2: aaabbbaaa
String 2 after replacement: aaacaaa

• Stepwise Explanation:

1. Count Occurrences: The code first iterates through the original string to count how many times find appears. This is crucial for calculating the exact size of the new string.
2. Calculate New Length: Based on the count and the length difference between find and replace, the new_len is computed.
3. Allocate Memory: malloc is used to allocate memory for the result string. It's essential to add +1 for the null terminator.
4. Construct New String:
   • The code iterates again. In each iteration, it finds the next match.

1. Copy Remainder: After all replacements are made, any remaining part of the original string (after the last match) is copied to result.
2. Return and Free: The dynamically allocated result string is returned. The caller is responsible for free()ing this memory to prevent leaks.

Approach 3: Replacing a Substring Using snprintf

Using snprintf can make the string construction safer by ensuring that writes do not go beyond the allocated buffer size. This method also involves dynamic allocation.

• Summary: Calculates the required buffer size, allocates memory, then uses snprintf iteratively to copy prefixes, replacement strings, and suffixes into the new buffer, managing buffer position and remaining size.

// Substring Replacement (Using snprintf)
#include <stdio.h>
#include <stdlib.h> // For malloc, free
#include <string.h> // For strlen, strstr

// Function to replace all occurrences of a substring using snprintf
char* replace_substring_snprintf(const char *original, const char *find, const char *replace) {
    char *result;
    char *current_pos; // Current write position in result
    const char *search_pos; // Current read position in original
    char *match; // Pointer to the found substring
    size_t len_find = strlen(find);
    size_t len_replace = strlen(replace);
    size_t len_original = strlen(original);
    int count = 0; // Number of replacements
    size_t final_len; // Final calculated length of the new string

    // Step 1: Count occurrences of 'find'
    search_pos = original;
    while ((match = strstr(search_pos, find)) != NULL) {
        count++;
        search_pos = match + len_find;
    }

    // Step 2: Calculate the final length of the result string
    final_len = len_original + (len_replace - len_find) * count;

    // Step 3: Allocate memory for the new string (+1 for null terminator)
    result = (char *)malloc(final_len + 1);
    if (!result) {
        return NULL;
    }

    // Step 4: Construct the new string using snprintf
    current_pos = result;
    search_pos = original;
    size_t remaining_space = final_len; // Track remaining space in the buffer

    while ((match = strstr(search_pos, find)) != NULL) {
        size_t len_prefix = match - search_pos;

        // Copy prefix
        int written = snprintf(current_pos, remaining_space + 1, "%.*s", (int)len_prefix, search_pos);
        if (written < 0 || (size_t)written > remaining_space) {
             // Handle error or buffer overflow (unlikely with correct length calc)
             free(result);
             return NULL;
        }
        current_pos += written;
        remaining_space -= written;

        // Copy replacement string
        written = snprintf(current_pos, remaining_space + 1, "%s", replace);
        if (written < 0 || (size_t)written > remaining_space) {
             free(result);
             return NULL;
        }
        current_pos += written;
        remaining_space -= written;

        search_pos = match + len_find; // Move search_pos past the found substring
    }

    // Step 5: Copy the remaining part of the original string
    snprintf(current_pos, remaining_space + 1, "%s", search_pos);

    return result;
}

int main() {
    const char *str = "The quick brown fox jumps over the lazy fox.";
    const char *find = "fox";
    const char *replace = "cat";

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

    char *new_str = replace_substring_snprintf(str, find, replace);

    if (new_str) {
        printf("String after replacement: %s\\n", new_str);
        free(new_str);
    } else {
        printf("Error during replacement or memory allocation.\\n");
    }

    const char *str_long = "One two three four five six seven eight nine ten. One two three four five six seven eight nine ten.";
    const char *find_short = "three";
    const char *replace_long = "THIRTY-THREE";

    printf("Original string long: %s\\n", str_long);
    char *new_str_long = replace_substring_snprintf(str_long, find_short, replace_long);
    if (new_str_long) {
        printf("String long after replacement: %s\\n", new_str_long);
        free(new_str_long);
    }

    return 0;
}

Run

• Sample Output:

Original string: The quick brown fox jumps over the lazy fox.
String after replacement: The quick brown cat jumps over the lazy cat.
Original string long: One two three four five six seven eight nine ten. One two three four five six seven eight nine ten.
String long after replacement: One two THIRTY-THREE four five six seven eight nine ten. One two THIRTY-THREE four five six seven eight nine ten.

• Stepwise Explanation:

1. Count Occurrences: Similar to Approach 2, it first counts all occurrences of find to determine the total length needed for the new string.
2. Calculate Final Length: The final_len is calculated based on the original length and the net change in length from all replacements.
3. Allocate Memory: Memory is allocated using malloc for the result string.
4. Construct with snprintf:
   • current_pos tracks where to write in the result buffer.

1. Copy Remainder: After the loop, the final remaining part of the original string is copied to result using snprintf.
2. Return and Free: The dynamically allocated result string is returned, and the caller is responsible for free()ing it.

Conclusion

Replacing a substring in C requires careful attention to memory management and string boundaries, especially when the replacement string differs in length from the original substring. While simple in-place replacement works for same-length substrings, dynamic memory allocation is essential for more flexible scenarios. The malloc/memcpy/strcpy approach offers direct control, while the snprintf-based method provides an extra layer of safety against buffer overflows by limiting write sizes.

Summary

• Same-Length Replacement: Can be done in-place using strncpy after locating the substring with strstr. Limited to fixed-size replacements.
• Different-Length Replacement (Dynamic):
• Requires calculating the total number of substring occurrences.
• Determine the new string's total length based on original length and replacement count.
• Dynamically allocate memory for the new string using malloc.
• Construct the new string by copying segments of the original string and the replacement string into the new buffer.
• Caller must free() the returned string.
• snprintf for Safety: Offers a more robust way to construct the new string by preventing buffer overflows during copying, especially useful when dealing with multiple string segments. Still requires careful length calculation and dynamic allocation.
• Error Handling: Always check malloc return values for NULL to handle memory allocation failures.