I'm doing an exercise where I need to reverse the elements of a string e.g. HelloWorld - dlroWolleH
My original code was here as below:
std::string reverseString(std::string text)
{
std::string new_string = "";
int index = 0;
int pos_text = text.size();
while (index <= text.size()) {
new_string[index] = text[pos_text]; //Line doesn't work.
pos_text--;
index ;
}
return new_string;
}
However, looking online, the code block inside the while loop goes like this instead.
new_string = new_string text[pos_text];
Could someone explain to me why it needed to be as the line above? I was under the impression that a string is an array of characters?
CodePudding user response:
You declared an empty string
std::string new_string = "";
You could equivalently write
std::string new_string;
So you may not use the subscript operator for an empty string to change its content
new_string[index] = text[pos_text];
Also in the right operand of the assignment there is also used an invalid index expression pos_text
. You have to use the expression pos_text - 1
. Otherwise the character '\0' will be written in the first position of the new string.
Instead you could write
new_string = text[pos_text - 1];
or (as the same )
new_string.push_back( text[pos_text - 1] );
As for this statement
new_string = new_string text[pos_text];
that again must be written like
new_string = new_string text[pos_text - 1];
then for the class std::string there is defined the overloaded operator with the right operand of the ty[e char
.
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator>
operator (const basic_string<charT, traits, Allocator>& lhs, charT rhs);
Pay attention to that the condition of the while loop
while (index <= text.size())
is incorrect. You have to write
while (index < text.size())
The simplest way to define the function is the following
std::string reverseString( const std::string &text )
{
return { text.rbegin(), text.rend() };
}
If to use loops as you are doing then the function can be defined like
std::string reverseString( const std::string &text )
{
std::string new_string;
new_string.reserve( text.size() );
for ( auto i = text.size(); i != 0; )
{
new_string = text[--i];
}
return new_string;
}
CodePudding user response:
Could someone explain to me why it needed to be as the line above? I was under the impression that a string is an array of characters?
Actually, strings are dynamic arrays who's size is not fixed. They have the
operator overloaded so you can append two strings using str1 = str2
. For example, "hello" "world" == "helloworld"
When you create new_string
, you create an empty string so you cannot access any of its elements, because it has none. That's why you need to use =
, to append an element.
Note: In practice, you should use std::reverse(string.begin(), string.end())
instead of a custom algorithm. See here: https://en.cppreference.com/w/cpp/algorithm/reverse
CodePudding user response:
When you use the sign in strings, it appends the character to the end of that string. We call this in programming "Operator Overloading".
Example:
string word1 = "Hello";
string word2 = "World";
word1 = word1 word2;
The word1
here becomes HelloWorld
.
There are diffrent ways to type this word1 = word1 word2
line of code, looking online you can see it as word1 = word2
, This also works and gives you the same result.
Here is a solution for reversing a word too:
string reverseString(string word)
{
int size = word.length();
string revWord;
for(int i = 0; i < size; i )
{
revWord = word[size-i-1];
}
return revWord;
}