Sorry, this is how I overloaded it:
Vector operator*(double scalar)
{
Vector result;
result.x = x * scalar;
result.y = y * scalar;
result.z = z * scalar;
return result;
}
That's illegal, but I suspect this is a member function. Next time,
post complete, compilable code.
class C
{
public:
C operator*(double d);
};
void f(C& c)
{
c * 1.0;
This works because the statement becomes
c.operator*(1.0);
However, this
1.0 * c
doesn't, because 1)
1.0.operator*(c);
makes no sense and 2)
operator*(double, const C&);
doesn't exist (remember: a binary operator @ as in x@y can be applied
as a member function x.operator@(y) or as a namespace scope function
operator@(x, y)).
There are three solutions. First, define two operator* at namespace
scope (outside the class):
C operator*(double d, const C& c); // 1.0 * c
C operator*(const C& c, double d); // c * 1.0
These operators may be friends of C if they need to.
The second and third solutions only work if you can [implictly]
construct a C from a double:
class C
{
public:
C(double d);
};
In this case, either define one non member operator* that takes two Cs:
C operator*(const C& c1, const C& c2);
or one member operator* that takes one C:
class C
{
public:
// ...
C operator*(const C& c);
};
The choice between the three solution is not only a matter of taste,
but also depends on the interpretation of the concept of
"encapsulation" or "information hiding". Have fun.
Now,
1.0 * c;
creates a temporary C initialized with 1.0 and both Cs are passed to
operator*. Note that operator*'s parameters must be const references
(or by value, which is "innefficient" however), because that's the only
way you will be able to pass the temporary value (technical: this
temporary is an rvalue and cannot be bound to a non-const reference).
}
Jonathan
perator*( double d ) const;