C++: a beginner's Guide, Second Edition

6 
C++ A Beginner’s Guide by Herbert Schildt 
1.
 
A class can contain what two things?
2.
 
What operator is used to access the members of a class through an object?
3.
 
Each object has its own copies of the class’ _____________.
CRITICAL SKILL 8.3: Adding Member Functions to a Class
So far, Vehicle contains only data, but no functions. Although data-only classes are perfectly valid, most 
classes will have function members. In general, member functions manipulate the data defined by the 
class and, in many cases, provide access to that data. Typically, other parts of your program will interact 
with a class through its functions.
To illustrate member functions, we will add one to the Vehicle class. Recall that main( ) in the preceding 
examples computed the range of a vehicle by multiplying its fuel consumption rate by its fuel capacity. 
While technically correct, this is not the best way to handle this computation. The calculation of a 
vehicle’s range is something that is best handled by the
Vehicle class itself. The reason for this conclusion is easy to understand: The range of a vehicle is 
dependent upon the capacity of the fuel tank and the rate of fuel consumption, and both of these 
quantities are encapsulated by Vehicle. By adding a function to Vehicle that computes the range, you 
are enhancing its object-oriented structure.
To add a function to Vehicle, specify its prototype within Vehicle’s declaration. For example, the 
following version of Vehicle specifies a member function called range( ), which returns the range of the 
vehicle:

---

7 
C++ A Beginner’s Guide by Herbert Schildt 
Because a member function, such as range( ), is prototyped within the class definition, it need not be 
prototyped elsewhere.
To implement a member function, you must tell the compiler to which class the function belongs by 
qualifying the function’s name with its class name. For example, here is one way to code the range( ) 
function:
// Implement the range member function. int Vehicle::range() {
return mpg * fuelcap; }
Notice the :: that separates the class name Vehicle from the function name range( ). The :: is called the 
scope resolution operator. It links a class name with a member name in order to tell the compiler what 
class the member belongs to. In this case, it links range( ) to the Vehicle class. In other words, :: states 
that this range( ) is in Vehicle’s scope. Several different classes can use the same function names. The 
compiler knows which function belongs to which class because of the scope resolution operator and the 
class name.
The body of range( ) consists solely of this line:
return mpg * fuelcap;
This statement returns the range of the vehicle by multiplying fuelcap by mpg. Since each object of type 
Vehicle has its own copy of fuelcap and mpg, when range( ) is called, the range computation uses the 
calling object’s copies of those variables.
Inside range( ) the instance variables fuelcap and mpg are referred to directly, without preceding them 
with an object name or the dot operator. When a member function uses an instance variable that is 
defined by its class, it does so directly, without explicit reference to an object and without use of the dot 
operator. This is easy to understand if you think about it. A member function is always invoked relative 
to some object of its class. Once this invocation has occurred, the object is known. Thus, within a 
member function, there is no need to specify the object a second time. This means that fuelcap and mpg 
inside range( ) implicitly refer to the copies of those variables found in the object that invokes range( ). 
Of course, code outside Vehicle must refer to fuelcap and mpg through an object and by using the dot 
operator.
A member function must be called relative to a specific object. There are two ways that this can happen. 
First, a member function can be called by code that is outside its class. In this case, you must use the 
object’s name and the dot operator. For example, this calls range( ) on minivan:

---

8 
C++ A Beginner’s Guide by Herbert Schildt 
range = minivan.range();
The invocation minivan.range( ) causes range( ) to operate on minivan’s copy of the instance variables. 
Thus, it returns the range for minivan.
The second way a member function can be called is from within another member function of the same 
class. When one member function calls another member function of the same class, it can do so directly, 
without using the dot operator. In this case, the compiler already knows which object is being operated 
upon. It is only when a member function is called by code that does not belong to the class that the 
object name and the dot operator must be used.
The program shown here puts together all the pieces and missing details, and illustrates the range( ) 
function:

---

9 
C++ A Beginner’s Guide by Herbert Schildt 
This program displays the following output:
Minivan can carry 7 with a range of 336
Sportscar can carry 2 with a range of 168