#include iostream #include string #include fstream std

1. #include <iostream>
#include <string>
#include <fstream> // std::ifstream
#include <iomanip>
using namespace std;
/* ********* Class Car *************
********************************* */
class Car
{
private:
string reportingMark;
int carNumber;
string kind;
bool loaded;
string destination;
public:
Car()
{
reportingMark = "";
carNumber = 0;
kind = "Others";
loaded = 0;
destination = "NONE";
}
//copy constructor
Car(Car &car)
{
reportingMark = car.reportingMark;
carNumber = car.carNumber;
kind = car.kind;
loaded = car.loaded;
destination = car.destination;
}
~Car()
{

2. }
/* ************* Function output ************
show all results of the program
******************************************* */
void output()
{
string strLoaded;
if (loaded==true)
{
strLoaded = "TRUE";
}
else
{
strLoaded = "FALSE";
}
cout << fixed << left << setw(18) << "Reporting Mark" <<
reportingMark << endl;
cout << fixed << left << setw(18) << "Car Number" <<
carNumber << endl;
cout << fixed << left << setw(18) << "Kind" << kind << endl;
cout << fixed << left << setw(18) << "Loaded" << strLoaded
<< endl;
cout << fixed << left << setw(18) << "Destination" <<
destination << endl;
cout << endl;
}
void setUp(string &r, int &c , string &k, bool &l, string &d)
{
reportingMark =r;
carNumber = c;
kind = k;
loaded = l;
destination = d;
}

3. friend bool operator== (const Car &c1, const Car &c2);
};
bool operator== (const Car &c1, const Car &c2)
{
return (c1.reportingMark== c2.reportingMark &&
c1.carNumber == c2.carNumber );
}
void input();
//*********** Main **************
int main()
{
string reportingMark;
int carNumber;
string kind;
bool loaded;
string destination;
input ();
Car car1;
car1.setUp(reportingMark,carNumber, kind, loaded,
destination);
cout<<"Contents of car1:"<<endl;
car1.output();
//copy constructor
Car car2=car1;
//call output funciton
cout<<"Contents of car1:"<<endl;
car2.output();
//default constructor
Car car3;
cout<<"Contents of car1:"<<endl;
//call output funciton
car3.output();
if (car1 == car2)
cout<< "car1 is the same car as car2 ";
else
cout<< "car1 is not the same car as car2 ";

4. if (car2 == car3)
cout<< "car2 is the same car as car3 ";
else
cout<< "car2 is not the same car as car3 ";
return 0;
}
/* ************ Function Input **************
Collect the data
****************************************** */
void input()
{
string type;
string reportingMark;
int carNumber;
string kind;
bool loaded;
string destination;
std::ifstream inputFile ("input.txt");
if (inputFile.is_open())
{
while(inputFile.peek() != EOF)
{
inputFile >> type >> reportingMark >> carNumber >> kind >>
loaded >> destination;
Car temp(string reportingMar k, int carNumber, string kind,
bool loaded);
}
}
else
{
// show message:
std::cout << "Error opening file";
return ;

5. }
inputFile.close();
/*
int len;
string choice;
cout<< "Enter reportingMark with 5 or less upper case
characters: ";
getline(cin, reportingMark);
len= reportingMark.length();
while (len > 5)
{
cout<< "invalid! Enter reportingMark with 5 or less upper case
characters: ";
getline(cin, reportingMark);
len= reportingMark.length();
}
cout<< "Enter Car Number: ";
cin>> carNumber;
cout << "Enter kind of car: ";
cin>> kind;
do
{
cout<<"Enter the loaded only true or false:";
cin>>choice;
if (choice == "true")
{
loaded = true;
}
else if (choice == "false")
{
loaded = false;
}
else
{
cout<<"error!"<<endl;

6. }
}
while (choice != "true" && choice != "false");
if(loaded==true)
{
cout<<"Entre the destination: ";
cin.ignore();
getline(cin,destination);
}
if(loaded ==false)
{
destination = "NONE";
}
Car temp(string reportingMark, int carNumber, string kind, bool
loaded);
*/
}
problem 4.2
Copy the following operator= overload member function that
returns the
left hand operator by reference:
// Car operator=
**************************************************
Car & Car::operator=(const Car & carB)
{
reportingMark = carB.reportingMark;
carNumber = carB.carNumber;
kind = carB.kind;
loaded = carB.loaded;
destination = carB.destination;
return * this;
}
Several cars coupled together are referred to as a string of cars.
Create another class called StringOfCars, containing:
* a pointer to an array of Car objects in the heap.
* a static const int ARRAY_MAX_SIZE set to 10.

7. * an int size containing the current number of Cars in the array.
* a default constructor which gets space for the array in the
heap,
and sets the the size to zero.
* a copy constructor which gets new space in the heap for the
array
and copies all the Car objects.
* a destructor which returns the space to the heap.
* a push function which adds a car to the string of cars.
* a pop function which removes a car from the string of cars,
Last In
First Out (LIFO).
* an output function which prints a heading for each car:
car number n where n is the position in the array starting
from 1
for the first car and then uses the Car output function to print
the
data for each car Or, if the array is empty prints: NO cars
Order of functions in the code:
1. main
2. Car member functions
1. Car constructors in the order
1. default constructor
2. copy constructor
3. other constructors
2. output
3. setUp
4. operator=
3. StringOfCars member functions
1. Car constructors in the order
1. default constructor
2. copy constructor
2. destructor
3. output
4. push
5. pop

8. 4. operator== friend of Car
5. input
Put an eye catcher before the beginning of each function, class,
and the
global area:
// class name function name comment(if any)
*************************************************
Modify the main function to do the following tests:
1. Test the Car operator= function.
Before the call to the input function:
Print: TEST 1
Creat a Car object named car1 with initial values:
reportingMark: SP
carNumber: 34567
kind: box
loaded: true
destination: Salt Lake City
Create a Car object named car2 which is a copy of car1
Print car2
2. Test the StringOfCar push function.
Change the input function to have a parameter that is a
reference to
a StringOfCars.
Add to main:
Create a default StringOfCars object named string1.
Print: TEST 2
Pass string1 to the input function.
Use the same file as in problem D1.
In the input function, just after creating the car, push it on to
string1.
Remove the print of the car in the input function.
Print: STRING 1
In the main function, after using the input function, print
string1.
3. Test the StringOfCars pop function.
Add to main:

9. Print: TEST 3
Create a car named car3.
Pop one car from string1 into car3.
Print: CAR 3
Print car3.
Print: STRING 1
Then print the contents of string1 again
Solution
#include <iostream>
#include <cstring>
#include <stdlib.h>
#include <string>
#include <cstring>
#include <stdbool.h>
#include <fstream>
#include <iomanip>
using namespace std;
enum Kind {business, maintenance, other, box, tank, flat,
otherFreight, chair, sleeper, otherPassenger};
class Car

10. {
protected:
//all private variables
string reportingMark;
int carNumber;
Kind kind;
string kindInit;
bool loaded;
string destination;
public:
//default constructor
Car()
{
setUp("",0,"other",false,"NONE");
}
//copy constructor
Car(const Car &obj)
{
setUp(obj.reportingMark,obj.carNumber,obj.kindInit,obj.loaded,
obj.destination);
}
//third constructor
Car(const string reportingMarkX, const int carNumberX,

11. const string kindX, const bool loadedX, const string
destinationX)
{
setUp(reportingMarkX, carNumberX, kindX, loadedX,
destinationX);
}
//deconstructor
~Car()
{
}
/* **********setUp*********
* takes in string, int, string, bool, and string
* sets teh private values accoridng to the data input
*
*/
void setUp(string reportingMarkOut, int carNumberOut,
string kindInit, bool loadedOut, string destinationOut);
/* **********output**********
* simply outputs the variables in a formatted fashion
*
*/
void output();

12. virtual void setKind(const string &kindS);
/* **********operator=**********
* overloads the = operator for car objects
*
*/
Car& operator=(const Car & carB);
//friend function
friend bool operator==(const Car&, const Car&);
};
class cs112 : public Car
{
public:
cs112()
{
setUp("",0,"other",false,"NONE");
}
//copy constructor

13. cs112(const cs112 &obj)
{
setUp(obj.reportingMark,obj.carNumber,obj.kindInit,obj.loaded,
obj.destination);
}
cs112(const string reportingMarkX, const int carNumberX,
const string kindX, const bool loadedX, const string
destinationX)
{
setUp(reportingMarkX, carNumberX, kindX, loadedX,
destinationX);
}
void setKind(const string &kindS);
};
class PassinjirKarr : public Car
{
public:
PassinjirKarr()
{

14. setUp("",0,"other",false,"NONE");
}
//copy constructor
PassinjirKarr(const PassinjirKarr &obj)
{
setUp(obj.reportingMark,obj.carNumber,obj.kindInit,obj.loaded,
obj.destination);
}
PassinjirKarr(const string reportingMar kX, const int
carNumberX, const string kindX, const bool loadedX, const
string destinationX)
{
setUp(reportingMarkX, carNumberX, kindX, loadedX,
destinationX);
}
void setKind(const string &kindS);
};
class StringOfCars
{
private:
const static int ARRAY_MAX_SIZE = 10;

15. int size;
Car *AOCPointer[ARRAY_MAX_SIZE];
public:
//default constructor
StringOfCars()
{
size = 0;
for(int i = 0; i < ARRAY_MAX_SIZE; i++)
{
//AOCPointer[i] = new Car[ARRAY_MAX_SIZE];
Car *myPointer = new Car;
AOCPointer[i] = myPointer;
}
}
//copy constructor
StringOfCars(const StringOfCars &thing)
{

16. int counter = thing.size;
Car *myPointer = new Car;
for(counter = 0; counter >= (thing.size - 1); counter++)
{
AOCPointer[counter] = new
Car[ARRAY_MAX_SIZE];
push(*thing.AOCPointer[counter]);
}
}
//destructor
~StringOfCars()
{
for(int i = 0; i < size; i++)
{
delete AOCPointer[i];
}
}

17. void push(const Car &carA);
void pop(Car *carx);
void output();
};
//empty constructors
void input(StringOfCars *myCar);
void buildCar(string reportingMarkOut, int carNumberOut,
string kindOut, bool loadedOut, string destinationOut);
void buildcs112(string reportingMarkOut, int carNumberOut,
string kindOut, bool loadedOut, string destinationOut);
void buildPassinjirKarr(string reportingMarkOut, int
carNumberOut, string kindOut, bool loadedOut, string
destinationOut);
const string KIND_ARRAY[10] = {"business",
"maintenance", "other", "box", "tank", "flat",
"otherFreight", "chair", "sleeper", "otherPassenger"};
//bool isEqual(const Car carA, const Car carB);
/* ****************main******************
*
*/
int main()
{
StringOfCars string1;
input(&string1);
return 0;

18. }
void input(StringOfCars *myCar)
{
ifstream inputFile;
string type;
string order;
string reportingMark;
string carNumberX;
int carNumber;
string kind;
//Kind kind;
string loadedX;
bool loaded;
string destination = "problem";
inputFile.open("inputE.txt");
if(inputFile.fail())
{
fprintf(stderr, "Error in reading file ");
exit(0);
}
while(inputFile.peek() != EOF)
{

19. string templine;
inputFile >> type;
inputFile >> order;
cout << order << endl;
inputFile >> reportingMark;
inputFile >> carNumber;
inputFile >> kind;
inputFile >> loadedX;
if(loadedX == "true")
{
loaded = 1;
}
else
{
loaded = 0;
}
while(inputFile.peek() == ' ')
inputFile.get();
getline(inputFile,destination);
if(type == "Car")

20. {
buildCar(reportingMark, carNumber, kind, loaded,
destination);
}
else if(type == "FreightCar")
{
buildcs112(reportingMark, carNumber, kind, loaded,
destination);
}
else if(type == "PassengerCar")
{
buildPassinjirKarr(reportingMark, carNumber, kind,
loaded, destination);
}
}
inputFile.close();
}
//***************************************************
*********************
void StringOfCars::push(const Car &carA)
{
Car *point = new Car(carA);

21. AOCPointer[size] = point;
size++;
}
void StringOfCars::pop(Car *carx)
{
size--;
Car newCar(*AOCPointer[size]);
*carx = newCar;
}
void StringOfCars::output()
{
int printCheck;
for(printCheck = 0; printCheck < size; printCheck++)
{
cout << "This is car number " << (printCheck+1) <<
endl;
AOCPointer[printCheck]->output();
}
}
//declaired as part of the Car function - see above
void Car::setUp(string reportingMarkOut, int carNumberOut,

22. string kindOut, bool loadedOut, string destinationOut)
{
reportingMark = reportingMarkOut;
carNumber = carNumberOut;
setKind(kindOut);
loaded = loadedOut;
destination = destinationOut;
}
//declaired as part of the Car function - see above
void Car::output()
{
cout << "The Reporting Mark is: " << reportingMark <<
endl;
cout << "The Car Number is: " << carNumber << endl;
cout << "The Kind is: " << KIND_ARRAY[kind] <<
endl;
cout << "The Loaded status is: ";
if(loaded == true)
{
cout << "true" << endl;
}
else
{
cout << "false" << endl;
}

23. cout << "The destination is: " << destination << endl <<
endl;
}
void Car::setKind(const string &kindS)
{
if(kindS == "business")
{
kind = business;
}
else if(kindS == "maintenance")
{
kind = maintenance;
}
else
{
kind = other;
}
}
void cs112::setKind(const string &kindS)
{
if(kindS == "box")
{
kind = box;
}

24. else if(kindS == "tank")
{
kind = tank;
}
else if(kindS == "flat")
{
kind = flat;
}
else
{
kind = otherFreight;
}
}
void PassinjirKarr::setKind(const string &kindS)
{
if(kindS == "chair")
{
kind = chair;
}
else if(kindS == "sleeper")
{
kind = sleeper;
}
else

25. {
kind = otherPassenger;
}
}
/* **********operator==**********
*
* friend function of Car which overloads == to check if two
cars are equal only using their reportingMark and their
carNumber
*
*/
bool operator==(const Car &a, const Car &b)
{
if((a.reportingMark == b.reportingMark) && (a.carNumber
== b.carNumber))
{
return true;
}
else
{
return false;
}
}
/* ********** Car operator= **********

26. */
Car & Car::operator=(const Car & carB)
{
setUp(carB.reportingMark, carB.carNumber, carB.kindInit,
carB.loaded, carB.destination);
return * this;
}
void buildCar(string reportingMarkOut, int carNumberOut,
string kindOut, bool loadedOut, string destinationOut)
{
Car CarThing(reportingMarkOut,carNumberOut, kindOut,
loadedOut,destinationOut);
CarThing.output();
}
void buildPassinjirKarr(string reportingMarkOut, int
carNumberOut, string kindOut, bool loadedOut, string
destinationOut)
{
PassinjirKarr
passengerCarThing(reportingMarkOut,carNumberOut, kindOut,
loadedOut,destinationOut);

27. passengerCarThing.output();
}
void buildcs112(string reportingMarkOut, int carNumberOut,
string kindOut, bool loadedOut, string destinationOut)
{
cs112 FreightCarThing(reportingMarkOut,carNumberOut,
kindOut, loadedOut,destinationOut);
FreightCarThing.output();
}
inputE.txt
Car car1 CN 819481 maintenance false NONE
Car car2 SLSF 46871 business true Memphis
Car car3 AOK 156 tender true McAlester
FreightCar car4 MKT 123456 tank false Fort Worth
FreightCar car5 MP 98765 box true Saint Louis
FreightCar car6 SP 567890 flat true Chicago
FreightCar car7 GMO 7878 hopper true Mobile
PassengerCar car8 KCS 7893 chair true Kansas City
PassengerCar car9 PAPX 145 sleeper true Tucson
PassengerCar car10 GN 744 combine false NONE