string::append in C++: Extending Strings Efficiently

Hello! In today’s article, we’re discussing a popular function in C++ used for string manipulation - string::append. We’ll start by getting familiar with the basics of this function, understand its correct usage, and see some real-world examples.

What is string::append?

In C++, strings are essentially a sequence of characters. There are times when you may want to add (or “append”) one string to the end of another. The string::append function allows you to do just that.

For instance, let’s look at a simple use:

#include <iostream>
#include <string>

int main() {
    std::string greeting = "Hello";
    greeting.append(", World!");

    std::cout << greeting << std::endl; // Outputs: Hello, World!
    return 0;

From the example above, you can see how we successfully appended ”, World!” to the “Hello” string:

Hello, World!

string::append Overloads

string::append isn’t limited to just adding one string to another. It offers multiple variants for different needs:

  1. Appending another string:
std::string str1 = "Code";
std::string str2 = "Lessons";
str1.append(str2); // CodeLessons
  1. Appending a substring:

This lets you add part of one string to another.

std::string str1 = "I love ";
std::string str2 = "apple pie and ice cream";
str1.append(str2, 0, 10); // I love apple pie
  1. Appending a C-string:

If you’re working with C-style strings or character arrays, you can append them too.

std::string str = "Code";
str.append("Lessons"); // CodeLessons
  1. Appending a sequence of characters:

This is useful when you want to add a specific range of characters from another string.

std::string str = "Learning ";
str.append("Code is fun!", 5, 8);  // Appends "is fun!" to the string
  1. Appending a repeated character:

If you want to add a character multiple times, you can do so.

std::string border = "!";
border.append(10, '-'); // !----------

Why Use string::append?

Efficiency: Appending using += operator creates a new string, copying both the original and the added part. string::append modifies the original string in-place, making it more memory and time-efficient.

Flexibility: With its multiple overloads, string::append gives you various ways to append data, be it another string, a C-string, a part of another string, or even repeated characters.

Readability: Using string::append makes it clear that the intention is to append data to the existing string. This can help in making the code more readable and self-explanatory.

Common Pitfalls

  • Appending Large Data: If you’re appending large amounts of data or performing the operation frequently, ensure your string has enough reserved space to prevent constant memory reallocations.

  • Invalid Ranges: While appending substrings, be wary of specifying ranges that exceed the source string’s length. It can lead to undefined behavior.

Wrapping Up

Strings are a crucial part of most programming tasks, and understanding how to manipulate them effectively is a must-have skill for any developer. string::append offers a powerful yet straightforward way to extend strings, making many string manipulation tasks more efficient and readable.

As you continue your C++ journey, always remember to keep experimenting and practicing. There’s no better way to grasp a concept than to use it firsthand. So, try out different variations of string::append and see how they can make your code more robust and efficient. Happy coding!


  1. Basic Usage of string::append:

    • Create a C++ program where the user can input two strings.
    • Use the string::append function to append the second string to the first.
    • Display the resulting combined string.
  2. Exploring Variants of string::append:

    • Create a C++ program with the following functionalities:
      1. Allow the user to append a substring of one string to another.
      2. Enable appending a C-string to an existing string.
      3. Allow appending a sequence of characters from one string to another.
      4. Enable appending a repeated character to a given string.
    • For each of these functionalities, the program should display the resulting string after the append operation.
  3. Efficiency and Pitfalls:

    • Demonstrate the efficiency advantage of string::append over the += operator by:
      1. Writing two versions of a program, one using string::append and another using the += operator, to append a large amount of data.
      2. (Optional: If familiar with time measurement in C++) Measure the time taken for each operation.
    • Write a program that tries to append a substring using string::append with invalid ranges. Observe the results and write down your findings.


© 2023,