Tutorial

How to Reverse a String in C++: A Guide with Code Examples

Updated on April 21, 2025

Sr Technical Writer

How to Reverse a String in C++: A Guide with Code Examples

In many situations, we may need to reverse a string in C++ programming. It may include just printing a reversed string. Or maybe in some cases need to reverse the string permanently at its address.

In this tutorial, we are going to learn how we can accomplish both the tasks. That too using different pre-defined as well as user-defined functions.

Reversing a String in C++

Reversing a string refers to the operation on a string, by which the sequence of characters in it gets reversed. For example, consider ‘str’ contains a string “JournalDev” in it.

After the reversal operation takes place on the string ‘str’, the content should get reversed. Hence now, ‘str’ should contain the string “veDlanruoJ”.

Now let us see how we can perform this reverse operation on C++ strings using various techniques.

Using reverse() function in C++

The built-in reverse function reverse() in C++ directly reverses a string. Given that both bidirectional begin and end iterators are passed as arguments.

This function is defined in the algorithm header file. The code given below describes the use of reverse() function,

#include <algorithm> 
#include<iostream>
#include<string>
using namespace std; 
int main() 
{ 
    string str = "Journal Dev reverse example"; 
    reverse(str.begin(), str.end()); 
 cout<<"\n"<<str; 
    return 0;
}

Output:

Use Of Reverse string in c++ — Use Of reverse()

Using `strrev()`

strrev() is a pre-defined function in C++, defined inside the cstring.h header file. It is extensively applicable for reversing any C-string(character array).

Further, it only requires the base address of the string as its argument and reverses the string accordingly. Let us see how we can use the strrev() function in C++ to reverse strings.

#include<iostream>
#include<cstring>
using namespace std; 
int main() 
{ 
    char str[] ="Journal Dev reverse example"; 
    strrev(str);
 cout<<"\n"<<str; 
    return 0;
}

Output:

Reverse Using Strrev reverse string in C++ — Reverse Using strrev()

The code above illustrates the working of the function strrev() very well. For a string ‘str’, the function reverses it successfully as we can see in the output itself.

Printing a String in reverse

In certain cases, we may not need to change the string but only print it in a reversed manner. This could be for constant strings that cannot be modified. We can print any string in a reversed pattern by using a loop. Let us see how.

#include<iostream>
#include<string>
using namespace std; 
int main() 
{ 
    string str="Journal Dev reverse example"; 
    int i;
    cout<<"Printing string in reverse\n";
    for(i = str.length() - 1; i >= 0; i--)
    {
       cout<<str[i];
    }
    return 0;
}

Output:

In the above-given code, we have firstly initialized a string ‘str’.
Inside the for loop, while printing the string, note that we have initialized the iterator ‘i’ with a value str.length()-1. This means that we print the string character by character but, starting from the last index.
Note: length() returns the length of a string. So, for printing a string in reverse we should consider the last index which should be length()-1, since indexing starts from ‘0’ in a character array.

Making our own string reversing function My_rev()

Until now we learned how we can print a string in reverse as well as reverse the string using different pre-defined functions. Now let us create or define our own function named My_rev() to reverse a given string.

#include<iostream>
#include<string>
#include<cstring>
using namespace std;
char *My_rev(char *str)
{
  int i,len=0,n;
  char temp;
  len=strlen(str);
  n=len-1;
  for(i = 0; i <=(len/2); i++)
  {
    temp=str[i];
    str[i]=str[n];
    str[n]=temp;
    n--;
  }
  return str;
}
int main()
{ 
    char My_string[]="Journal Dev reverse example";
 cout<<"Reverse string using My_rev()...\n";
    My_rev(My_string);
 cout<<My_string;
    return 0;
}

Output:

In the code above, My_rev() is a function that reverses a string, given the base address of the string is passed as an argument.
Inside the My_rev() function, *str is a pointer that stores the base address of the provided string. In our case, str points to the first element of the string My_string.
len stores the length of the string. Whereas, n is the index of the last element.
In the function, we try to swap individual characters of the string, from both ends. That means we go on swapping elements from the 0th and nth index until we get to the (len/2)th position. In the code above, the for loop does this swapping for us which technically reverses the string.
In the end, we return the base address str to the main() function. Where the string is printed using the cout function.

Pracical Use Cases

1. Reversing user input for palindrome checking

Reversing user input is crucial for palindrome checking. A palindrome is a word, phrase, number, or other sequence of characters that reads the same forward and backward (ignoring spaces, punctuation, and capitalization). To check if a string is a palindrome, we can reverse the string and compare it with the original string. If they are the same, then the string is a palindrome.

Here’s a simple code snippet to check if a string is a palindrome using the My_rev() function:

#include<iostream>
#include<string>
#include<cstring>
using namespace std;

bool isPalindrome(char *str) {
    char *reversedStr = My_rev(str);
    return strcmp(str, reversedStr) == 0;
}

int main() {
    char My_string[]="madam";
    if(isPalindrome(My_string)) {
        cout << "The string is a palindrome." << endl;
    } else {
        cout << "The string is not a palindrome." << endl;
    }
    return 0;
}

2. Formatting output for UI strings

Reversing strings can be useful in formatting output for UI strings. For example, in a chat application, you might want to display the most recent messages first. By reversing the order of the messages, you can easily achieve this without modifying the underlying data structure.

Here’s a simple example of how you might use string reversal to format output for UI strings:

#include<iostream>
#include<string>
#include<cstring>
using namespace std;

void displayMessages(char **messages, int numMessages) {
    for(int i = numMessages - 1; i >= 0; i--) {
        cout << messages[i] << endl;
    }
}

int main() {
    char *messages[] = {"Hello", "How are you?", "I'm fine, thank you."};
    int numMessages = sizeof(messages) / sizeof(messages[0]);
    cout << "Displaying messages in reverse order:" << endl;
    displayMessages(messages, numMessages);
    return 0;
}

3. NLP or string manipulation preprocessing

String reversal is a common preprocessing step in many NLP and string manipulation tasks. For example, in text analysis, you might want to reverse the order of words in a sentence to analyze the sentence structure or to perform tasks like sentiment analysis.

Here’s a simple example of how you might use string reversal in NLP preprocessing:

#include<iostream>
#include<string>
#include<cstring>
using namespace std;

void reverseSentence(char *sentence) {
    char *token = strtok(sentence, " ");
    char reversedSentence[100] = "";
    while(token != NULL) {
        strcat(reversedSentence, token);
        strcat(reversedSentence, " ");
        token = strtok(NULL, " ");
    }
    cout << "Reversed sentence: " << reversedSentence << endl;
}

int main() {
    char sentence[] = "This is a sample sentence for NLP preprocessing.";
    cout << "Original sentence: " << sentence << endl;
    reverseSentence(sentence);
    return 0;
}

4. Reversing tokens or strings for parsing tasks

Reversing tokens or strings is essential in parsing tasks, such as parsing expressions or syntax analysis. By reversing the tokens, you can easily analyze the structure of the expression or syntax from right to left.

Here’s a simple example of how you might use string reversal in parsing tasks:

#include<iostream>
#include<string>
#include<cstring>
using namespace std;

void parseExpression(char *expression) {
    char *token = strtok(expression, " ");
    while(token != NULL) {
        cout << "Parsed token: " << token << endl;
        token = strtok(NULL, " ");
    }
}

int main() {
    char expression[] = "2 + 3 * 4 - 1";
    cout << "Original expression: " << expression << endl;
    parseExpression(expression);
    return 0;
}

Comparing Efficiency of Each Method (Loop vs Recursion vs STL)

When it comes to reversing a string, there are several approaches that can be taken. Here, we’ll compare the efficiency of three common methods: using a loop, recursion, and the Standard Template Library (STL).

Loop Method

The loop method involves iterating through the string from the beginning to the end, swapping characters along the way. This approach is straightforward and easy to implement. However, it requires extra space to store the temporary swap, which can be a drawback for large strings.

Recursion Method

The recursion method involves dividing the problem into smaller sub-problems until a base case is reached. This approach can be more challenging to implement, especially for those unfamiliar with recursive functions. However, it can be more efficient in terms of space complexity since it doesn’t require extra space for swapping.

STL Method

The STL method leverages the std::reverse function from the <algorithm> library to reverse the string. This approach is the most efficient in terms of both time and space complexity since it’s optimized for performance and doesn’t require extra space.

Here’s a comparison table to illustrate the efficiency of each method:

Method	Time Complexity	Space Complexity	Ease of Implementation
Loop	O(n)	O(1)	Easy
Recursion	O(n)	O(n)	Medium
STL	O(n)	O(1)	Easy

Note: n represents the length of the string.

In conclusion, while all three methods have a time complexity of O(n), the STL method stands out for its efficiency in terms of space complexity and ease of implementation. However, the choice of method ultimately depends on the specific requirements and constraints of the project.

Common Errors and Debugging

1. Forgetting null terminators in character arrays

When working with character arrays, it’s essential to ensure that the array is null-terminated. This means that the last element of the array should be a null character ('\0'). Without a null terminator, string functions may not work correctly, leading to unexpected behavior or errors. To fix this issue, always manually add a null character at the end of the array or use a string class that handles null termination automatically.

Example:

char str[] = "Hello, World!";
str[strlen(str)] = '\0'; // Ensure null termination

2. Using std::reverse() incorrectly with string iterators

When using std::reverse to reverse a string, it’s crucial to pass the correct iterators. The function requires two iterators: one pointing to the beginning of the string and another pointing to the end of the string. Ensure that the end iterator points to the position after the last character of the string. To fix this issue, use the begin() and end() functions of the string class to obtain the correct iterators.

Example:

std::string str = "Hello, World!";
std::reverse(str.begin(), str.end()); // Correctly reverse the string

3. Invisible Unicode characters not behaving as expected

Invisible Unicode characters, such as the zero-width joiner (ZWJ), can sometimes cause unexpected behavior when processing strings. These characters can affect the way strings are parsed or displayed. To fix this issue, consider using Unicode-aware string processing functions or libraries that can handle these characters correctly.

Example:

std::wstring wideStr = L"Example\u{200D}String"; // Unicode string with ZWJ
std::wstring reversedStr(wideStr.rbegin(), wideStr.rend()); // Correctly reverse the string

4. Misuse of `getline` vs `cin` leading to partial strings

When reading input from the user, it’s common to use either cin or getline to read strings. However, using cin can lead to partial strings being read if the input contains spaces. This is because cin stops reading when it encounters a whitespace character. To fix this issue, use getline instead of cin to read strings, especially when the input may contain spaces.

Example:

std::string inputStr;
std::getline(std::cin, inputStr); // Correctly read a string with spaces

FAQs

1. What is the simplest way to reverse a string in C++?

The simplest way to reverse a string in C++ is to use the std::reverse function from the <algorithm> library. This function takes two iterators as arguments, the beginning and the end of the range to be reversed.

Example:

std::string str = "Hello, World!";
std::reverse(str.begin(), str.end());
std::cout << str << std::endl; // Output: "!dlroW ,olleH"

2. How do you reverse a string without using std::reverse?

To reverse a string without using std::reverse, you can use a simple loop that swaps characters from the beginning and end of the string, moving towards the center.

Example:

std::string str = "Hello, World!";
int start = 0;
int end = str.length() - 1;
while (start < end) {
    char temp = str[start];
    str[start] = str[end];
    str[end] = temp;
    start++;
    end--;
}
std::cout << str << std::endl; // Output: "!dlroW ,olleH"

3. Can you reverse a string in-place in C++?

Yes, it is possible to reverse a string in-place in C++. This means that the original string is modified without using any additional space. The approach is similar to the one described in the previous question, but it’s more efficient as it doesn’t require any extra space.

Example:

std::string str = "Hello, World!";
int start = 0;
int end = str.length() - 1;
while (start < end) {
    char temp = str[start];
    str[start] = str[end];
    str[end] = temp;
    start++;
    end--;
}
std::cout << str << std::endl; // Output: "!dlroW ,olleH"

4. What is the time complexity of string reversal methods?

The time complexity of string reversal methods is O(n), where n is the length of the string. This is because each character in the string needs to be accessed and potentially swapped once.

5. How do you reverse a C-style string (char array)?

To reverse a C-style string (char array), you can use a similar approach to the one described in question 2, but with a few adjustments to accommodate the C-style string.

Example:

char str[] = "Hello, World!";
int start = 0;
int end = strlen(str) - 1;
while (start < end) {
    char temp = str[start];
    str[start] = str[end];
    str[end] = temp;
    start++;
    end--;
}
std::cout << str << std::endl; // Output: "!dlroW ,olleH"

6. Can you reverse a string using recursion in C++?

Yes, it is possible to reverse a string using recursion in C++. This approach involves recursively calling a function that swaps characters from the beginning and end of the string, moving towards the center.

Example:

void reverseString(std::string& str, int start, int end) {
    if (start >= end) return;
    char temp = str[start];
    str[start] = str[end];
    str[end] = temp;
    reverseString(str, start + 1, end - 1);
}

std::string str = "Hello, World!";
reverseString(str, 0, str.length() - 1);
std::cout << str << std::endl; // Output: "!dlroW ,olleH"

7. How do I reverse words in a sentence instead of characters?

To reverse words in a sentence instead of characters, you need to first split the sentence into words and then reverse the order of the words. This can be achieved using a combination of string manipulation and algorithms.

Example:

std::string sentence = "Hello, World!";
std::istringstream iss(sentence);
std::vector<std::string> words;
std::string word;
while (iss >> word) {
    words.push_back(word);
}
std::reverse(words.begin(), words.end());
std::string reversedSentence;
for (const auto& word : words) {
    reversedSentence += word + " ";
}
std::cout << reversedSentence << std::endl; // Output: "World! Hello, "

Conclusion

In conclusion, reversing a string in C++ can be done using various methods, each with its own advantages and disadvantages. The choice of method depends on the specific requirements and constraints of the project. The std::reverse function from the <algorithm> library is the most efficient in terms of both time and space complexity, while the loop method is straightforward and easy to implement.

If you found this tutorial helpful, you may also be interested in the following tutorials: