Inapoi
Inainte
Cuprins
12:
Operator
Overloading
Operator overloading
is just “syntactic
sugar,” which means it is
simply another way for you to make a function call.
The difference is that the arguments for
this function don’t appear inside parentheses, but instead they surround
or are next to characters you’ve always thought of as immutable
operators.
There are two differences between the use
of an operator and an ordinary function call. The syntax is different; an
operator is often “called” by placing it between or sometimes after
the arguments. The second difference is that the compiler determines which
“function” to call. For instance, if you are using the operator
+ with floating-point arguments, the compiler “calls” the
function to perform floating-point addition (this “call” is
typically the act of inserting in-line code, or a floating-point-processor
instruction). If you use operator + with a floating-point number and an
integer, the compiler “calls” a special function to turn the
int into a float, and then “calls” the floating-point
addition code.
But in C++, it’s possible to define
new operators that work with classes. This definition is just like an ordinary
function definition except that the name of the function consists of the keyword
operator followed by the operator. That’s
the only difference, and it becomes a function like any
other function, which the compiler calls when it sees the appropriate
pattern.
Warning & reassurance
It’s tempting to become
overenthusiastic with operator overloading. It’s a fun toy, at first. But
remember it’s only syntactic sugar, another way of calling a
function. Looking at it this way, you have no reason to overload an operator
except if it will make the code involving your class easier to write and
especially easier to read. (Remember, code is read much more than it is
written.) If this isn’t the case, don’t bother.
Another common response to operator
overloading is panic; suddenly, C operators have no familiar meaning anymore.
“Everything’s changed and all my C code will do different
things!” This isn’t true. All the operators used in expressions that
contain only built-in data types cannot be changed. You can never overload
operators such that
1 << 4;
1.414 << 2;
has meaning. Only an expression
containing a user-defined type can have an overloaded
operator.
Syntax
Defining an overloaded
operator is like defining a function, but the name of
that function is operator@, in which @ represents the operator
that’s being overloaded. The number of arguments in the overloaded
operator’s argument list depends on two
factors:
- Whether it’s a unary
operator (one argument) or a binary operator (two
arguments).
- Whether
the operator is defined as a global function (one argument for unary, two for
binary) or a member function (zero arguments for unary, one for binary –
the object becomes the left-hand
argument).
Here’s a
small class that shows the syntax for operator overloading:
//: C12:OperatorOverloadingSyntax.cpp
#include <iostream>
using namespace std;
class Integer {
int i;
public:
Integer(int ii) : i(ii) {}
const Integer
operator+(const Integer& rv) const {
cout << "operator+" << endl;
return Integer(i + rv.i);
}
Integer&
operator+=(const Integer& rv) {
cout << "operator+=" << endl;
i += rv.i;
return *this;
}
};
int main() {
cout << "built-in types:" << endl;
int i = 1, j = 2, k = 3;
k += i + j;
cout << "user-defined types:" << endl;
Integer ii(1), jj(2), kk(3);
kk += ii + jj;
} ///:~
The two overloaded operators are defined
as inline member functions that announce when they are called. The single
argument is what appears on the right-hand side of the operator for binary
operators. Unary operators have no arguments when defined as member functions.
The member function is called for the object on the left-hand side of the
operator.
For non-conditional operators
(conditionals usually return a Boolean value), you’ll almost always want
to return an object or reference
of the same type you’re operating on if the two arguments are the same
type. (If they’re not the same type, the interpretation of what it should
produce is up to you.) This way,
complicated
expressions can be built up:
kk += ii + jj;
The operator+ produces a new
Integer (a temporary) that is used as the rv argument for the
operator+=. This temporary is destroyed as soon as it is no longer
needed.
 |
|
|
