Project 3
1.
#include <iostream>
#include <vector>
#include <limits>
enum Type {
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)
: make(make), model(model), year(year), odometer(odometer) {}
// Getter and setter functions
std::string getMake() const { return make; }
std::string getModel() const { return model; }
int getYear() const { return year; }
int getOdometer() const { return odometer; }
// Maintenance activities
virtual void checkTireRotation() const = 0;
virtual void checkChargerPower() const = 0;
// Get fuel type (pure virtual)
virtual Type getType() const = 0;
// Display car information
void getCarInformation() const {
std::cout << "Make: " << make << "\nModel: " << model << "\nYear: " << year << "\nOdometer: " << odometer << " km\n";
}
};
class GasCar : public Vehicle {
public:
GasCar(const std::string& make, const std::string& model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}
Type getType() const override { return GAS; }
void checkTireRotation() const override {
int tireCycle = 50000;
int distanceRun = getOdometer();
if (distanceRun >= tireCycle && distanceRun % tireCycle == 0) {
std::cout << "Advising tire rotation for Gas Car.\n";
} else {
std::cout << "Tires are good to go for Gas Car.\n";
}
}
void checkChargerPower() const override {
// Gas cars don't have electric power, so this method is empty
}
};
class DieselCar : public Vehicle {
public:
DieselCar(const std::string& make, const std::string& model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}
Type getType() const override { return DIESEL; }
void checkTireRotation() const override {
int tireCycle = 50000;
int distanceRun = getOdometer();
if (distanceRun >= tireCycle && distanceRun % tireCycle == 0) {
std::cout << "Advising tire rotation for Diesel Car.\n";
} else {
std::cout << "Tires are good to go for Diesel Car.\n";
}
}
void checkChargerPower() const override {
// Diesel cars don't have electric power, so this method is empty
}
};
class ElectricCar : public Vehicle {
public:
ElectricCar(const std::string& make, const std::string& model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}
Type getType() const override { return ELECTRIC; }
void checkTireRotation() const override {
int tireCycle = 50000;
int distanceRun = getOdometer();
if (distanceRun >= tireCycle && distanceRun % tireCycle == 0) {
std::cout << "Advising tire rotation for Electric Car.\n";
} else {
std::cout << "Tires are good to go for Electric Car.\n";
}
}
void checkChargerPower() const override {
int powerDistance = 400;
int distanceRun = getOdometer();
if (distanceRun >= powerDistance && distanceRun % powerDistance == 0) {
std::cout << "Advising to recharge battery for Electric Car.\n";
} else {
std::cout << "Electric Car battery is good to go.\n";
}
}
};
class MaintenanceSystem {
private:
std::vector<Vehicle*> vehicles;
public:
~MaintenanceSystem() {
for (auto& vehicle : vehicles) {
delete vehicle;
}
vehicles.clear();
}
void addVehicle(Vehicle* vehicle) {
vehicles.push_back(vehicle);
}
void listVehicles() const {
std::cout << "Vehicle List:\n";
for (const auto& vehicle : vehicles) {
vehicle->getCarInformation();
std::cout << "Fuel Type: ";
switch (vehicle->getType()) {
case GAS:
std::cout << "Gas\n";
break;
case DIESEL:
std::cout << "Diesel\n";
break;
case ELECTRIC:
std::cout << "Electric\n";
break;
}
std::cout << "---------------------\n";
}
}
void updateVehicle(int index, int newOdometer) {
if (index >= 0 && index < vehicles.size()) {
vehicles[index]->checkTireRotation();
vehicles[index]->checkChargerPower();
vehicles[index]->getCarInformation();
std::cout << "Updated Odometer Reading: " << newOdometer << " km\n";
vehicles[index]->getCarInformation();
} else {
std::cout << "Invalid vehicle index.\n";
}
}
void removeVehicle(int index) {
if (index >= 0 && index < vehicles.size()) {
delete vehicles[index];
vehicles.erase(vehicles.begin() + index);
std::cout << "Vehicle removed from inventory.\n";
} else {
std::cout << "Invalid vehicle index.\n";
}
}
size_t size() const {
return vehicles.size();
}
Vehicle* operator[](size_t index) const {
if (index < vehicles.size()) {
return vehicles[index];
} else {
return nullptr;
}
}
};
int getNewYear() {
int year;
std::cout << "Enter Year: ";
std::cin >> year;
// Validate the year input (4 digits)
while (std::cin.fail() || std::to_string(year).length() != 4) {
std::cin.clear();
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
std::cout << "Invalid input. Enter a 4-digit year: ";
std::cin >> year;
}
return year;
}
int getNewOdometer() {
int odometer;
std::cout << "Enter Odometer Reading: ";
std::cin >> odometer;
// Validate the odometer input (numeric)
while (std::cin.fail()) {
std::cin.clear();
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
std::cout << "Invalid input. Enter a numeric odometer reading: ";
std::cin >> odometer;
}
return odometer;
}
int getNewType() {
int type;
std::cout << "Enter Fuel Type (0: Gas, 1: Diesel, 2: Electric): ";
std::cin >> type;
// Validate the fuel type input (0-2)
while (std::cin.fail() || type < 0 || type > 2) {
std::cin.clear();
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
std::cout << "Invalid input. Enter a valid fuel type (0-2): ";
std::cin >> type;
}
return type;
}
int selectCar(const MaintenanceSystem& maintenanceSystem) {
int index;
maintenanceSystem.listVehicles();
std::cout << "Enter the index of the vehicle: ";
std::cin >> index;
while (index < 0 || index >= maintenanceSystem.size()) {
std::cout << "Invalid vehicle index. Enter a valid index: ";
std::cin >> index;
}
return index;
}
int getNewOdometerReading() {
int newOdometer;
std::cout << "Enter the new odometer reading: ";
std::cin >> newOdometer;
// Validate the new odometer input (numeric)
while (std::cin.fail()) {
std::cin.clear();
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
std::cout << "Invalid input. Enter a numeric odometer reading: ";
std::cin >> newOdometer;
}
return newOdometer;
}
int main() {
MaintenanceSystem maintenanceSystem;
int choice;
do {
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: ";
std::cin >> choice;
switch (choice) {
case 0:
break;
case 1:
maintenanceSystem.listVehicles();
break;
case 2: {
std::string make, model;
int year, odometer, type;
std::cout << "Enter Make: ";
std::cin >> make;
std::cout << "Enter Model: ";
std::cin >> model;
year = getNewYear();
odometer = getNewOdometer();
type = getNewType();
Vehicle* newVehicle = nullptr;
switch (static_cast<Type>(type)) {
case GAS:
newVehicle = new GasCar(make, model, year, odometer);
break;
case DIESEL:
newVehicle = new DieselCar(make, model, year, odometer);
break;
case ELECTRIC:
newVehicle = new ElectricCar(make, model, year, odometer);
break;
}
maintenanceSystem.addVehicle(newVehicle);
std::cout << "Vehicle added to inventory.\n";
break;
}
case 3: {
int index = selectCar(maintenanceSystem);
int newOdometer = getNewOdometerReading();
maintenanceSystem.updateVehicle(index, newOdometer);
break;
}
case 4: {
int index = selectCar(maintenanceSystem);
maintenanceSystem.removeVehicle(index);
break;
}
case 5: {
int index = selectCar(maintenanceSystem);
maintenanceSystem[index]->checkTireRotation();
break;
}
case 6: {
int index = selectCar(maintenanceSystem);
// Assuming Electric cars need oil change as well for simplicity
maintenanceSystem[index]->checkTireRotation();
break;
}
case 7: {
int index = selectCar(maintenanceSystem);
// Assuming only Electric cars need recharge for simplicity
maintenanceSystem[index]->checkChargerPower();
break;
}
default:
std::cout << "Invalid choice. Please enter a valid option.\n";
}
} while (choice != 0);
return 0;
}