📄 index.html
字号:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<HTML>
<HEAD>
<META NAME="Author" Content="Steph Mineart">
<META HTTP-EQUIV="Content-Type" CONTENT="text/html;CHARSET=iso-8859-1">
<TITLE>ANSI/ISO C++ Professional Programmer's Handbook - Chapter 3 - Operator Overloading </TITLE>
<link rel="stylesheet" TYPE="text/css" href="/includes/stylesheets/ebooks.css">
</head>
<BODY TEXT="#000000" BGCOLOR="#FFFFFF">
<CENTER>
<H1><img src="/publishers/que/series/professional/0789720221/button/que.gif" WIDTH="171" HEIGHT="66" ALIGN="BOTTOM" BORDER="0"><BR>
ANSI/ISO C++ Professional Programmer's Handbook</H1>
</CENTER>
<CENTER>
<P><A HREF="/publishers/que/series/professional/0789720221/index.htm"><img src="/publishers/que/series/professional/0789720221/button/contents.gif" WIDTH="128"
HEIGHT="28" ALIGN="BOTTOM" ALT="Contents" BORDER="0"></A>
<HR>
</CENTER>
<H1 align="center"> 3</H1>
<h1 align="center"> Operator Overloading</h1>
<address>by Danny Kalev</address>
<ul>
<li><a href="#Heading1">Introduction</a>
<li><a href="#Heading2">Operator Overloading Rules of Thumb</a>
<ul>
<li><a href="#Heading3">Members and Nonmembers</a>
<li><a href="#Heading4">Operator's Interface</a>
<li><a href="#Heading5"> Operator Associativity</a>
</ul>
<li><a href="#Heading6">Restrictions on Operator Overloading</a>
<ul>
<li><a href="#Heading7">Operators Can Only Be Overloaded for User-Defined
Types </a>
<li><a href="#Heading8">Invention of New Operators Is Not Allowed</a>
<li><a href="#Heading9"> Precedence and Argument Number</a>
<li><a href="#Heading10">Default Parameters</a>
<li><a href="#Heading11">Operators That Cannot Be Overloaded</a>
</ul>
<li><a href="#Heading12">Conversion Operators</a>
<ul>
<li><a href="#Heading13">Standard Versus User-Defined Conversions</a>
</ul>
<li><a href="#Heading14">Postfix and Prefix Operators</a>
<li><a href="#Heading15">Using Function Call Syntax</a>
<li><a href="#Heading16">Consistent Operator Overloading</a>
<li><a href="#Heading17"> 'Returning Objects by Value</a>
<li><a href="#Heading18">Multiple Overloading</a>
<li><a href="#Heading19">Overloading Operators for Other User-Defined types</a>
<li><a href="#Heading20">Overloading the Subscripts Operator</a>
<li><a href="#Heading21">Function Objects</a>
<li><a href="#Heading22">Conclusions</a>
</ul>
<hr size=4>
<h2> <a name="Heading1">Introduction</a></h2>
<p>A built-in operator can be extended to support user-defined types as well.
Such an extension <i>overloads</i> the predefined meaning of an operator rather
than overrides it. Although ordinary functions can offer the same functionality,
operator overloading provides a uniform notational convention that is clearer
than the ordinary function call syntax. For example</p>
<pre>
<tt>Monday < Tuesday; //overloaded < </tt>
<tt>Greater_than(Monday, Tuesday); </tt>
</pre>
<p>The history of operator overloading can be traced back to the early days of
Fortran. Fortran, the first high-level programming language, presented the concept
of operator overloading in a way that was revolutionary back in the mid-1950s.
For the first time, built-in operators such as <tt>+</tt> or <tt>-</tt> could
be applied to various data types: integers, real and complex. Until then, assembly
languages -- which didn't even support operator notation -- had been the only
choice for programmers. Fortran's operator overloading was limited to a fixed
set of built-in data types; they could not be extended by the programmer. Object-based
programming languages offered user-defined overloaded operators. In such languages,
it is possible to associate a set of operators with a user-defined type. Object-oriented
languages usually incorporate operator overloading as well.</p>
<p>The capability to redefine the meaning of a built-in operator in C++ was a
source of criticism. People -- mostly C programmers making the migration to
C++ -- felt that overloading an operator was as dangerous as enabling the programmer
to add, remove, or change keywords of the language. Still, notwithstanding the
potential Tower of Babel that might arise as a result, operator overloading
is one of the most fundamental features of C++ and is mandatory for generic
programming (generic programming is discussed in Chapter 10, "STL and Generic
Programming."). Today, even languages that tried to make do without operator
overloading are in the process of adding this feature.</p>
<p>This chapter explores the benefits as well as the potential problems of operator
overloading. It also discusses the few restrictions that apply to operator overloading.
Finally, it presents conversion operators, which are a special form of overloaded
operators.</p>
<p>An overloaded operator is essentially a function whose name is an operator
preceded by the keyword <tt>operator</tt>. For example</p>
<pre>
<tt>class Book</tt>
<tt>{</tt>
<tt>private:</tt>
<tt> long ISBN;</tt>
<tt>public:</tt>
<tt>//...</tt>
<tt> long get_ISBN() const { return ISBN;}</tt>
<tt>};</tt>
<tt>bool operator < (const Book& b1, const Book& b2) // overload operator <</tt>
<tt>{</tt>
<tt> return b1.get_ISBN() < b2.get_ISBN();</tt>
<tt>} </tt>
</pre>
<h2> <a name="Heading2">Operator Overloading Rules of Thumb</a></h2>
<p>C++ enforces few restrictions on operator overloading. For instance, it does
not prohibit a programmer from overloading the operator <tt>++</tt> in order
to perform a decrement operation on its object (to the dismay of its users,
who would instead expect operator <tt>++</tt> to perform an increment operation).
Such misuses and puns can lead to a cryptic coding style that is almost unintelligible.
Often, the source code that contains the definition of an overloaded operator
is not accessible to its users; therefore, overloading an operator in an unexpected,
nonintuitive manner is not recommended.</p>
<p>The other extreme, avoiding operator overloading altogether, is not a practical
choice either because it means giving up an important tool for data abstraction
and generic programming. When you are overloading an operator to support a user-defined
type, therefore, it is recommended that you adhere to the basic semantics of
the corresponding built-in operator. In other words, an overloaded operator
has the same side effects on its operands and manifests the same interface as
does the corresponding built-in operator.</p>
<h3> <a name="Heading3">Members and Nonmembers</a></h3>
<p>Most of the overloaded operators can be declared either as nonstatic class
members or as nonmember functions. In the following example, the operator <tt>==</tt>
is overloaded as a nonstatic class member:</p>
<pre>
<tt>class Date</tt>
<tt>{</tt>
<tt>private:</tt>
<tt> int day;</tt>
<tt> int month;</tt>
<tt> int year;</tt>
<tt>public:</tt>
<tt> bool operator == (const Date & d ); // 1: member function</tt>
<tt>};</tt>
</pre>
<p>Alternatively, it can be declared as a <tt>friend</tt> function (the criteria
for choosing between a member and a friend will be discussed later in this chapter):</p>
<pre>
<tt>bool operator ==( const Date & d1, const Date& d2); // 2: nonmember function</tt>
<tt>class Date</tt>
<tt>{</tt>
<tt>private:</tt>
<tt> int day;</tt>
<tt> int month; </tt>
<tt> int year;</tt>
<tt>public:</tt>
<tt> friend bool operator ==( const Date & d1, const Date& d2);</tt>
<tt>};</tt>
</pre>
<p>Nonetheless, the operators <tt>[]</tt>, <tt>()</tt>, <tt>=</tt>, and <tt>-></tt>
can only be declared as nonstatic member functions; this ensures that their
first operand is an lvalue.</p>
<h3> <a name="Heading4">Operator's Interface</a></h3>
<p>When you overload an operator, adhere to the interface of its built-in counterpart.
The interface of an operator consists of the number of operands to which it
applies, whether any of these operands can be altered by the operator, and the
result that is returned by the operator. For example, consider operator <tt>==</tt>.
Its built-in version can be applied to a wide variety of fundamental types,
including <tt>int</tt>, <tt>bool</tt>, <tt>float</tt>, and <tt>char</tt>, and
to pointers. The underlying computation process that is required for testing
whether the operands of operator <tt>==</tt> are equal is an implementation-detail.
However, it can be generalized that the built-in <tt>==</tt> operator tests
its left and right operands for equality and returns a <tt>bool</tt> value as
its result. It is important to note also that operator <tt>==</tt> does not
modify any of its operands; in addition, the order of the operands is immaterial
in the case of operator <tt>==</tt>. An overloaded operator <tt>==</tt> should
conform to this behavior, too.</p>
<h3> <a name="Heading5"> Operator Associativity</a></h3>
<p>Operator <tt>==</tt> is binary and symmetrical. An overloaded version of <tt>==</tt>
conforms to these qualities. It takes two operands, which are of the same type.
Indeed, one can use operator <tt>==</tt> to test the equality of two operands
of distinct fundamental types, for example <tt>char</tt> and <tt>int</tt>. However,
C++ automatically applies <i>integral promotion</i> to the operands in this
case; as a result, the seemingly distinct types are promoted to a single common
type before they are compared.<i> </i>The symmetrical quality implies that an
overloaded operator <tt>==</tt> is to be defined as a <tt>friend</tt> function
rather than a member function. So that you can see why, here's a comparison
of two different versions of the same overloaded operator <tt>==</tt>:</p>
<pre>
<tt>class Date</tt>
<tt>{</tt>
<tt>private:</tt>
<tt> int day;</tt>
<tt> int month; </tt>
<tt> int year;</tt>
<tt>public:</tt>
<tt> Date();</tt>
<tt> bool operator == (const Date & d) const; // 1 asymmetrical</tt>
<tt> friend bool operator ==(const Date& d1, const Date& d2); //2 symmetrical</tt>
<tt>};</tt>
<tt>bool operator ==(const Date& d1, const Date& d2);</tt>
</pre>
<p>The overloaded operator <tt>==</tt> that is declared as a member function in
<tt>(1)</tt> is inconsistent with the built-in operator <tt>==</tt> because
it takes two arguments of different types. The compiler transforms the member
operator <tt>==</tt> into the following:</p>
<pre>
<tt>bool Date::operator == (const Date *const, const Date&) const; </tt>
</pre>
<p>The first argument is a <tt>const this</tt> pointer that points to a <tt>const</tt>
object (remember that <tt>this</tt> is always a <tt>const</tt> pointer; it points
to a <tt>const</tt> object when the member function is also <tt>const)</tt>.
The second argument is a reference to <tt>const Date</tt>. Clearly, these are
two distinct types for which no standard conversion exists. On the other hand,
the <tt>friend</tt> version takes two arguments of the same type. There are
practical implications to favoring the <tt>friend</tt> version over the member
function. STL algorithms rely on a symmetrical version of the overloaded operator
<tt>==</tt>. For example, containers that store objects that do not have symmetrical
operator <tt>==</tt> cannot be sorted.</p>
<p>Another example, built-in operator <tt>+=</tt>, which also takes two operands,
modifies its left operand but leaves the right operand unchanged. The interface
of an overloaded <tt>+=</tt> needs to reflect the fact that it modifies its
object but not its right operand. This is reflected by the declaration of the
function parameter as <tt>const</tt>, whereas the function itself is a non-<tt>const</tt>
member function. For example</p>
<pre>
<tt>class Date</tt>
<tt>{</tt>
<tt>private:</tt>
<tt> int day;</tt>
<tt> int month; </tt>
<tt> int year;</tt>
<tt>public:</tt>
<tt> Date();</tt>
<tt> //built-in += changes its left operand but not its right one</tt>
<tt> //the same behavior is maintained here</tt>
<tt> Date & operator += (const Date & d);</tt>
<tt>};</tt>
</pre>
<p>To conclude, it can be said that every overloaded operator must implement an
interface that is similar to the one that is manifested by the built-in operator.
The implementer is free to define the underlying operation and hide its details
-- as long as it conforms to the interface.</p>
<h2> <a name="Heading6">Restrictions on Operator Overloading</a></h2>
<p>As was previously noted, an overloaded operator is a function that is declared
with the <tt>operator</tt> keyword, immediately followed by an <i>operator id.</i>
An operator id can be one of the following:</p>
<pre>
<tt>new delete new[] delete[]</tt>
<tt>+ - * / % ^ & | ~</tt>
<tt>! = < > += -= *= /= %=</tt>
<tt>^= &= |= << >> >>= <<= == !=</tt>
<tt><= >= && || ++ -- , ->* -></tt>
<tt>() []</tt>
</pre>
<p>In addition, the following operators can be overloaded both in their unary
and binary forms:</p>
<pre>
<tt>+ - * &</tt>
</pre>
<p>Overloaded operators are inherited in the same manner as other base class functions.
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -