• C Program to Add String without using concat()

    Welcome to another exciting blog post on programming! In this article, we will explore how to add strings in the C programming language without using the concat() function. Adding strings is a common operation in programming, and understanding how to do it efficiently can greatly enhance your coding skills. So, let’s dive right in!

    Introduction to String Concatenation

    Before we jump into the details, let’s first understand what string concatenation means. In simple terms, string concatenation is the process of combining two or more strings into a single string. Programmers commonly use this operation to construct larger strings by appending smaller strings together.

    The C programming language provides the concat() function, which is specifically designed to concatenate strings. This function takes two strings as input and returns a new string that is the result of the concatenation process. Here’s a quick example to illustrate its usage:

    #include <stdio.h>
    #include <string.h>
    int main() {
        char str1[20] = "Hello, ";
        char str2[] = "World!";
        printf("Before concatenation: %s\n", str1);
        strcat(str1, str2);
        printf("After concatenation: %s\n", str1);
        return 0;

    Running this program will output:

    Before concatenation: Hello, 
    After concatenation: Hello, World!

    As you can see, the concat() function allows us to merge the contents of str2 with str1, resulting in the combined string “Hello, World!”.

    Limitations of the concat() Function

    While the concat() function is widely used for string concatenation, it does have certain limitations that may not suit all programming scenarios. One major drawback is that it modifies and extends the first string (str1 in our example) directly, rather than returning a new string.

    This behavior can cause problems when the first string doesn’t have enough memory allocated to accommodate the combined result. If str1 is not large enough to hold the concatenated string, a buffer overflow can occur, leading to undefined behavior and potentially crashing the program.

    In addition, the concat() function requires the destination string (str1) to be null-terminated, meaning it must end with a null character ('\0'). If the destination string is not properly null-terminated, the result of the concatenation may be incorrect or unpredictable.

    Given these limitations, it is essential to explore alternative methods to add strings in situations where the concat() function may not be the best choice.

    Directly Modifying the String

    One approach to add strings in C without using concat() is to directly modify the first string to include the characters from the second string. This can be done by iterating over the second string and appending each character to the end of the first string.

    Let’s take a look at the implementation:

    #include <stdio.h>
    void addStrings(char* str1, char* str2) {
      // Find the end of str1
      int i = 0;
      while (str1[i] != '\0') {
      // Append str2 to str1
      int j = 0;
      while (str2[j] != '\0') {
        str1[i] = str2[j];
      // Add null character to mark the end of the new string
      str1[i] = '\0';
    int main() {
      char str1[100] = "Hello";
      char str2[100] = " World!";
      addStrings(str1, str2);
      printf("Combined string: %s\n", str1);
      return 0;

    In the addStrings() function, we first find the end of str1 by iterating over it until we encounter the null character ‘\0’. Then, we iterate over str2 and append each character to the end of str1. Finally, we add a null character at the end to mark the end of the new string.

    When we run the program, it combines the two strings and prints the result: “Hello World!”.

    Using Dynamic Memory Allocation

    Another way to add strings in C without concat() is to dynamically allocate memory for the combined string. This approach allows us to handle strings of any length, not limited by the size of the array.

    Here’s an implementation using dynamic memory allocation:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    char* addStrings(char* str1, char* str2) {
      // Calculate the lengths of str1 and str2
      int len1 = strlen(str1);
      int len2 = strlen(str2);
      // Allocate memory for the combined string
      char* combined = (char*)malloc((len1 + len2 + 1) * sizeof(char));
      // Copy str1 to combined
      strcpy(combined, str1);
      // Append str2 to combined
      strcat(combined, str2);
      return combined;
    int main() {
      char str1[100] = "Hello";
      char str2[100] = " World!";
      char* combined = addStrings(str1, str2);
      printf("Combined string: %s\n", combined);
      // Free the allocated memory
      return 0;

    In the addStrings() function, we calculate the lengths of str1 and str2 using the strlen() function. Then, we allocate memory for the combined string using malloc(), taking into account the lengths of both strings plus 1 for the null character.

    Next, we copy str1 to the allocated memory using strcpy(). Finally, we append str2 to the end of the combined string using strcat(). The function returns the combined string.

    In the main() function, we call addStrings() with str1 and str2, and it returns a dynamically allocated combined string. We print the result and free the allocated memory using free() to prevent memory leaks.

    Limitations and Considerations

    While both approaches discussed above provide ways to add strings without using concat(), it is essential to consider their limitations and potential risks.

    In the first approach of directly modifying the first string, we need to ensure that the first string has enough space to accommodate the characters from the second string. If the first string is not large enough, it can lead to buffer overflow, resulting in unexpected behavior or crashes. Therefore, it’s crucial to allocate sufficient memory or use a fixed-size array to avoid such issues.

    On the other hand, the second approach using dynamic memory allocation allows for handling strings of any length. However, it imposes the responsibility of releasing the allocated memory after one no longer needs it. Forgetting to free the memory can lead to memory leaks, which can degrade the performance of the program over time.


    In this blog post, we explored how to add strings in the C programming language without using the concat() function. We discussed two different approaches: directly modifying the first string and using dynamic memory allocation.

    By directly modifying the first string, we can append the characters from the second string to it. Alternatively, by dynamically allocating memory, we can create a new string that combines both input strings.

    It is important to be mindful of the limitations and considerations associated with each approach to ensure the code’s stability and performance. Proper memory allocation and deallocation techniques should mitigate potential risks like buffer overflow and memory leaks.

    Adding strings is a fundamental operation in many programming scenarios, and understanding different methods to achieve it enhances our problem-solving skills. So go ahead, experiment with the code, and explore further possibilities!

    Happy coding!