Inapoi
Inainte
Cuprins
Non-member operators
In some of the previous examples, the
operators may be members or non-members, and it doesn’t seem to make much
difference. This usually raises the question, “Which should I
choose?” In general, if it doesn’t make any difference, they should
be members, to emphasize the association between the operator and its class.
When the left-hand operand is always an object of the current class, this works
fine.
However, sometimes you want the left-hand
operand to be an object of some other class. A common place you’ll see
this is when the operators << and >> are overloaded
for
iostreams.
Since iostreams is a fundamental C++ library, you’ll probably want to
overload these operators for most of your classes, so the process is worth
memorizing:
//: C12:IostreamOperatorOverloading.cpp
// Example of non-member overloaded operators
#include "../require.h"
#include <iostream>
#include <sstream> // "String streams"
#include <cstring>
using namespace std;
class IntArray {
enum { sz = 5 };
int i[sz];
public:
IntArray() { memset(i, 0, sz* sizeof(*i)); }
int& operator[](int x) {
require(x >= 0 && x < sz,
"IntArray::operator[] out of range");
return i[x];
}
friend ostream&
operator<<(ostream& os, const IntArray& ia);
friend istream&
operator>>(istream& is, IntArray& ia);
};
ostream&
operator<<(ostream& os, const IntArray& ia) {
for(int j = 0; j < ia.sz; j++) {
os << ia.i[j];
if(j != ia.sz -1)
os << ", ";
}
os << endl;
return os;
}
istream& operator>>(istream& is, IntArray& ia){
for(int j = 0; j < ia.sz; j++)
is >> ia.i[j];
return is;
}
int main() {
stringstream input("47 34 56 92 103");
IntArray I;
input >> I;
I[4] = -1; // Use overloaded operator[]
cout << I;
} ///:~
This class also contains an overloaded
operator
[ ], which returns a reference to a legitimate value in the array. Because a
reference is returned, the expression
I[4] = -1;
not only looks much more civilized than
if pointers were used, it also accomplishes the desired effect.
It’s important that the overloaded
shift operators pass and return by reference, so the actions will affect
the external objects. In the function definitions, expressions
like
os << ia.i[j];
cause the existing overloaded
operator functions to be called (that is, those defined in
<iostream>). In this case, the function called is ostream&
operator<<(ostream&, int) because ia.i[j] resolves to an
int.
Once all the actions are performed on the
istream or
ostream, it is returned so it can be used in a
more complicated expression.
In main( ), a new type of
iostream is used: the stringstream
(declared in
<sstream>). This is
a class that takes a string (which it can create from a char
array, as shown here) and turns it into an iostream. In the example
above, this means that the shift operators can be tested without opening a file
or typing data in on the command line.
The form shown in this example for the
inserter and extractor is standard. If you want to create these operators for
your own class, copy the function signatures and return types above and follow
the form of the
body.
Basic guidelines
Murray[49]
suggests these guidelines for choosing between members and
non-members:
|
Operator
|
Recommended use
|
|
|
|
|
|
|
+= –= /= *= ^=
&= |= %= >>=
<<=
|
|
All other binary
operators
|
|
Overloading assignment
A common source of confusion with new C++
programmers is assignment. This is no doubt because the = sign is such a
fundamental operation in programming, right down to copying a register at the
machine level. In addition, the
copy-constructor
(described in Chapter 11) is also sometimes invoked when the
= sign is
used:
MyType b;
MyType a = b;
a = b;
In the second line, the object a
is being defined. A new object is being created where one didn’t
exist before. Because you know by now how defensive the C++ compiler is about
object initialization, you know that a constructor must always be called at the
point where an object is defined. But which constructor? a is being
created from an existing MyType object (b, on the right side of
the equal sign), so there’s only one choice: the copy-constructor. Even
though an equal sign is involved, the copy-constructor is
called.
In the third line, things are different.
On the left side of the equal sign, there’s a previously initialized
object. Clearly, you don’t call a constructor for an object that’s
already been created. In this case MyType::operator= is called for
a, taking as an argument whatever appears on the right-hand side. (You
can have multiple operator= functions to take different types of
right-hand arguments.)
This behavior is not restricted to the
copy-constructor. Any time you’re initializing an
object using an = instead of the ordinary function-call form of the
constructor, the compiler will look for a constructor that accepts whatever is
on the right-hand side:
//: C12:CopyingVsInitialization.cpp
class Fi {
public:
Fi() {}
};
class Fee {
public:
Fee(int) {}
Fee(const Fi&) {}
};
int main() {
Fee fee = 1; // Fee(int)
Fi fi;
Fee fum = fi; // Fee(Fi)
} ///:~
When dealing with the = sign,
it’s important to keep this distinction in mind: If the object
hasn’t been created yet, initialization is required; otherwise the
assignment operator= is used.
It’s even better to avoid writing
code that uses the = for initialization; instead, always use the explicit
constructor form. The two constructions with the equal sign then
become:
Fee fee(1);
Fee fum(fi);
This way, you’ll avoid confusing
your
readers.
Behavior of operator=
In Integer.h and Byte.h,
you saw that operator= can be only a member function. It is intimately
connected to the object on the left side of the ‘=’. If it
was possible to define operator= globally, then you might attempt to
redefine the built-in ‘=’ sign:
int operator=(int, MyType); // Global = not allowed!
The compiler skirts this whole issue by
forcing you to make operator= a member function.
When you create an operator=, you
must copy all of the necessary information from the right-hand object into the
current object (that is, the object that operator= is being called for)
to perform whatever you consider “assignment” for your class. For
simple objects, this is obvious:
//: C12:SimpleAssignment.cpp
// Simple operator=()
#include <iostream>
using namespace std;
class Value {
int a, b;
float c;
public:
Value(int aa = 0, int bb = 0, float cc = 0.0)
: a(aa), b(bb), c(cc) {}
Value& operator=(const Value& rv) {
a = rv.a;
b = rv.b;
c = rv.c;
return *this;
}
friend ostream&
operator<<(ostream& os, const Value& rv) {
return os << "a = " << rv.a << ", b = "
<< rv.b << ", c = " << rv.c;
}
};
int main() {
Value a, b(1, 2, 3.3);
cout << "a: " << a << endl;
cout << "b: " << b << endl;
a = b;
cout << "a after assignment: " << a << endl;
} ///:~
Here, the object on the left side of the
= copies all the elements of the object on the right, then returns a
reference to itself, which allows a more complex expression to be
created.
This example includes a common mistake.
When you’re assigning two objects of the same type, you should always
check first for self-assignment:
is the object being assigned to itself? In some cases, such as this one,
it’s harmless if you perform the assignment operations anyway, but if
changes are made to the implementation of the class, it can make a difference,
and if you don’t do it as a matter of habit, you may forget and cause
hard-to-find bugs.
Pointers in classes
What happens if the object is not so
simple? For example, what if the object contains pointers to other objects?
Simply copying a pointer means that you’ll end up
with two objects pointing to the same storage location. In situations like
these, you need to do bookkeeping of your own.
There are two common approaches to this
problem. The simplest technique is to copy whatever the pointer refers to when
you do an assignment or a copy-construction. This is
straightforward:
//: C12:CopyingWithPointers.cpp
// Solving the pointer aliasing problem by
// duplicating what is pointed to during
// assignment and copy-construction.
#include "../require.h"
#include <string>
#include <iostream>
using namespace std;
class Dog {
string nm;
public:
Dog(const string& name) : nm(name) {
cout << "Creating Dog: " << *this << endl;
}
// Synthesized copy-constructor & operator=
// are correct.
// Create a Dog from a Dog pointer:
Dog(const Dog* dp, const string& msg)
: nm(dp->nm + msg) {
cout << "Copied dog " << *this << " from "
<< *dp << endl;
}
~Dog() {
cout << "Deleting Dog: " << *this << endl;
}
void rename(const string& newName) {
nm = newName;
cout << "Dog renamed to: " << *this << endl;
}
friend ostream&
operator<<(ostream& os, const Dog& d) {
return os << "[" << d.nm << "]";
}
};
class DogHouse {
Dog* p;
string houseName;
public:
DogHouse(Dog* dog, const string& house)
: p(dog), houseName(house) {}
DogHouse(const DogHouse& dh)
: p(new Dog(dh.p, " copy-constructed")),
houseName(dh.houseName
+ " copy-constructed") {}
DogHouse& operator=(const DogHouse& dh) {
// Check for self-assignment:
if(&dh != this) {
p = new Dog(dh.p, " assigned");
houseName = dh.houseName + " assigned";
}
return *this;
}
void renameHouse(const string& newName) {
houseName = newName;
}
Dog* getDog() const { return p; }
~DogHouse() { delete p; }
friend ostream&
operator<<(ostream& os, const DogHouse& dh) {
return os << "[" << dh.houseName
<< "] contains " << *dh.p;
}
};
int main() {
DogHouse fidos(new Dog("Fido"), "FidoHouse");
cout << fidos << endl;
DogHouse fidos2 = fidos; // Copy construction
cout << fidos2 << endl;
fidos2.getDog()->rename("Spot");
fidos2.renameHouse("SpotHouse");
cout << fidos2 << endl;
fidos = fidos2; // Assignment
cout << fidos << endl;
fidos.getDog()->rename("Max");
fidos2.renameHouse("MaxHouse");
} ///:~
Dog is a simple class that
contains only a string that holds the name of the dog. However,
you’ll generally know when something happens to a Dog because the
constructors and destructors print information when they are called. Notice that
the second constructor is a bit like a copy-constructor except that it takes a
pointer to a Dog instead of a reference, and it has a second argument
that is a message that’s concatenated to the argument Dog’s
name. This is used to help trace the behavior of the program.
You can see that whenever a member
function prints information, it doesn’t access that information directly
but instead sends *this to cout. This in turn calls the
ostream operator<<. It’s valuable to do it this way
because if you want to reformat the way that Dog information is displayed
(as I did by adding the ‘[’ and ‘]’) you only need to do
it in one place.
A DogHouse contains a Dog*
and demonstrates the four functions you will always need to define when your
class contains pointers: all necessary ordinary constructors, the
copy-constructor, operator= (either define it or disallow it), and a
destructor. The operator= checks for self-assignment as a matter of
course, even though it’s not strictly necessary here. This virtually
eliminates the possibility that you’ll forget to check for self-assignment
if you do change the code so that it matters.
Reference Counting
In the example above, the
copy-constructor and operator= make a new copy of what the pointer points
to, and the destructor deletes it. However, if your object requires a lot of
memory or a high initialization overhead, you may want to avoid this copying. A
common approach to this problem is called reference
counting.
You give intelligence to the object that’s being pointed to so it knows
how many objects are pointing to it. Then copy-construction or assignment means
attaching another pointer to an existing object and incrementing the reference
count. Destruction means reducing the reference count and destroying the object
if the reference count goes to zero.
But what if you want to write to the
object (the Dog in the example above)? More than one object may be using
this Dog, so you’d be modifying someone else’s Dog as
well as yours, which doesn’t seem very neighborly. To solve this
“aliasing” problem, an additional technique
called copy-on-write is used. Before writing to a
block of memory, you make sure no one else is using it. If the reference count
is greater than one, you must make yourself a personal copy of that block before
writing it, so you don’t disturb someone else’s turf. Here’s a
simple example of reference counting and copy-on-write:
//: C12:ReferenceCounting.cpp
// Reference count, copy-on-write
#include "../require.h"
#include <string>
#include <iostream>
using namespace std;
class Dog {
string nm;
int refcount;
Dog(const string& name)
: nm(name), refcount(1) {
cout << "Creating Dog: " << *this << endl;
}
// Prevent assignment:
Dog& operator=(const Dog& rv);
public:
// Dogs can only be created on the heap:
static Dog* make(const string& name) {
return new Dog(name);
}
Dog(const Dog& d)
: nm(d.nm + " copy"), refcount(1) {
cout << "Dog copy-constructor: "
<< *this << endl;
}
~Dog() {
cout << "Deleting Dog: " << *this << endl;
}
void attach() {
++refcount;
cout << "Attached Dog: " << *this << endl;
}
void detach() {
require(refcount != 0);
cout << "Detaching Dog: " << *this << endl;
// Destroy object if no one is using it:
if(--refcount == 0) delete this;
}
// Conditionally copy this Dog.
// Call before modifying the Dog, assign
// resulting pointer to your Dog*.
Dog* unalias() {
cout << "Unaliasing Dog: " << *this << endl;
// Don't duplicate if not aliased:
if(refcount == 1) return this;
--refcount;
// Use copy-constructor to duplicate:
return new Dog(*this);
}
void rename(const string& newName) {
nm = newName;
cout << "Dog renamed to: " << *this << endl;
}
friend ostream&
operator<<(ostream& os, const Dog& d) {
return os << "[" << d.nm << "], rc = "
<< d.refcount;
}
};
class DogHouse {
Dog* p;
string houseName;
public:
DogHouse(Dog* dog, const string& house)
: p(dog), houseName(house) {
cout << "Created DogHouse: "<< *this << endl;
}
DogHouse(const DogHouse& dh)
: p(dh.p),
houseName("copy-constructed " +
dh.houseName) {
p->attach();
cout << "DogHouse copy-constructor: "
<< *this << endl;
}
DogHouse& operator=(const DogHouse& dh) {
// Check for self-assignment:
if(&dh != this) {
houseName = dh.houseName + " assigned";
// Clean up what you're using first:
p->detach();
p = dh.p; // Like copy-constructor
p->attach();
}
cout << "DogHouse operator= : "
<< *this << endl;
return *this;
}
// Decrement refcount, conditionally destroy
~DogHouse() {
cout << "DogHouse destructor: "
<< *this << endl;
p->detach();
}
void renameHouse(const string& newName) {
houseName = newName;
}
void unalias() { p = p->unalias(); }
// Copy-on-write. Anytime you modify the
// contents of the pointer you must
// first unalias it:
void renameDog(const string& newName) {
unalias();
p->rename(newName);
}
// ... or when you allow someone else access:
Dog* getDog() {
unalias();
return p;
}
friend ostream&
operator<<(ostream& os, const DogHouse& dh) {
return os << "[" << dh.houseName
<< "] contains " << *dh.p;
}
};
int main() {
DogHouse
fidos(Dog::make("Fido"), "FidoHouse"),
spots(Dog::make("Spot"), "SpotHouse");
cout << "Entering copy-construction" << endl;
DogHouse bobs(fidos);
cout << "After copy-constructing bobs" << endl;
cout << "fidos:" << fidos << endl;
cout << "spots:" << spots << endl;
cout << "bobs:" << bobs << endl;
cout << "Entering spots = fidos" << endl;
spots = fidos;
cout << "After spots = fidos" << endl;
cout << "spots:" << spots << endl;
cout << "Entering self-assignment" << endl;
bobs = bobs;
cout << "After self-assignment" << endl;
cout << "bobs:" << bobs << endl;
// Comment out the following lines:
cout << "Entering rename(\"Bob\")" << endl;
bobs.getDog()->rename("Bob");
cout << "After rename(\"Bob\")" << endl;
} ///:~
The class Dog is the object
pointed to by a DogHouse. It contains a reference count and functions to
control and read the reference count. There’s a copy-constructor so you
can make a new Dog from an existing one.
The attach( ) function
increments the reference count of a Dog to indicate there’s another
object using it. detach( ) decrements the reference count. If the
reference count goes to zero, then no one is using it anymore, so the member
function destroys its own object by saying delete this.
Before you make any modifications (such
as renaming a Dog), you should ensure that you aren’t changing a
Dog that some other object is using. You do this by calling
DogHouse::unalias( ), which in turn calls
Dog::unalias( ). The latter function will return the existing
Dog pointer if the reference count is one (meaning no one else is
pointing to that Dog), but will duplicate the Dog if the reference
count is more than one.
The copy-constructor, instead of creating
its own memory, assigns Dog to the Dog of the source object. Then,
because there’s now an additional object using that block of memory, it
increments the reference count by calling
Dog::attach( ).
The operator= deals with an object
that has already been created on the left side of the =, so it must first
clean that up by calling detach( ) for that Dog, which will
destroy the old Dog if no one else is using it. Then operator=
repeats the behavior of the copy-constructor. Notice that it first checks to
detect whether you’re assigning the same object to
itself.
The destructor calls
detach( ) to conditionally destroy the Dog.
To implement copy-on-write, you must
control all the actions that write to your block of memory. For example, the
renameDog( ) member function allows you to change the values in the
block of memory. But first, it uses unalias( ) to prevent the
modification of an aliased Dog (a Dog with more than one
DogHouse object pointing to it). And if you need to produce a pointer to
a Dog from within a DogHouse, you unalias( ) that
pointer first.
main( ) tests the various
functions that must work correctly to implement reference counting: the
constructor, copy-constructor, operator=, and destructor. It also tests
the copy-on-write by calling renameDog( ).
Here’s the output (after a little
reformatting):
Creating Dog: [Fido], rc = 1
Created DogHouse: [FidoHouse]
contains [Fido], rc = 1
Creating Dog: [Spot], rc = 1
Created DogHouse: [SpotHouse]
contains [Spot], rc = 1
Entering copy-construction
Attached Dog: [Fido], rc = 2
DogHouse copy-constructor:
[copy-constructed FidoHouse]
contains [Fido], rc = 2
After copy-constructing bobs
fidos:[FidoHouse] contains [Fido], rc = 2
spots:[SpotHouse] contains [Spot], rc = 1
bobs:[copy-constructed FidoHouse]
contains [Fido], rc = 2
Entering spots = fidos
Detaching Dog: [Spot], rc = 1
Deleting Dog: [Spot], rc = 0
Attached Dog: [Fido], rc = 3
DogHouse operator= : [FidoHouse assigned]
contains [Fido], rc = 3
After spots = fidos
spots:[FidoHouse assigned] contains [Fido],rc = 3
Entering self-assignment
DogHouse operator= : [copy-constructed FidoHouse]
contains [Fido], rc = 3
After self-assignment
bobs:[copy-constructed FidoHouse]
contains [Fido], rc = 3
Entering rename("Bob")
After rename("Bob")
DogHouse destructor: [copy-constructed FidoHouse]
contains [Fido], rc = 3
Detaching Dog: [Fido], rc = 3
DogHouse destructor: [FidoHouse assigned]
contains [Fido], rc = 2
Detaching Dog: [Fido], rc = 2
DogHouse destructor: [FidoHouse]
contains [Fido], rc = 1
Detaching Dog: [Fido], rc = 1
Deleting Dog: [Fido], rc = 0
By studying the output, tracing through
the source code, and experimenting with the program, you’ll deepen your
understanding of these techniques.
 |
|
|
