Selected C++ Example #5
//Example #5
// This example with its five parts will illustrate how a
// uses relationship may be implemented. The most common
// method of implementing the uses relationship is via
// containment. Containment relationships always imply
// uses, but uses do not always imply containment. The second
// example illustrates uses via containment. How does a Meal
// know the name of its Melon object when it wants to use
// it? Answer: It knows its name because it contains it, i.e.,
// Meals contain Melons.
// This brings up an interesting point. In a design
// discussion, if a member of the design team states that
// some class X uses class Y, always ask, ''How does the X
// object know the name of the Y object?''. While the answer is
// often, ''Because X contains the Y object,'' there are five
// other possibilities. We will discuss these in the context
// of a car using a gas station.
// How does the Car object know the name of the GasStation
// object? It clearly doesn't contain it; Cars do not contain
// GasStations.
// The first, and most popular, method is that the Car object
// is given the GasStation object as an explicit parameter to
// its method. This is illustrated by the Car1 class.
// The second method is for all Car objects to go to the
// same global GasStation. They know its name by hardcoding
// it into the Car's method(s). Some consider this to be
// a special case of the first method since global variables
// are really implicit parameters. Because it has a different
// form, we implement it in the class Car2.
// The third method is for the wealthy. When their Car runs
// out of gasoline, they build a GasStation, pump gas, and
// tear down the gas station. While this is ridiculous in
// the domain of cars and gas stations, it is appropriate in
// many domains. The Car3 class captures this method of using
// local objects.
// The fourth method is that when a car is born, god gives
// it its gas station for later use. Each car has a one-to-one
// association with its gas station. We will talk more about
// associations in Chapter 7, but this serves as a good example
// of the implementation of associations. Do not confuse
// an association with containment by reference. The
// relationships are very different at design time, however,
// C++ does not distinguish them. The class Car4 implements
// this feature.
// The fifth method is for the Car class to ask a third-party
// object for a gas station. Of course, this only postpones
// the problem. How did we know the name of the third-party
// object? It must be one of the other five methods: i.e.,
// containment, passed as an argument, a global object,
// a local object, an association, or ... ask a fourth-
// party object ... (ad nauseum).
// The Car5 class illustrates this implementation of uses by
// asking a contained map object for a gas station.
#include <iostream.h>
// The GasStation is the same class in all five methods of
// implementing uses relationships. The only interest is how
// we gain knowledge of the name of a particular gas station
// we want to use. Our gas station has a constructor; it
// can take gas deliveries, it can change its price (no grades
// of gasoline here, for simplification), and most
// importantly, it can dispense gasoline to anyone willing
// to pay. In our case, Car objects.
class GasStation{
private:
double quantityOfGas;
double price;
public:
GasStation(double, double quantity=0.0);
void take_gas_delivery(double);
void change_price(double);
double give_gasoline(double);
};
GasStation::GasStation(double start_price, double quantity)
{
quantityOfGas = quantity;
price = start_price;
}
void
GasStation::take_gas_delivery(double quantity)
{
quantityOfGas += quantity;
}
void
GasStation::change_price(double new_price)
{
price = new_price;
}
double
GasStation::give_gasoline(double amount)
{
double gas_purchased;
gas_purchased = amount / price;
quantityOfGas -= gas_purchased;
if (quantityOfGas < 0) {
gas_purchased += quantityOfGas;
quantityOfGas = 0.0;
}
return(gas_purchased);
}
// The Car1 class implements the first method of implementing
// a uses relationship which is not containment. The Car's
// get_gasoline method takes not only money, but also a
// GasStation object, as an argument.
class Car1 {
private:
double milesPerGallon;
double fuelCapacity;
double gasInTank;
double mileage;
public:
Car1(double, double, double=0.0, double=0.0);
void get_gasoline(GasStation&, double);
void drive(double);
void print();
};
Car1::Car1(double mpg, double capacity, double starting_gas,
double miles)
{
milesPerGallon = mpg;
fuelCapacity = capacity;
gasInTank = starting_gas;
mileage = miles;
}
// The drive method computes the gasoline needed to travel the
// desired distance. It then checks to see if there is enough
// gasoline in the car. If not, a message is printed to the user and
// the car moves as far as it can. If the car has less than 10% of its
// remaining capacity, a warning is printed to the user.
void
Car1::drive(double miles)
{
double gas_needed;
gas_needed = miles / milesPerGallon;
if (gas_needed > gasInTank) {
mileage += gasInTank * milesPerGallon;
cerr << ''You ran out of gasoline after travelling '';
cerr << gasInTank * milesPerGallon << '' miles.\n'';
gasInTank = 0.0;
}
else {
mileage += miles;
gasInTank -= gas_needed;
if (gasInTank < 0.1 * fuelCapacity) {
cerr << ''Warning: You have only enough gas
to go '';
cerr << GasInTank * miles_per_gallon << ''
miles.\n'';
}
}
}
// The get_gasoline method is the most interesting. In this
// implementation the Car class knows the name of its gas station
// because it is passed into the method. The gas station is used to
// get the gasoline, and a number of checks are made to be sure the
// gas station wasn't out of gas or that the user didn't spill some
// gas. Of course, this implementation could be made more
// elaborate but this will suffice to demonstrate the
// implementation of ''Car uses GasStation. ''
void
Car1::get_gasoline(GasStation& myGasStation, double money)
{
double gas_received;
gas_received = myGasStation.give_gasoline(money);
if (gas_received == 0) {
cerr << ''Sorry the gas station was out of gas.\n'';
}
else {
gasInTank += gas_received;
if (gasInTank > fuelCapacity) {
cerr << ''You spilled '' << (gasInTank -
fuelCapacity);
cerr << '' gallons of gas on the ground.\n'';
gasInTank = fuelCapacity;
}
}
}
void
Car1::print()
{
cout << ''The car gets '' << miles_per_gallon;
cout << '' miles per gallon.\nIt currently has '';
cout << gasInTank << '' gallons of gasoline on board.\n'';
cout << ''Its maximum fuel capacity is '' << fuelCapacity;
cout << '' gallons\nand it has '' << mileage << '' miles.\n''
}
// The Car2 class demonstrates the implementation of a uses
// relationship through a global GasStation object. In this case,
// all Car2 objects go to the same GasStation, in this case
// ''Global_GasStation.'' Some designers consider this a special
// case of implementing the uses relationship through a parameter
// (e.g., Car1), but since it looks different in implementation, I
// felt it should be included.
GasStation Global_GasStation(1.25, 10000);
class Car2 {
private:
double milesPerGallon;
double fuelCapacity;
double gasInTank;
double mileage;
public:
Car2(double, double, double=0.0, double=0.0);
void get_gasoline(double);
void drive(double);
void print();
};
Car2::Car2(double mpg, double capacity, double starting_gas,
double miles)
{
milesPerGallon = mpg;
fuelCapacity = capacity;
gasInTank = starting_gas;
mileage = miles;
}
void
Car2::drive(double miles)
{
double gas_needed;
gas_needed = miles / milesPerGallon;
if (gas_needed > gasInTank) {
mileage += gasInTank * milesPerGallon;
cerr << ''You ran out of gasoline after travelling '';
cerr << gasInTank * milesPerGallon << '' miles.\n'';
gasInTank = 0.0;
}
else {
mileage += miles;
gasInTank -= gas_needed;
if (gasInTank < 0.1 * fuelCapacity) {
cerr << ''Warning: You have only enough gas
to go '';
cerr << GasInTank * milesPerGallon << ''
miles.\n'';
}
}
}
// Note the use of the Global_GasStation object to get_gasoline.
void
Car2::get_gasoline(double money)
{
double gas_received;
gas_received = Global_GasStation.give_gasoline(money);
if (gas_received == 0) {
cerr << ''Sorry the gas station was out of gas.\n'';
}
else {
gasInTank += gas_received;
if (gasInTank > fuelCapacity) {
cerr << ''You spilled '' << (gasInTank -
fuelCapacity);
cerr << '' gallons of gas on the ground.\n'';
gasInTank = fuelCapacity;
}
}
}
void
Car2::print()
{
cout << ''The car gets '' << milesPerGallon;
cout << ''miles per gallon.\nIt currently has '';
cout << gasInTank << '' gallons of gasoline on board.\n'';
cout << ''Its maximum fuel capacity is '' << fuelCapacity;
cout << ''gallons\nand it has'' << mileage << '' miles.\n'';
}
// The Car3 class implements its uses relationship through a local
// object that is built ''on-the-fly'' at runtime. Whenever the
// get_gasoline() method is called on Car3 objects, the method
// builds itself a gas station, uses the gas station, and then
// destroys it.This is inefficient but is used in some
// implementations,
class Car3 {
private:
double milesPerGallon;
double fuelCapacity;
double gasInTank;
double mileage;
public:
Car3(double, double, double=0.0, double=0.0);
void get_gasoline(double);
void drive(double);
void print();
};
Car3::Car3(doublempg, double capacity, double starting_gas,
double miles)
{
milesPerGallon = mpg;
fuelCapacity = capacity;
gasInTank = starting_gas;
mileage = miles;
}
void
Car3::drive(double miles)
{
double gas_needed;
gas_needed = miles / milesPerGallon;
if (gas_needed > gasInTank) {
mileage += gasInTank * milesPerGallon;
cerr << ''You ran out of gasoline after travelling '';
cerr << gasInTank * milesPerGallon << '' miles.\n'';
gasInTank = 0.0;
}
else {
mileage += miles;
gasInTank -= gas_needed;
if (gasInTank < 0.1 * fuelCapacity) {
cerr << ''Warning: You have only enough gas
to go '';
cerr << gasInTank * milesPerGallon <<
'' miles.\n'';
}
}
}
// Note the creation and use of local_station in order to get
// gasoline for the car. While a bit silly in the domain of cars and
// gas stations, there are domains where the use of a local object
// as part of the implementation of a method is perfectly
// appropriate.
void
Car3::get_gasoline(double money)
{
double gas_received;
GasStationlocal_station(1.25, 1000);
gas_received = local_station.give_gasoline(money);
if (gas_received == 0) {
cerr << ''Sorry the gas station was out of gas.\n'';
}
else {
gasInTank += gas_received;
if (gasInTank > fuelCapacity) {
cerr << ''You spilled '' << (gasInTank -
fuelCapacity);
cerr << '' gallons of gas on the ground.\n'';
gasInTank = fuelCapacity;
}
}
}
void
Car3::print()
{
cout << ''The car gets '' << milesPerGallon;
cout << '' miles per gallon.\nIt currently has '';
cout << gasInTank << '' gallons of gasoline on board.\n'';
cout << ''Its maximum fuel capacity is '' << fuelCapacity;
cout << ''gallons\nand it has'' << mileage << ''miles.\n'';
}
// The Car4 class uses a different twist in implementing its uses
// relationship. When each Car4 object is built, it is told who its
// gas station is. This gas station is stored in the Car4 object for
// later use. In this case, the class will make a copy of the gas
// station, which is safer because it avoids problems of the gas
// station given to the Car4 object being destroyed before the Car4
// object. If data sharing is desired, then only the pointer,
// and not the stuff to which it points, should be copied. For an
// example of this form of shallow copying which also provides a
// safety mechanism, see the Air Traffic Controller example in
// Chapter 9 (Example #3). Do not confuse association with
// containment by reference. While the Car4 class does have a
// pointer to a GasStation as a data member, this is not containment
// by reference, it is association through a referential attribute.
// While C++ does not let us distinguish these two relationships,
// the distinction is available AND important to designers. If this
// were containment, we could ignore GasStations at some high
// level of design. The fact that it is assocation means we cannot.
class Car4 {
private:
double milesPerGallon;
double fuelCapacity;
double gasInTank;
double mileage;
GasStation* myStation;
public:
Car4(GasStation*, double, double, double=0.0, double=0.0);
~Car4();
void get_gasoline(double);
void drive(double);
void print();
};
// Note the constructor copying the GasStation passed to it using
// the default copy constructor for GasStation. (Note: GasStation
// is a fixed-sized class so the default copy constructor does not
// cause any memory leakage/heap corruption problems. See Appendix B
// for a more thorough explanation of memory leakage/heap corruption
// problems of copy constructors/assignment operators.
Car4::Car4(GasStation* station, double mpg, double capacity,
double starting_gas, double miles)
{
myStation = new GasStation(*station);
milesPerGallon = mpg;
fuelCapacity = capacity;
gasInTank = starting_gas;
mileage = miles;
}
Car4::~Car4()
{
delete myStation;
}
void
Car4::drive(double miles)
{
double gas_needed;
gas_needed = miles / milesPerGallon;
if (gas_needed > gasInTank) {
mileage += gasInTank * milesPerGallon;
cerr << ''You ran out of gasoline after travelling '';
cerr << gasInTank * milesPerGallon << '' miles.\n'';
gasInTank = 0.0;
}
else {
mileage += miles;
gasInTank -= gas_needed;
if (gasInTank< 0.1* fuelCapacity) {
cerr << ''Warning: You have only enough gas
to go '';
cerr << gasInTank * milesPerGallon <<
'' miles.\n'';
}
}
}
// Note the use of the referential attribute in the get_gasoline method.
void
Car4::get_gasoline(double money)
{
double gas_received;
gas_received = myStation->give_gasoline(money);
if (gas_received == 0) {
cerr << ''Sorry the gas station was out of gas.\n'';
}
else {
gasInTank += gas_received;
if (gasInTank > fuelCapacity) {
cerr << ''You spilled '' << (gasInTank -
fuelCapacity);
cerr << '' gallons of gas on the ground.\n'';
gasInTank = fuelCapacity;
}
}
}
void
Car4::print()
{
cout << ''The car gets '' << milesPerGallon;
cout << '' miles per gallon.\nIt currently has '';
cout << gasInTank << '' gallons of gasoline on board.\n'';
cout << ''Its maximum fuel capacity is '' << fuelCapacity;
cout << '' gallons\nand it has '' << mileage << '' miles.\n'';
}
// The Car5 class implements its uses relationship by asking a
// third-party class, in this case a Map object. Of course, asking
// a third-party only postpones the answer to the question, ''How
// does a class know the name of the object it wishes to use? ''We
// will have to use one of the other five methods of implementing
// uses. In this case, I chose containment, i.e., Car 5 contains a
// Map object.
// We first implement our Map class. I have chosen a naive algorithm
// for finding a GasStation on a Map. Each Map object has four
// quadrants and a car has an x, y location. The map takes the x-
// and y-coordinates of a car and returns one of four stations.
// While it is true that this is naive (the attentive will notice
// that a Map has no way of getting gasoline deliveries to its
// GasStations), it is sufficient to demonstrate uses.
class Map {
private:
GasStation* quadrant[4];
public:
Map();
~Map();
GasStation* get_station(int, int);
};
// The constructor for Map simply builds the four GasStations , one
// for each quadrant.
Map::Map()
{
quadrant[0] = newGasStation(1.45, 1000);
quadrant[1] = newGasStation(1.30, 200);
quadrant[2] = newGasStation(2.10, 10000);
quadrant[3] = newGasStation(1.10, 678);
}
Map::~Map()
{
int i;
for (i=0; i < 4; i++) {
delete quadrant[i];
}
}
// When a Car5 object asks the Map for a station, it gives the Map its
// x- and y-coordinates. The Map returns the appropriate
// GasStation.
GasStation*
Map::get_station(int x, inty)
{
if (x > 0) {
if (y > 0)
return(quadrant[0]);
else
return(quadrant[3]);
}
else {
if (y > 0)
return(quadrant[1]);
else
return(quadrant[2]);
}
}
// The Car5 class contains the Map by value. Even if it contained it
// by reference, this would still be a containment relationship.
// It would not be association through a referential attribute
// like the Car4 class. The difference is significant at design time.
// I can state that Maps are not as important a class in this domain
// as Car5 and GasStation objects because the former is contained in
// a top-level class and does not have to be discussed at high-level
// design time.
class Car5 {
private:
int loc_x, loc_y;
double milesPerGallon;
double fuelCapacity;
double gasInTank;
double mileage;
Map myMap;
public:
Car5(int, int, double, double, double=0.0, double=0.0);
void get_gasoline(double);
void drive(double);
void print();
};
// The constructor for Map is called automatically before the
// constructor for each Car5 object. The destructor for Map will
// likewise be called whenever a Car5 object is destroyed.
Car5::Car5(int x, int y, double mpg, double capacity,
double starting_gas, double miles)
{
loc_x = x;
loc_y = y;
milesPerGallon = mpg;
fuelCapacity = capacity;
gasInTank = starting_gas;
mileage = miles;
}
void
Car5::drive(double miles)
{
double gas_needed;
gas_needed = miles / milesPerGallon;
if (gas_needed > gasInTank) {
mileage += gasInTank * milesPerGallon;
cerr << ''You ran out of gasoline after travelling '';
cerr << gasInTank * milesPerGallon << '' miles.\n'';
gasInTank = 0.0;
}
else {
mileage += miles;
gasInTank -= gas_needed;
if (gasInTank < 0.1 * fuelCapacity) {
cerr << ''Warning: You have only enough gas
to go '';
cerr << gasInTank * milesPerGallon <<
''miles.\n'';
}
}
}
// Note the use of the contained, third-party object called MyMap to
// get a GasStation for use by the get_gasoline method.
void
Car5::get_gasoline(double money)
{
double gas_received;
GasStation *myStation = myMap.get_station(loc_x, loc_y);
gas_received = myStation->give_gasoline(money);
if (gas_received == 0) {
cerr << ''Sorry the gas station was out of gas.\n'';
}
else {
gasInTank += gas_received;
if (gasInTank>fuelCapacity) {
cerr << ''You spilled '' << (gasInTank -
fuelCapacity);
cerr << '' gallons of gas on the ground.\n'';
gasInTank = fuelCapacity;
}
}
}
void
Car5::print()
{
cout << ''The car at location ('' << loc_x << '', '' << loc_y <<
'') gets '';
cout << milesPerGallon << '' miles per gallon.\nIt currently
has '';
cout << gasInTank << '' gallons of gasoline on board.\n'';
cout << ''Its maximum fuel capacity is '' << fuelCapacity;
cout << '' gallons\nand it has '' << mileage << '' miles.\n''
}
void
main()
{
// The following code tests the Car1 class :
GasStation g1(1.18, 300), g2(1.45, 2300);
Car1 mycar1(22, 18, 10);
mycar1.print();
mycar1.drive(200);
mycar1.print();
mycar1.drive(100);
mycar1.print();
mycar1.get_gasoline(g1, 15.00);
mycar1.print();
// The following code tests the Car2 class :
Car2 mycar2(30, 20, 3);
mycar2.print();
mycar2.drive(200);
mycar2.print();
mycar2.get_gasoline(20.00);
mycar2.print));
mycar2.get_gasoline(10.00);
mycar2.print();
// The following code tests the Car3 class:
Car3 mycar3(9, 13, 5);
mycar3.print();
mycar3.drive(38);
mycar3.print();
mycar3.get_gasoline(10.00);
mycar3.print();
mycar3.drive(150);
mycar3.print();
// The following code tests the Car4 class:
Car4 mycar4(&g2, 18, 25, 12);
mycar4.print();
mycar4.get_gasoline(15.00);
mycar4.print();
mycar4.drive(150);
mycar4.print();
mycar4.get_gasoline(3.69);
mycar4.print();
// The following code tests the Car5 class:
Car5mycar5(10, -34, 35, 18, 15);
myCar5.print();
myCar5.drive(250);
mycar5.print();
myCar5.drive(250);
myCar5.print();
myCar5.get_gasoline(10.00);
myCar5.print();
myCar5.get_gasoline(20.00);
mycar5.print();
}
|
