Thread: Operator Overloading - Can This Be Done?

I just had a go at overloading the + operator. It works, but I want it to do more if possible. For example if i do this in my code:

Code:

String something("strings");
something + " together";

It concatenates the two, but if I do:

Code:

String something("strings");
"I want to put " + something;

It wont work. Is there any way I can get what side of the operator the constant char pointer is on and whack it on the string accordingly?
Heres my function so far:

Code:

String &String::operator+(const char *add)
{
	char *origin = str_ptr;
	size+=strlen(add);
	str_ptr = new char[size];
	char *src = origin;
	char *dst = str_ptr;
	while(*src) *dst=*src, src++, dst++; //Copy original
	while(*add) *dst=*add, add++, dst++; //Copy string to add
	++*dst='\0';
	delete[] origin;
	return *this;
}

You have to make the operator a global function instead of a member function. For instance:

Code:

my_string operator+(const char * left, const my_string &right);

Overloaded member operators always take the class type as their first parameter and there's no way to change that.

Depending on the class implementation, this global function might have to be declared a friend, but there's nothing wrong with that.

Originally Posted by dwks

Double Mats!


It seems that way.

Your example works because the standard library has exactly the kind of overloaded global function we're talking about here.

Your example could work by operator+ being overloaded for (const char*, const std::string&), so it doesn't actually prove anything one way or the other.

The compiler does convert the const char* to the String, but not when operator+ is a member function. So, you do only need one non-member operator+ if you have appropriate non-explicit copy constructors:

Code:

#include <iostream>

class Test
{
    int i_;
public:
    Test(int i = 1) : i_(i) { }
    int get_i() const { return i_; }
};

Test operator+(const Test& lhs, const Test& rhs) { return Test(rhs.get_i() + lhs.get_i()); }

int main()
{
    Test t;
    Test s = 3 + t;
    std::cout << s.get_i() << '\n';
}

If there are two possibilities, then the compiler will pick the best one or complain that the call is ambiguous.

Originally Posted by Daved

The compiler does convert the const char* to the String, but not when operator+ is a member function.

That's exactly the point. The conversion can happen if the type being converted to explicit in the argument list. But in the case of a member function, the type is only implicit and the compiler has no way of deciding which conversion is appropriate.

A related issue comes up when you've got more than one type conversion operator in a class:

Code:

class A, B;

class C
{
public:
    operator A(); // convert C to A
    operator B(); // convert C to B.
};

Now imagine you've got two overloads:

Code:

int foo(const A &);
int foo(const B &);

Then imagine you instantiate a C and try to pass it to foo(). There are two conversions available that would make this call possible: to type A, or type B. What should happen in this case is ambiguous and I can't remember what the standard says about it.

Another side point is that often operator+ is implemented in terms of operator+=, so once you've established the proper function signatures, you can and should initialize a temporary String with the first operand and use += to concatenate the second, then return that temporary. Also make note of the fact that operator+ should not return a reference, although operator+= can.

Okay I made some progress but its still not doing exactly what I wanted. I basically made the operators call some member functions. As in:

Code:

String operator+(String &left, char *right)
{
	left.Add(right);
	return left;
}
String operator+(char *left, String &right)
{
	right.Insert(left, 0);
	return right;
}

This works for: something + " together";
Or: "Put " + something;
But not: "Put " + something + " together";
Why cant I do that?

Also I'm starting to realise that I was kind of clueless as to what I was trying to achieve when I started out. The sort of thing i really wanted to do is be able write code in a similar way to a scripting language using my functions. As in:

Code:

int num=100;
char string_bit[]="blergh";
my_string = "Blah blah" + string_bit + "blah "+ num + " blah....";

Any advice on how I can go about this? I dont have a dont know where to start at the moment.

Cheers.

The const char* is less important than const String&, but you should put both there.

You need your operator+ to work if you want to do anything like my_string = "jfh" + number + "djfbjsd" + another_string; and that means fixing your consts.

The reason is that when you have a bunch of things added together like that, each addition is done one at a time. The first two pieces are added and stored in a temporary string, which is then added to the third piece and that result is stored in another temporary string, and that is then added with the fourth piece, and so on. A temporary object cannot be modified by the function, which is why the reference needs to be const.

So to solve your problem, get your operator+(const String& left, const String& right) working, then strings like this "jfh" will work automatically. Adding numbers is more difficult like I mentioned in an edit above.