Overview of C++ Overloading

• Overloading occurs when the same operator or

function name is used with different signatures

• Both operators and functions can be overloaded

• Different definitions must be distinguished by their

signatures (otherwise which to call is ambiguous)
– Reminder: signature is the operator/function name and the
ordered list of its argument types
– E.g., add(int,long) and add(long,int) have different
signatures
– E.g., add(const Base &) and add(const Derived &)
have different signatures, even if Derived is-a Base
– Most specific match is used to select which one to call

CSE 332: C++ Overloading

 Overloading vs. Overriding
• Overriding a base class member function is
similar to overloading a function or operator
– But for overriding, definitions are distinguished by
their scopes rather than by their signatures

• C++ can distinguish method definitions

according to either static or dynamic type
– Depends on whether a method is virtual or not
– Depends on whether called via a reference or
pointer vs. directly on an object
– Depends on whether the call states the scope
explicitly (e.g., Foo::baz();)

CSE 332: C++ Overloading

 Function Overloading
class A {
public:
int add(int i, int j);
// not allowed, would be
// ambiguous with above:
// long add(int m, int n);
// Ok, different signature
long add(long m, long n);
};
int
main (int argc, char **argv) {
int a = 7;
int b = 8;
int c = add(a, b);
return 0;
} – Compiler generates an error if the
CSE 332: C++ Overloading
• Calls to overloaded functions and
operators are resolved by
– Finding all possible matches based
on passed arguments
• May involve type promotion
• May involve instantiating templates
– Finding the “best match” among
those possible matches
• Signature does not include the
return type
– Which might not help even if it did,
i.e., calls may ignore result
– So, overloading can’t be resolved by
return type alone
call can’t be resolved
 Operator Overloading
class A { • Similar to function
friend ostream &operator<<
(ostream &, const A &);
overloading
private: – Resolved by signature
int m_; – Best match is used
};

ostream &operator<< • But the list of operators and

(ostream &out, const A &a) { the “arity” of each is fixed
out << "A::m_ = " << a.m_;
return out; – Can’t invent operators (e.g.,
} like ** for exponentiation )
– Must use same number of
int main () { arguments as for built-in types
A a; (except for operator())
cout << a << endl; – Some operators are off limits
return 0;
}
:: (scope) ?: (conditional)
.* (member dereference)
. (member) sizeof
typeid (RTTI)

CSE 332: C++ Overloading

 Operator Symmetry, Precedence
class Complex {
public:
• Make arithmetic
// Constructor operators symmetric
Complex (double r, double i); – As non-member friends
friend Complex operator* – Return result by value
(const Complex &, const Complex &); – Don’t mix base and
// but not friend Complex operator^ derived types in their
// (const Complex &, const Complex &); parameter lists
private:
• Operators for user-
int real_; defined types obey the
};
int imaginary_; same precedence rules
as for built-in types
// multiplication works just fine – Can lead to some
Complex operator* (const Complex &,
const Complex &);
unexpected mistakes
– E.g., if uncommented
// exponentiation operator unworkable exponentiation for
// Complex operator^ (const Complex &,
// const Complex &); a + b * c ^ 2
CSE 332: C++ Overloading
 Member vs. Non-Member Overloading
// declarations in .h file
class A {
public:
friend bool operator<
(const A &, const A &);
A operator++(); // prefix
A operator++(int); // postfix
private:
int m_;
};
bool operator==(const A &lhs,
const A &rhs);
// definitions in .cpp file
bool operator==(const A &lhs,
const A &rhs)
{return lhs.m_ == rhs.m_;}
A A::operator++() // prefix
{++m_; return *this;}
A A::operator++(int) // postfix
{A ret(*this); ++*this; return ret;}
CSE 332: C++ Overloading
• Remember a this pointer is passed
to any non-static member function
– Object doesn’t appear in parameters
– For non-member functions and
operators all parameters are listed
• The rules about operator arity are
obeyed in code on left
– Operator == is binary
– Prefix/postfix ++ are unary, parameter
for postfix distinguishes its signature
• Must declare and define [] and ==
and -> and () as member operators
• Non-member operators are needed
when working with classes you wrote
and classes you didn’t write
– E.g., ostream << and istream >>
• Non-member operators are also useful
to preserve symmetry
– E.g., for arithmetic/relational operators
– May help to avoid unexpected type
conversions, especially with an
inheritance hierarchy
 Summary: Tips on Overloading
• Use virtual overriding when you want to substitute
different subtypes polymorphically
– E.g., move() in derived and base classes

• Use overloading when you want to provide related

interfaces to similar abstractions
– E.g., migrate(Bird &) vs. migrate(Elephant &)
– Make[] -> () = *= ++ -- etc. members
– Make << >> + * - / == < etc. non-members

• Use different names when the abstractions differ

– E.g., fly() versus walk()

CSE 332: C++ Overloading