Project 3

AIM:

Build an object-oriented library which can be used to track automobile maintenance. There can be different car types such as petrol, diesel, gas, electric etc., This library should be able to support at least three of the car types. 

Maintenance tasks include activities like oil change or replace oil filter, replace air filter, replace fuel filter, tire rotations, infotainment system debug, replace spark plugs, replace the cabin or a/c filter, check the level and refill clutch fluid or brake fluid, examine belts, wipers, hoses, check the tire conditions, check the charging systems and battery.

code:

#include
#include
#include

using namespace std;

// Enum for fuel types
enum class FuelType { GAS, DIESEL, ELECTRIC };

// Vehicle class
class Vehicle {
protected:
string make;
string model;
int year;
int odometer;

public:
Vehicle(string make, string model, int year, int odometer)
: make(make), model(model), year(year), odometer(odometer) {}

string getMake() const { return make; }
void setMake(string make) { this->make = make; }

string getModel() const { return model; }
void setModel(string model) { this->model = model; }

int getYear() const { return year; }
void setYear(int year) { this->year = year; }

int getOdometer() const { return odometer; }
void setOdometer(int odometer) { this->odometer = odometer; }

virtual FuelType getFuelType() const = 0;

void checkTireRotation() const {
int tireCycle = 50000; // Tire cycle in kilometers
int distanceRun = odometer % tireCycle;
if (distanceRun >= 0 && distanceRun <= 5000)
cout << "Rotate tires." << endl;
else
cout << "Tires are good to go." << endl;
}

void getCarInformation() const {
cout << "Make: " << make << endl;
cout << "Model: " << model << endl;
cout << "Year: " << year << endl;
cout << "Odometer: " << odometer << endl;
cout << "Fuel type: " << static_cast(getFuelType()) << endl;
}
};

// GasCar class
class GasCar : public Vehicle {
public:
GasCar(string make, string model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}

FuelType getFuelType() const override { return FuelType::GAS; }

void checkChargerPower() const {
// Gas cars don't need to recharge power
cout << "Gas car doesn't need to recharge power." << endl;
}
};

// DieselCar class
class DieselCar : public Vehicle {
public:
DieselCar(string make, string model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}

FuelType getFuelType() const override { return FuelType::DIESEL; }

void checkChargerPower() const {
// Diesel cars don't need to recharge power
cout << "Diesel car doesn't need to recharge power." << endl;
}
};

// ElectricCar class
class ElectricCar : public Vehicle {
public:
ElectricCar(string make, string model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}

FuelType getFuelType() const override { return FuelType::ELECTRIC; }

void checkChargerPower() const {
int powerCycle = 400; // Power cycle in kilometers
int distanceRun = odometer % powerCycle;
if (distanceRun == 0)
cout << "Recharge power." << endl;
else
cout << "Vehicle is good to go." << endl;
}
};

// Inventory class
class Inventory {
private:
vector<Vehicle*> vehicles;

public:
// Destructor
~Inventory() {
for (auto vehicle : vehicles)
delete vehicle;
}

// Add a vehicle to the inventory
void addVehicle(Vehicle* vehicle) {
vehicles.push_back(vehicle);
}

// Remove a vehicle from the inventory
void removeVehicle(int index) {
delete vehicles[index];
vehicles.erase(vehicles.begin() + index);
}

// Get the total number of vehicles in the inventory
int getTotalVehicles() const {
return vehicles.size();
}

// Display the information for all vehicles in the inventory
void displayInventory() const {
for (int i = 0; i < vehicles.size(); i++) {
cout << "Vehicle " << i + 1 << ":" << endl;
vehicles[i]->getCarInformation();
vehicles[i]->checkTireRotation();
//vehicles[i]->checkChargerPower(); // This method will only be called for ElectricCar objects
cout << endl;
}
}
};

int main() {
vector<Vehicle*> vehicles;
int choice = 0;

do {
cout << "Add a vehicle:n";
cout << "1. Gas carn";
cout << "2. Diesel carn";
cout << "3. Electric carn";
cout << "4. Exitn";
cout << "Enter your choice: ";
cin >> choice;

if (choice == 1) {
string make, model;
int year, odometer;
cout << "Enter make: ";
cin >> make;
cout << "Enter model: ";
cin >> model;
cout << "Enter year: ";
cin >> year;
cout << "Enter odometer: ";
cin >> odometer;

GasCar* car = new GasCar(make, model, year, odometer);
vehicles.push_back(car);
}
else if (choice == 2) {
string make, model;
int year, odometer;
cout << "Enter make: ";
cin >> make;
cout << "Enter model: ";
cin >> model;
cout << "Enter year: ";
cin >> year;
cout << "Enter odometer: ";
cin >> odometer;

DieselCar* car = new DieselCar(make, model, year, odometer);
vehicles.push_back(car);
}
else if (choice == 3) {
string make, model;
int year, odometer;
cout << "Enter make: ";
cin >> make;
cout << "Enter model: ";
cin >> model;
cout << "Enter year: ";
cin >> year;
cout << "Enter odometer: ";
cin >> odometer;

ElectricCar* car = new ElectricCar(make, model, year, odometer);
vehicles.push_back(car);
}
else if (choice == 4) {
break;
}
else {
cout << "Invalid choice. Try again.n";
}
} while (choice != 4);

// Print information and perform maintenance checks for all vehicles
for (Vehicle* vehicle : vehicles) {
vehicle->getCarInformation();
vehicle->checkTireRotation();
vehicle->checkOilChange();
vehicle->checkChargerPower();
cout << endl;
}

// Free the memory allocated for the vehicles
for (Vehicle* vehicle : vehicles) {
delete vehicle;
}

return 0;
}

FOR CREATING LIBRARY:

Vehicle.h

#ifndef VEHICLE_H
#define VEHICLE_H

enum Type {
GAS,
DIESEL,
ELECTRIC
};

class Vehicle {
protected:
std::string make_;
std::string model_;
int year_;
int odometer_;
public:
Vehicle(std::string make, std::string model, int year, int odometer);
std::string getMake() const;
std::string getModel() const;
int getYear() const;
int getOdometer() const;
void setMake(std::string make);
void setModel(std::string model);
void setYear(int year);
void setOdometer(int odometer);
virtual Type getType() = 0;
virtual void checkTireRotation() = 0;
virtual void checkChargerPower() = 0;
virtual void getCarInformation() = 0;
};

#endif

vehicle.cpp

#include "Vehicle.h"

Vehicle::Vehicle(std::string make, std::string model, int year, int odometer)
: make_(make), model_(model), year_(year), odometer_(odometer) {}

std::string Vehicle::getMake() const {
return make_;
}

std::string Vehicle::getModel() const {
return model_;
}

int Vehicle::getYear() const {
return year_;
}

int Vehicle::getOdometer() const {
return odometer_;
}

void Vehicle::setMake(std::string make) {
make_ = make;
}

void Vehicle::setModel(std::string model) {
model_ = model;
}

void Vehicle::setYear(int year) {
year_ = year;
}

void Vehicle::setOdometer(int odometer) {
odometer_ = odometer;
}

GasCar.h

#ifndef GASCAR_H
#define GASCAR_H

#include "Vehicle.h"

class GasCar : public Vehicle {
public:
GasCar(std::string make, std::string model, int year, int odometer);
Type getType() override;
void checkTireRotation() override;
void checkChargerPower() override;
void getCarInformation() override;
std::string getFuelType();
};

#endif

GasCar.cpp

#include "GasCar.h"

GasCar::GasCar(std::string make, std::string model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}

Type GasCar::getType() {
return GAS;
}

void GasCar::checkTireRotation() {
int distance = odometer_ % 50000;
if (distance >= 0) {
std::cout << "Rotate tires" << std::endl;
}
else {
std::cout << "Tires are good to go" << std::endl;
}
}

void GasCar::checkChargerPower() {
// Not applicable for GasCar
}

void GasCar::getCarInformation() {
std::cout << "Make: " << make_ << std::endl;
std::cout << "Model: " << model_ << std::endl;
std::cout << "Year: " << year_ << std::endl;
std::cout << "Odometer Reading: " << odometer_ << std::endl;
std::cout << "Fuel Type: " << getFuelType() << std::endl;
}

std::string GasCar::getFuelType() {
return "Gas";
}

class DieselCar : public Vehicle {
public:
DieselCar(std::string make, std::string model, int year, int odometer) :
Vehicle(make, model, year, odometer) {}

Type getType() {
return DIESEL;
}

std::string getFuelType() {
return "diesel";
}
};

ALTERNATE CODE:

#include
#include

enum class FuelType {
GAS,
DIESEL,
ELECTRIC,
HYBRID
};

class Vehicle {
protected:
std::string make_;
std::string model_;
int year_;
int odometer_;

public:
Vehicle(const std::string& make, const std::string& model, int year, int odometer)
: make_(make), model_(model), year_(year), odometer_(odometer) {}

const std::string& getMake() const { return make_; }
const std::string& getModel() const { return model_; }
int getYear() const { return year_; }
int getOdometer() const { return odometer_; }

void setMake(const std::string& make) { make_ = make; }
void setModel(const std::string& model) { model_ = model; }
void setYear(int year) { year_ = year; }
void setOdometer(int odometer) { odometer_ = odometer; }

virtual FuelType getFuelType() const = 0;

virtual void checkTireRotation() const {}
virtual void checkPower() const {}

virtual void printDetails() const {
std::cout << "Make: " << make_ << "n";
std::cout << "Model: " << model_ << "n";
std::cout << "Year: " << year_ << "n";
std::cout << "Odometer: " << odometer_ << "n";
}
};

class GasCar : public Vehicle {
public:
GasCar(const std::string& make, const std::string& model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}

FuelType getFuelType() const override { return FuelType::GAS; }
};

class DieselCar : public Vehicle {
public:
DieselCar(const std::string& make, const std::string& model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}

FuelType getFuelType() const override { return FuelType::DIESEL; }
};

class ElectricCar : public Vehicle {
public:
ElectricCar(const std::string& make, const std::string& model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}

FuelType getFuelType() const override { return FuelType::ELECTRIC; }

void checkTireRotation() const override {
int tire_cycle = 50000;
int distance_run = odometer_ % tire_cycle;
if (distance_run >= 0) {
std::cout << "Tire rotation advisedn";
}
else {
std::cout << "Tire rotation not requiredn";
}
}

void checkPower() const override {
int recharge_distance = 400;
int distance_run = odometer_ % recharge_distance;
if (distance_run == 0) {
std::cout << "Battery recharge advisedn";
}
else {
std::cout << "Battery recharge not requiredn";
}
}
};

class Inventory {
private:
std::vector<Vehicle*> vehicles_;

public:
~Inventory() {
for (auto vehicle : vehicles_) {
for (auto vehicle : vehicles_) {
delete vehicle;
}
vehicles_.clear();
}

void addVehicle(Vehicle* vehicle) {
vehicles_.push_back(vehicle);
}

void updateVehicle(int index, Vehicle* vehicle) {
delete vehicles_[index];
vehicles_[index] = vehicle;
}

void removeVehicle(int index) {
delete vehicles_[index];
vehicles_.erase(vehicles_.begin() + index);
}

void listVehicles() const {
for (int i = 0; i < vehicles_.size(); i++) {
std::cout << "[" << i << "] " << vehicles_[i]->getMake() << " " << vehicles_[i]->getModel() << " "
<< vehicles_[i]->getYear() << " " << vehicles_[i]->getOdometer() << " " << std::endl;
}
}

void tireRotation(int index) {
Vehicle* vehicle = vehicles_[index];
int odometer = vehicle->getOdometer();
int remainder = odometer % 50000;
if (odometer >= 50000 && remainder >= 0) {
std::cout << "Time for a tire rotation on this vehicle." << std::endl;
}
else {
std::cout << "Tire rotation is not needed at this time." << std::endl;
}
}

void oilChange(int index) {
Vehicle* vehicle = vehicles_[index];
int odometer = vehicle->getOdometer();
if (odometer >= 5000) {
std::cout << "Time for an oil change on this vehicle." << std::endl;
}
else {
std::cout << "Oil change is not needed at this time." << std::endl;
}
}

void recharge(int index) {
ElectricCar* electricCar = dynamic_cast<ElectricCar*>(vehicles_[index]);
if (electricCar != nullptr) {
int odometer = electricCar->getOdometer();
if (odometer >= 400) {
std::cout << "Time to recharge the battery on this vehicle." << std::endl;
}
else {
std::cout << "Battery recharge is not needed at this time." << std::endl;
}
}
else {
std::cout << "This is not an electric vehicle." << std::endl;
}
}
};

int main()
{
Inventory inventory;
while (true) {
std::cout << "nSelect an option:n"
<< " 0. Quit.n"
<< " 1. List inventory.n"
<< " 2. Add vehicle.n"
<< " 3. Update vehicle.n"
<< " 4. Remove vehicle.n"
<< " 5. Tire rotation.n"
<< " 6. Oil change.n"
<< " 7. Recharge.n";

int option;
std::cin >> option;

if (option == 0) {
break;
}

switch (option) {
case 1:
inventory.listVehicles();
break;
case 2:
std::cout << "Enter the make: ";
std::string make;
std::getline(std::cin >> std::ws, make);
if (make.empty()) {
std::cout << "Invalid input. Please enter the make again." << std::endl;
break;
}

std::cout << "Enter the model: ";
std::string model;
std::getline(std::cin, model);
while (model.empty())
{
std::cout << "Model can't be blank, please enter again: ";
std::getline(std::cin, model);
}
std::cout << "Enter the model: ";
std::string model;
std::getline(std::cin, model);
while (model.empty())
{
std::cout << "Model can't be blank, please enter again: ";
std::getline(std::cin, model);
}

// get the year
std::cout << "Enter the year: ";
int year;
std::cin >> year;
while (std::cin.fail())
{
std::cout << "Invalid input. Please enter the year again: ";
std::cin.clear();
std::cin.ignore(std::numeric_limits::max(), 'n');
std::cin >> year;
}

// get the mileage
std::cout << "Enter the mileage: ";
double mileage;
std::cin >> mileage;
while (std::cin.fail())
{
std::cout << "Invalid input. Please enter the mileage again: ";
std::cin.clear();
std::cin.ignore(std::numeric_limits::max(), 'n');
std::cin >> mileage;
}

// create the vehicle
std::unique_ptr vehicle = std::make_unique(make, model, year, mileage);

// add the vehicle to the inventory
inventory.addVehicle(std::move(vehicle));
std::cout << "Vehicle added to inventory." << std::endl;
break;

case 3:
inventory.updateVehicle();
break;

case 4:
inventory.removeVehicle();
break;

case 5:
inventory.rotateTires();
break;

case 6:
inventory.changeOil();
break;

case 7:
inventory.recharge();
break;

default:
std::cout << "Invalid input. Please select a valid option." << std::endl;
break;
}

}

return 0;
}

Explaination of code:

It defines a base class Vehicle and derived classes GasCar, DieselCar, and ElectricCar. The Vehicle class has some member variables such as make_, model_, year_, and odometer_, and some member functions such as getMake(), getModel(), getYear(), getOdometer(), and printDetails(). The GasCar, DieselCar, and ElectricCar classes are derived from the Vehicle class and have their own implementations of the getFuelType() member function. The program also defines a class Inventory that contains a vector of pointers to Vehicle objects. It has member functions such as addVehicle(), updateVehicle(), removeVehicle(), listVehicles(), tireRotation(), oilChange(), and recharge(), which are used to perform various operations on the Vehicle objects in the inventory. The tireRotation(), oilChange(), and recharge() member functions are specific to the derived ElectricCar class, and use dynamic casting to check whether the pointer to the Vehicle object is actually pointing to an ElectricCar object. There is also a destructor for the Inventory class, which deletes all the dynamically allocated Vehicle objects when the Inventory object is destroyed.