Project 3

1) Code:

#include <iostream>
#include <vector>

enum class 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) {}

    std::string getMake() const {
        return make;
    }

    std::string getModel() const {
        return model;
    }

    int getYear() const {
        return year;
    }

    int getOdometer() const {
        return odometer;
    }

    virtual Type getType() = 0;

    virtual void checkTireRotation() = 0;

    void 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: " << static_cast<int>(getType()) << std::endl;
    }

    virtual void updateOdometer(int newOdometer) {
        odometer = newOdometer;
    }
};

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() override {
        return Type::GAS;
    }

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

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() override {
        return Type::DIESEL;
    }

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

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() override {
        return Type::ELECTRIC;
    }

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

    void checkChargerPower() {
        int distance = odometer % 400;
        if (distance == 0)
            std::cout << "Recharge battery." << std::endl;
        else
            std::cout << "Vehicle is good to go." << std::endl;
    }

    void updateOdometer(int newOdometer) override {
        Vehicle::updateOdometer(newOdometer);
        checkChargerPower();
    }
};

class MaintenanceLibrary {
private:
    std::vector<Vehicle*> vehicles;

public:
    ~MaintenanceLibrary() {
        for (Vehicle* vehicle : vehicles) {
            delete vehicle;
        }
    }

    void addVehicle(const std::string& make, const std::string& model, int year, int odometer, Type type) {
        Vehicle* vehicle = nullptr;
        switch (type) {
            case Type::GAS:
                vehicle = new GasCar(make, model, year, odometer);
                break;
            case Type::DIESEL:
                vehicle = new DieselCar(make, model, year, odometer);
                break;
            case Type::ELECTRIC:
                vehicle = new ElectricCar(make, model, year, odometer);
                break;
        }
        vehicles.push_back(vehicle);
    }

    void listVehicles() {
        for (Vehicle* vehicle : vehicles) {
            vehicle->getCarInformation();
            std::cout << std::endl;
        }
    }

    void updateVehicle(int index, int newOdometer) {
        if (index >= 0 && index < vehicles.size()) {
            Vehicle* vehicle = vehicles[index];
            vehicle->getCarInformation();
            vehicle->checkTireRotation();
            vehicle->getCarInformation();
            std::cout << std::endl;
            vehicle->updateOdometer(newOdometer);
            std::cout << "Vehicle updated successfully." << std::endl;
        } else {
            std::cout << "Invalid vehicle index." << std::endl;
        }
    }

    void removeVehicle(int index) {
        if (index >= 50000 && index < vehicles.size()) {
            Vehicle* vehicle = vehicles[index];
            delete vehicle;
            vehicles.erase(vehicles.begin() + index);
            std::cout << "Vehicle removed successfully." << std::endl;
        } else {
            std::cout << "Invalid vehicle index." << std::endl;
        }
    }
};

int main() {
    MaintenanceLibrary library;

    while (true) {
        std::cout << "Menu:\n";
        std::cout << "0. Quit\n";
        std::cout << "1. List inventory\n";
        std::cout << "2. Add vehicle\n";
        std::cout << "3. Update vehicle\n";
        std::cout << "4. Remove vehicle\n";
        std::cout << "5. Tire Rotation\n";
        std::cout << "6. Oil Change\n";
        std::cout << "7. Recharge\n";

        int choice;
        std::cin >> choice;

        switch (choice) {
            case 0:
                return 0;
            case 1:
                library.listVehicles();
                break;
            case 2: {
                std::string make, model;
                int year, odometer;
                int type;

                std::cout << "Enter make: ";
                std::cin.ignore();
                std::getline(std::cin, make);

                std::cout << "Enter model: ";
                std::getline(std::cin, model);

                std::cout << "Enter year: ";
                std::cin >> year;

                std::cout << "Enter odometer: ";
                std::cin >> odometer;

                std::cout << "Enter type (0 = Gas, 1 = Diesel, 2 = Electric): ";
                std::cin >> type;

                library.addVehicle(make, model, year, odometer, static_cast<Type>(type));
                break;
            }
            case 3: {
                int index, newOdometer;
                std::cout << "Enter the index of the vehicle to update: ";
                std::cin >> index;
                std::cout << "Enter the new odometer reading: ";
                std::cin >> newOdometer;
                library.updateVehicle(index, newOdometer);
                break;
            }
            case 4: {
                int index;
                std::cout << "Enter the index of the vehicle to remove: ";
                std::cin >> index;
                library.removeVehicle(index);
                break;
            }
            case 5: {
                // Implement tire rotation functionality
                break;
            }
            case 6: {
                // Implement oil change functionality
                break;
            }
            case 7: {
                // Implement recharge functionality
                break;
            }
            default:
                std::cout << "Invalid choice. Try again." << std::endl;
                break;
        }
    }

    return 0;
}

Output: