| |
Access functions
One of the most important uses of inlines
inside classes is the access
function. This is a small
function that allows you to read or change part of the state of an object
– that is, an internal variable or variables. The reason inlines are so
important for access functions can be seen in the following
example:
//: C09:Access.cpp
// Inline access functions
class Access {
int i;
public:
int read() const { return i; }
void set(int ii) { i = ii; }
};
int main() {
Access A;
A.set(100);
int x = A.read();
} ///:~
Here, the class user never has direct
contact with the state variables inside the class, and they can be kept
private, under the
control of the class designer. All the access to the private data members
can be controlled through the member function interface. In addition, access is
remarkably efficient. Consider the read( ), for example. Without
inlines, the code generated for the call to read( ) would typically
include pushing this on
the stack and making an assembly language CALL. With most machines, the size of
this code would be larger than the code created by the inline, and the execution
time would certainly be longer.
Without inline functions, an
efficiency-conscious class designer will be tempted to simply make i a
public member, eliminating the overhead by allowing the user to directly access
i. From a design standpoint, this is disastrous
because i then becomes part of the public interface, which means the
class designer can never change it. You’re stuck with an int called
i. This is a problem because you may learn sometime later that it would
be much more useful to represent the state information as a float rather
than an int, but because int i is part of the public interface,
you can’t change it. Or you may want to perform some additional
calculation as part of reading or setting i, which you can’t do if
it’s public. If, on the other hand, you’ve always used
member functions to read and change the state information of an object, you can
modify the underlying representation of the object to your heart’s
content.
In addition, the use of member functions
to control data members allows you to add code to the member function to detect
when that data is being changed, which can be very useful during debugging. If a
data member is public, anyone can change it anytime without you knowing
about it.
|
|
