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.

Okay, thanks for the fast replies. I'll have a go at that.

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.

Originally Posted by matsp

Hmm, I thought if there is a constructor String::String(const char *s), then the compiler will automatically be able to create a String object from a char *, and thus be able to use the normal String:perator+(const String &right)

No, the compiler won't do that. Think what would happen if there was some other class Blah which also had a method of type:

Code:

String operator+(const String &right);

Now the compiler has to decide whether to convert the char * into a String or into a Blah. This cannot be decided, so the compiler doesn't support such operations.

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.

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.