How is operator+ implemented for strings?

Question

can anyone show me more or less how is it implemented because if, for example i have

string str1 = "hello";
string str2 = " world";
string str3 = str1 + str2;

so because the code executes from right to left, this is getting executes, but how? str1 + str2 i mean what the returned value? because it needs to maybe allocate memory for some object and then return it and then how the memory will get free. and also is there a operator+ in the vector class? EDIT thanks to everyone, i was just looking for to understand how the returned object is getting return because i thought that if the object is created inside the function so it'll get destroy after the function finished, but its not, so i can return an object that got created inside a function.

Answer 1

See this link:

template< class CharT, class Traits, class Alloc >
    std::basic_string<CharT,Traits,Alloc>
        operator+( const std::basic_string<CharT,Traits,Alloc>& lhs,
                   const std::basic_string<CharT,Traits,Alloc>& rhs );

You're basically calling the templated function which boils down to (greatly simplified):

string str3 = operator+(str1, str2);

The operator+ is responsible for constructing a new string out of the two provided and then this gets assigned to str3.

---

And, based on your comments elsewhere in this question, you seem to be suffering under the misapprehension that things allocated within a function cannot be returned.

That's actually not the case for dynamically allocated things like the content of strings. While it's almost always fatal to return the address of a local object in a function, dynamically allocated memory outlives the function quite nicely.

Answer 2

A c++ std::string is implemented as a char array. But you will not see this implementation as there is the string class which wraps it for making your life easier. Instead, string class gives you a nice interface to use (as std::string::operator+ for concatenation).

Related to the question, when you add str1 + str2 there is the std::string::operator+ function called and a temporary string will be generated (on the right side of the = operator). The newly created object (let's call it str_temp and consider it looks like this "hello world" ) will be used by str3 to create a new object (of course it will allocate memory dynamically but it will not allocate only 12 elements, but will alocate chunks of bytes). [for example a string with 3 chars can have a length of 3 chars but a size of 15 bytes].

In the example you provided, both str1 and str2 will remain unmodified.

On the following link cppreference std::string::operator+ function signature you can see on what kind of parameters is + going to work when talking about strings. Therefore the next example works as expected, showing three times on the screen the message hello world.

std::string a = "hello ";
std::string b = "world";

std::string result1 = a + "world";
std::string result2 = "hello " + b;
std::string result3 = a + b;

std::cout << result1 << "\n" << result2 << "\n" << result3 << std::endl;

Answer 3

Operator overloading

Forget std::string. Imagine you have a simple position class, which holds x and y coordinates in a 2 dimensional world

struct Position {
    int x;
    int y;
    Position( const int x, const int y)
        : x(x), y(y)
    {}
};
int main()
{
    Position s( 5, 10 );
    Position t( 20, 30);
}

Now let's say the I wanted to add these positions, so that I get a new position where x = 25 , y = 40. Can I just use +?

Position sum = s + t; // error
                 ^
              No match for operator '+', Operands are `Position`, `Position`
              ~~~~~~~~~~~~~~~~~~~~~~

How is the compiler supposed to know how to add Position and Position? As I said, operator overloading.

For this example it would be

    friend Position operator+(const Position& r, const Position& l)
    {
        return Position(r.x + l.x, r.y + l.y);
    }

Now the error disappears, and the new object formed will have the correct values.
The same way, std::string has overloaded operator+which takes two other std::strings objects and concatenates them.

Once it constructs the new string, it copies it into str3.

---

I thought that if the object is created inside the function so it'll get destroy after the function finished, but its not, so i can return an object that got created inside a function.

Consider this example

int foo()
{
    int temp = 10;
    return temp;
}
int main()
{
    int i = foo();
    std::cout << i;
}

10

You're not actually returning temp from the function. That variable is completely destroyed. What you are doing is returning a copy, which gets assigned to i.

What will fail is

int& foo()
{
    int temp = 10;
    return temp;
}
int main()
{
    int& i = foo();
    std::cout << i;
}

^{Make sure to disable optimizations when you test this}
This fails because now you are returning a reference to an object that is destroyed. Note that it isn't necessary this has to fail. Anything that happens after doing the above is undefined behavior.

The compiler is god so it just might translate your code into

int main()
{
    int i = 5;
    std::cout << i;
}

---

Because of all this, the compiler will decide to do something else because copying will be in-efficient if the object is huge, that is return value optimization