overloading operator in C++

**-EquinoX-** · 04-02-2010

If say I want to overload the following:

Code:

String operator*(const String& str, int n);

and my test case is:

Code:

String ab = ab0 * 3;
String abc = 2 * (ab + String('c'));

do I need to write another function with a different parameter, or is there a way to just use one function definition and perform both operators?

**anon** · 04-02-2010

I think you'll need another, but you can probably implement it in terms of the first:

Code:

String operator*(int n, const String& str)
{
    return str * n;
}

**-EquinoX-** · 04-02-2010

May I know the reason why?

**Elysia** · 04-02-2010

Because in the first case, the compiler looks for a function with a parameter list that looks like const String&, int, and in the second the reverse. Since no such function exists...
The reason for the need of two is probably technical. Such as the compiler cannot guarantee no side effects.

**-EquinoX-** · 04-02-2010

I see that explains, also another question about overloading unary operator.. I have the following:

Code:

String String::operator-(){
	String r('x', strlen(itsPtr) + 1);
	int j = 0;
	for(int i = strlen(itsPtr) + 1; i >= 0; i--){
		r[j] = itsPtr[i];
		j++;
	}
	return r;
}

but when I do the test:

Code:

 String x("abc");
    String y = -x;

it says:
s0.cc:31: error: no match for âoperator-â in â-xâ

definitely there's a operator-

**laserlight** · 04-02-2010

Sorry, but I cannot replicate your problem:

Code:

class String
{
public:
    String operator-()
    {
        return *this;
    }
};

int main()
{
    String x;
    String y = -x;
}

**Elysia** · 04-02-2010

Did you declare it properly in your prototype?

Code:

class Test
{
public:
	Test operator - () const
	{
		return Test();
	}
};

int main()
{
	Test test;
	Test test2 = -test;
}

This works fine, as expected.

**-EquinoX-** · 04-02-2010

okay lets get back to my first topic, when I just use that one... I get:

error: invalid conversion from âintâ to âconst char*â
error: initializing argument 1 of âString::String(const char*)â
error: invalid conversion from âconst char*â to âintâ
error: initializing argument 2 of âString operator*(const String&, int)â

so does this mean that I must use two function signature?

PS: I fixed the error of operator-

**Elysia** · 04-02-2010

Your operator * at the beginning of the thread? If so, then there's nothing wrong with it from the look of it.
Can you provide an example?

**-EquinoX-** · 04-02-2010

here is my operator*

Code:

String operator*(int n, const String& str){
	String r;
	if (n > 0){
		for (int i = 0; i < n; i++)
		r = str + str;
	}
	else if (n < 0)
		printf("assertion failure\n");
	
	return r;
}

my test:

Code:

String ab = ab0 * 3;
    String abc = 2 * (ab + String('c'));

**Elysia** · 04-02-2010

The biggest problem I see is your first line. It's (String, int), but your defined operator is (int, String).
I got this minimal example to compile (it is by no means correct):

Code:

class String
{
public:
	String(char c) { m_str = c; }
	String(const std::string& str): m_str(str) {}
	String() {}
	friend String operator + (const String& lhs, const String& rhs)
	{
		return lhs.m_str + rhs.m_str;
	}
	friend String operator*(int n, const String& str)
	{
		String r;
		if (n > 0){
			for (int i = 0; i < n; i++)
				r = str + str;
		}
		else if (n < 0)
			printf("assertion failure\n");

		return r;
	}

protected:
	std::string m_str;
};

int main()
{
	String ab0;
	String ab = 3 * ab0;
	String abc = 2 * (ab + String('c'));
}

**-EquinoX-** · 04-02-2010

that's what my original question is, would it be possible just to use one function definition to cover both (String, int) and (int, String) in overloading?

**Elysia** · 04-02-2010

No. You need to define two.
But the second can just wrap the first.

You may also want to look into Boost Operators: http://www.boost.org/doc/libs/1_42_0.../operators.htm
It saves you from writing several operators, plus it also defines them in a two-way form: ie T, U and U, T.
Handy stuff.

**-EquinoX-** · 04-02-2010

okay... some say that using operator cast will allow me to use one function definition

**laserlight** · 04-02-2010

Yes, but it will also allow much more than that.

Thread: overloading operator in C++

Thread Tools

Search Thread

Display

overloading operator in C++

Similar Threads

Help with Operator Overloading

Overloading operators

unary operator overloading and classes

Overloading operator ==

overloading