[ Pobierz całość w formacie PDF ]
" Direct member access, operator .
" Deference pointer to class member, operator .*
" Scope resolution, operator ::
" Size of, operator sizeof
The conditional operator ?: cannot be overloaded either.
Additionally, the new type cast operators -- static_cast, dynamic_cast,
reinterpret_cast, and const_cast -- and the # and ## preprocessor tokens
cannot be overloaded.
Conversion Operators
It is not uncommon to find C++ and C code used together. For instance, legacy systems
that were originally written in C can be wrapped by an object-oriented interface. Such
bilingual systems often need to support a dual interface at the same time -- one that caters
to an object-oriented environment and another that caters to C environment. Classes that
implement specific numeric entities -- such as complex numbers and binary numbers --
and nibbles also tend to use conversion operators to enable smoother interaction with
fundamental types.
Strings are a classic example of the need for a dual interface. A string object might have
to be used in contexts that support only null-terminated char arrays. For example
class Mystring
{
private:
char *s;
int size;
public:
Mystring(const char *);
Mystring();
//...
};
#include
#include "Mystring.h"
using namespace std;
int main()
{
Mystring str("hello world");
int n = strcmp(str, "Hello"); //compile time error:
//str is not of type const char *
return 0;
}
C++ offers an automatic means of type conversion for such cases. A conversion operator
can be thought of as a user-defined typecasting operator; it converts its object to a
different type in contexts that require that specific type. The conversion is done
automatically. For example
class Mystring //now with conversion operator
{
private:
char *s;
int size;
public:
Mystring();
operator const char * () {return s; } //convert Mystring to a C-
string
//...
};
int n = strcmp(str, "Hello"); //OK, automatic conversion of str to
const char *
Conversion operators differ from ordinary overloaded operators in two ways. First, a
conversion operator does not have a return value (not even void). The return value is
deduced from the operator's name.
Secondly, a conversion operator takes no arguments.
Conversion operators can convert their object to any given type, fundamental and user-
defined alike:
struct DateRep //legacy C code
{
char day;
char month;
short year;
};
class Date // object-oriented wrapper
{
private:
DateRep dr;
public:
operator DateRep () const { return dr;} // automatic conversion to
DateRep
};
extern "C" int transmit_date(DateRep); // C-based communication API
function
int main()
{
Date d;
//...use d
//transmit date object as a binary stream to a remote client
int ret_stat = transmit_date; //using legacy communication API
return 0;
}
Standard Versus User-Defined Conversions
The interaction of a user-defined conversion with a standard conversion can cause
undesirable surprises and side effects, and therefore must be used with caution. Examine
the following concrete example.
A non-explicit constructor that takes a single argument is also a conversion operator,
which casts its argument to an object of this class. When the compiler has to resolve an
overloaded function call, it takes into consideration such user-defined conversions in
addition to the standard ones. For example
class Numeric
{
private:
float f;
public:
Numeric(float ff): f(ff) {} //constructor is also a float-to-Numeric
// conversion operator
};
void f(Numeric);
Numeric num(0.05);
f(5.f); //OK, calls void f(Numeric). Numeric's constructor
//converts argument to a Numeric object
'Suppose you add, at a later stage, another overloaded version of f():
void f (double);
Now the same function call resolves differently:
f(5.f); // now calls f(double), not f(Numeric)
This is because float is promoted to double automatically in order to match an
overloaded function signature. This is a standard type conversion. On the other hand, the
conversion of float to Numeric is a user-defined conversion. User-defined conversions
rank lower than standard conversions -in overload resolution; as a result, the function call
resolves differently.
Because of this phenomenon and others, conversion operators have been severely
criticized. Some programming schools ban their usage altogether. However, conversion
operators are a valuable -- and sometimes inevitable -- tool for bridging between dual
interfaces, as you have seen.
Postfix and Prefix Operators
For primitive types, C++ distinguishes between ++x; and x++; as well as between --x;
and x--;. Under some circumstances, objects have to distinguish between prefix and
postfix overloaded operators as well (for example, as an optimization measure. See
Chapter 12, "Optimizing Your Code"). Postfix operators are declared with a dummy int
argument, whereas their prefix counterparts take no arguments. For example
class Date
{
public:
Date& operator++(); //prefix
Date& operator--(); //prefix
Date& operator++(int unused); //postfix
Date& operator--(int unused); //postfix
};
void f()
{
Date d, d1;
d1 = ++d;//prefix: first increment d and then assign to d1
d1 = d++; //postfix; first assign, increment d afterwards
}
Using Function Call Syntax
An overloaded operator call is merely "syntactic sugar" for an ordinary function call. You
[ Pobierz całość w formacie PDF ]