Project 3

'Vehicle.h' Header File:

#ifndef VEHICLE_H

#define VEHICLE_H

#include

enum class FuelType {

GAS,

DIESEL,

ELECTRIC

};

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);

std::string getMake() const;

void setMake(const std::string& _make);

std::string getModel() const;

void setModel(const std::string& _model);

int getYear() const;

void setYear(int _year);

int getOdometer() const;

void setOdometer(int _odometer);

void getCarInformation() const;

virtual void checkTireRotation() const = 0;

};

#endif // VEHICLE_H

Vehicle.cpp Implementation File:

#include "Vehicle.h"

#include

Vehicle::Vehicle(const std::string& _make, const std::string& _model, int _year, int _odometer)

: make(_make), model(_model), year(_year), odometer(_odometer) {}

std::string Vehicle::getMake() const {

return make;

}

void Vehicle::setMake(const std::string& _make) {

make = _make;

}

std::string Vehicle::getModel() const {

return model;

}

void Vehicle::setModel(const std::string& _model) {

model = _model;

}

int Vehicle::getYear() const {

return year;

}

void Vehicle::setYear(int _year) {

year = _year;

}

int Vehicle::getOdometer() const {

return odometer;

}

void Vehicle::setOdometer(int _odometer) {

odometer = _odometer;

}

void Vehicle::getCarInformation() const {

std::cout << "Make: " << make << ", Model: " << model << ", Year: " << year

<< ", Odometer: " << odometer << " miles" << std::endl;

}

FuelVehicle.h Header File:

#ifndef FUELVEHICLE_H

#define FUELVEHICLE_H

#include "Vehicle.h"

class FuelVehicle : public Vehicle {

public:

FuelVehicle(const std::string& _make, const std::string& _model, int _year, int _odometer);

virtual FuelType getFuelType() const = 0;

void checkOil() const;

};

#endif // FUELVEHICLE_H

FuelVehicle.cpp Implementation File:

#include "FuelVehicle.h"

#include

FuelVehicle::FuelVehicle(const std::string& _make, const std::string& _model, int _year, int _odometer)

: Vehicle(_make, _model, _year, _odometer) {}

void FuelVehicle::checkOil() const {

std::cout << "Checking oil for " << make << " " << model << std::endl;

// Implementation specific to each derived class

}

GasCar.h Header File:

#ifndef GASCAR_H

#define GASCAR_H

#include "FuelVehicle.h"

class GasCar : public FuelVehicle {

public:

GasCar(const std::string& _make, const std::string& _model, int _year, int _odometer);

FuelType getFuelType() const override;

};

#endif // GASCAR_H

GasCar.cpp Implementation File:

#include "GasCar.h"

GasCar::GasCar(const std::string& _make, const std::string& _model, int _year, int _odometer)

: FuelVehicle(_make, _model, _year, _odometer) {}

FuelType GasCar::getFuelType() const {

return FuelType::GAS;

}

DieselCar.h Header File:

#ifndef DIESELCAR_H

#define DIESELCAR_H

#include "FuelVehicle.h"

class DieselCar : public FuelVehicle {

public:

DieselCar(const std::string& _make, const std::string& _model, int _year, int _odometer);

FuelType getFuelType() const override;

};

#endif // DIESELCAR_H

DieselCar.cpp Implementation File:

#include "DieselCar.h"

DieselCar::DieselCar(const std::string& _make, const std::string& _model, int _year, int _odometer)

: FuelVehicle(_make, _model, _year, _odometer) {}

FuelType DieselCar::getFuelType() const {

return FuelType::DIESEL;

}

ElectricCar.h Header File:

#ifndef ELECTRICCAR_H

#define ELECTRICCAR_H

#include "FuelVehicle.h"

class ElectricCar : public FuelVehicle {

public:

ElectricCar(const std::string& _make, const std::string& _model, int _year, int _odometer);

FuelType getFuelType() const override;

void checkTireRotation() const override;

void checkChargerPower() const;

};

#endif // ELECTRICCAR_H

ElectricCar.cpp Implementation File:

#include "ElectricCar.h"

#include

ElectricCar::ElectricCar(const std::string& _make, const std::string& _model, int _year, int _odometer)

: FuelVehicle(_make, _model, _year, _odometer) {}

FuelType ElectricCar::getFuelType() const {

return FuelType::ELECTRIC;

}

void ElectricCar::checkTireRotation() const {

if (odometer % 50000 == 0) {

std::cout << "Time to rotate tires for " << make << " " << model << std::endl;

} else {

std::cout << "Tire rotation not needed yet for " << make << " " << model << std::endl;

}

}

void ElectricCar::checkChargerPower() const {

if (odometer % 400 == 0) {

std::cout << "Check charger power for " << make << " " << model << std::endl;

} else {

std::cout << "Charger power is good for " << make << " " << model << std::endl;

}

}

main.cpp Implementation File:

#include "GasCar.h"

#include "DieselCar.h"

#include "ElectricCar.h"

#include

#include

#include // for numeric_limits

#include // for system("pause") in Windows

// Function prototypes

void addVehicle(std::vector& inventory);

void listVehicles(const std::vector& inventory);

void updateVehicle(std::vector& inventory);

void removeVehicle(std::vector& inventory);

void tireRotation(const std::vector& inventory);

void oilChange(const std::vector& inventory);

void recharge(const std::vector& inventory);

int getUserInput(int min, int max);

std::string getStringInput();

int getIntInput();

FuelType getFuelTypeInput();

int main() {

std::vector inventory;

int choice = -1;

while (choice != 0) {

std::cout << "\nMenu:\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"

<< "Enter your choice (0-7): ";

choice = getUserInput(0, 7);

switch (choice) {

case 0:

std::cout << "Exiting program...\n";

break;

case 1:

listVehicles(inventory);

break;

case 2:

addVehicle(inventory);

break;

case 3:

updateVehicle(inventory);

break;

case 4:

removeVehicle(inventory);

break;

case 5:

tireRotation(inventory);

break;

case 6:

oilChange(inventory);

break;

case 7:

recharge(inventory);

break;

default:

std::cout << "Invalid choice. Please enter a number between 0 and 7.\n";

break;

}

// Pause to view output in console before clearing screen and displaying menu again

std::cout << "\nPress Enter to continue...";

std::cin.ignore(std::numeric_limits::max(), '\n');

std::cin.get(); // Pause for user to press Enter

system("clear"); // Change to "cls" if on Windows

}

// Clean up memory

for (auto vehicle : inventory) {

delete vehicle;

}

return 0;

}

void addVehicle(std::vector& inventory) {

std::cout << "\nEnter vehicle details:\n";

std::cout << "Make: ";

std::string make = getStringInput();

std::cout << "Model: ";

std::string model = getStringInput();

std::cout << "Year: ";

int year = getUserInput(1000, 9999);

std::cout << "Odometer Reading: ";

int odometer = getIntInput();

std::cout << "Fuel Type (0: Gas, 1: Diesel, 2: Electric): ";

FuelType type = getFuelTypeInput();

// Create vehicle based on fuel type

FuelVehicle* newVehicle = nullptr;

switch (type) {

case FuelType::GAS:

newVehicle = new GasCar(make, model, year, odometer);

break;

case FuelType::DIESEL:

newVehicle = new DieselCar(make, model, year, odometer);

break;

case FuelType::ELECTRIC:

newVehicle = new ElectricCar(make, model, year, odometer);

break;

}

if (newVehicle != nullptr) {

inventory.push_back(newVehicle);

std::cout << "\nVehicle added successfully.\n";

} else {

std::cout << "\nFailed to add vehicle. Please try again.\n";

}

}

void listVehicles(const std::vector& inventory) {

std::cout << "\nInventory:\n";

for (size_t i = 0; i < inventory.size(); ++i) {

std::cout << "\nVehicle " << i + 1 << ":\n";

inventory[i]->getCarInformation();

std::cout << "Fuel Type: ";

switch (inventory[i]->getFuelType()) {

case FuelType::GAS:

std::cout << "Gas\n";

break;

case FuelType::DIESEL:

std::cout << "Diesel\n";

break;

case FuelType::ELECTRIC:

std::cout << "Electric\n";

break;

}

}

}

void updateVehicle(std::vector& inventory) {

if (inventory.empty()) {

std::cout << "\nInventory is empty. Cannot update.\n";

return;

}

std::cout << "\nEnter the number of the vehicle to update (1-" << inventory.size() << "): ";

size_t index = getUserInput(1, inventory.size()) - 1;

std::cout << "\nEnter new odometer reading: ";

int newOdometer = getIntInput();

inventory[index]->setOdometer(newOdometer);

std::cout << "\nVehicle updated successfully.\n";

}

void removeVehicle(std::vector& inventory) {

if (inventory.empty()) {

std::cout << "\nInventory is empty. Cannot remove.\n";

return;

}

std::cout << "\nEnter the number of the vehicle to remove (1-" << inventory.size() << "): ";

size_t index = getUserInput(1, inventory.size()) - 1;

delete inventory[index];

inventory.erase(inventory.begin() + index);

std::cout << "\nVehicle removed successfully.\n";

}

void tireRotation(const std::vector& inventory) {

if (inventory.empty()) {

std::cout << "\nInventory is empty. No vehicles to check for tire rotation.\n";

return;

}

std::cout << "\nChecking tire rotation for vehicles:\n";

for (auto vehicle : inventory) {

vehicle->checkTireRotation();

}

}

void oilChange(const std::vector& inventory) {

if (inventory.empty()) {

std::cout << "\nInventory is empty. No vehicles to check for oil change.\n";

return;

}

std::cout << "\nChecking oil change for vehicles:\n";

for (auto vehicle : inventory) {

vehicle->checkOil();

}

}

void recharge(const std::vector& inventory) {

if (inventory.empty()) {

std::cout << "\nInventory is empty. No vehicles to check for recharge.\n";

return;

}

std::cout << "\nChecking recharge for vehicles:\n";

for (auto vehicle : inventory) {

ElectricCar* electricCar = dynamic_cast(vehicle);

if (electricCar != nullptr) {

electricCar->checkChargerPower();

}

}

}

int getUserInput(int min, int max) {

int input;

while (true) {

std::cin >> input;

if (std::cin.fail() || input < min || input > max) {

std::cin.clear();

std::cin.ignore(std::numeric_limits::max(), '\n');

std::cout << "Invalid input. Please enter a number between " << min << " and " << max << ": ";

} else {

std::cin.ignore(std::numeric_limits::max(), '\n');

return input;

}

}

}

std::string getStringInput() {

std::string input;

while (true) {

std::getline(std::cin, input);

if (!input.empty()) {

return input;

} else {

std::cout << "Input cannot be blank. Please enter again: ";

}

}

}

int getIntInput() {

int input;

while (true) {

std::cin >> input;

if (std::cin.fail()) {

std::cin.clear();

std::cin.ignore(std::numeric_limits::max(), '\n');

std::cout << "Invalid input. Please enter a numerical value: ";

} else {

std::cin.ignore(std::numeric_limits::max(), '\n');

return input;

}

}

}

FuelType getFuelTypeInput() {

int input;

while (true) {

input = getUserInput(0, 2);

if (input == 0) {

return FuelType::GAS;

} else if (input == 1) {

return FuelType::DIESEL;

} else if (input == 2) {

return FuelType::ELECTRIC;

} else {

std::cout << "Invalid input. Please enter 0 (Gas), 1 (Diesel), or 2 (Electric): ";

}

}

}

Classes and Interfaces:

1. Vehicle Class:

   • Contains basic details of a vehicle: make, model, year, odometer.
   • Provides getter and setter methods for these attributes.
   • Includes methods for maintenance activities like checkTireRotation().

2. FuelType Enumeration:

   • Enumerates the different fuel types supported: GAS, DIESEL, ELECTRIC.

3. FuelVehicle Abstract Class:

   • Inherits from Vehicle.
   • Declares a pure virtual function getFuelType() to be implemented by derived classes.
   • Includes method checkOil() as an example.

4. GasCar Class:

   • Inherits from FuelVehicle.
   • Implements getFuelType() and getType() methods.

5. DieselCar Class:

   • Inherits from FuelVehicle.
   • Implements getFuelType() and getType() methods.

6. ElectricCar Class:

   • Inherits from FuelVehicle.
   • Implements getFuelType(), checkTireRotation(), checkChargerPower(), and getType() methods.

7. Explanation:

   • Vehicle, FuelVehicle, GasCar, DieselCar, ElectricCar: These classes are designed as per the object-oriented principles, with appropriate inheritance (FuelVehicle inheriting from Vehicle), and polymorphism (checkTireRotation() overridden in ElectricCar).
   • Main Program (main.cpp): This program interacts with the user to manage the vehicle inventory using console input. It allows adding, updating, listing, and removing vehicles, as well as performing specific maintenance checks based on user selections.
   • User Input Handling: Functions like getUserInput(), getStringInput(), and getIntInput() are used to ensure valid input from the user during interactions with the program.

   Usage:

   1. Compile all .cpp files together (e.g., g++ -o maintenance main.cpp Vehicle.cpp FuelVehicle.cpp GasCar.cpp DieselCar.cpp ElectricCar.cpp).
   2. Run the compiled executable (./maintenance on Unix/Linux or maintenance.exe on Windows).
   3. Follow the menu prompts to interact with the program, add vehicles, perform maintenance checks, and manage the inventory.