Project 3
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Base structure for Vehicle
typedef struct {
char make[50];
char model[50];
int year;
int odometer;
void (*perform_maintenance)(void);
} Vehicle;
// Maintenance functions for different car types
void petrol_maintenance() {
printf("Performing maintenance on a Petrol vehicle:\n");
printf("- Oil change\n- Replace oil filter\n- Replace spark plugs\n- Check belts and hoses\n");
}
void diesel_maintenance() {
printf("Performing maintenance on a Diesel vehicle:\n");
printf("- Replace fuel filter\n- Check glow plugs\n- Examine belts and hoses\n- Change engine oil\n");
}
void electric_maintenance() {
printf("Performing maintenance on an Electric vehicle:\n");
printf("- Check charging system\n- Battery health check\n- Inspect electrical connections\n- Tire rotation\n");
}
// Function to create a new vehicle
Vehicle* create_vehicle(const char *make, const char *model, int year, int odometer, void (*maintenance_func)(void)) {
Vehicle *v = (Vehicle*)malloc(sizeof(Vehicle));
if (!v) {
printf("Memory allocation failed!\n");
return NULL;
}
strcpy(v->make, make);
strcpy(v->model, model);
v->year = year;
v->odometer = odometer;
v->perform_maintenance = maintenance_func;
return v;
}
// Function to display vehicle details
void display_vehicle(Vehicle *v) {
if (v) {
printf("Vehicle Details:\n");
printf("Make: %s\n", v->make);
printf("Model: %s\n", v->model);
printf("Year: %d\n", v->year);
printf("Odometer: %d km\n", v->odometer);
}
}
int main() {
// Creating different car types
Vehicle *petrolCar = create_vehicle("Toyota", "Camry", 2018, 50000, petrol_maintenance);
Vehicle *dieselCar = create_vehicle("Ford", "F-250", 2020, 75000, diesel_maintenance);
Vehicle *electricCar = create_vehicle("Tesla", "Model 3", 2022, 30000, electric_maintenance);
// Displaying vehicle details and performing maintenance
printf("\n");
display_vehicle(petrolCar);
petrolCar->perform_maintenance();
printf("\n");
display_vehicle(dieselCar);
dieselCar->perform_maintenance();
printf("\n");
display_vehicle(electricCar);
electricCar->perform_maintenance();
// Freeing allocated memory
free(petrolCar);
free(dieselCar);
free(electricCar);
return 0;
}
#include <iostream>
#include <vector>
#include <string>
// Enum for Fuel Types
enum class Type {
GAS,
DIESEL,
ELECTRIC
};
// Abstract Base Class: Vehicle
class Vehicle {
protected:
std::string make;
std::string model;
int year;
int odometer;
public:
// Constructor
Vehicle(const std::string& make, const std::string& model, int year, int odometer)
: make(make), model(model), year(year), odometer(odometer) {}
// Getter and Setter for Make
std::string getMake() const { return make; }
void setMake(const std::string& make) { this->make = make; }
// Getter and Setter for Model
std::string getModel() const { return model; }
void setModel(const std::string& model) { this->model = model; }
// Getter and Setter for Year
int getYear() const { return year; }
void setYear(int year) { this->year = year; }
// Getter and Setter for Odometer
int getOdometer() const { return odometer; }
void setOdometer(int odometer) { this->odometer = odometer; }
// Maintenance Activities
virtual void checkTireRotation() const {
std::cout << "Checking tire rotation for " << make << " " << model << ".\n";
}
virtual void getCarInformation() const {
std::cout << "Make: " << make << "\nModel: " << model
<< "\nYear: " << year << "\nOdometer: " << odometer << " km\n";
}
// Pure Virtual Function to Get Fuel Type
virtual Type getType() const = 0;
// Virtual Destructor
virtual ~Vehicle() = default;
};
// Derived Class: GasVehicle
class GasVehicle : public Vehicle {
public:
GasVehicle(const std::string& make, const std::string& model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}
Type getType() const override {
return Type::GAS;
}
};
// Derived Class: DieselVehicle
class DieselVehicle : public Vehicle {
public:
DieselVehicle(const std::string& make, const std::string& model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}
Type getType() const override {
return Type::DIESEL;
}
};
// Derived Class: ElectricVehicle
class ElectricVehicle : public Vehicle {
public:
ElectricVehicle(const std::string& make, const std::string& model, int year, int odometer)
: Vehicle(make, model, year, odometer) {}
Type getType() const override {
return Type::ELECTRIC;
}
};
// Vehicle Management System
class VehicleManagementSystem {
private:
std::vector<Vehicle*> vehicles;
public:
// Add Vehicle
void addVehicle(Vehicle* vehicle) {
vehicles.push_back(vehicle);
std::cout << "Vehicle added: " << vehicle->getMake() << " " << vehicle->getModel() << "\n";
}
// Update Vehicle
void updateVehicle(int index, const std::string& make, const std::string& model, int year, int odometer) {
if (index >= 0 && index < vehicles.size()) {
vehicles[index]->setMake(make);
vehicles[index]->setModel(model);
vehicles[index]->setYear(year);
vehicles[index]->setOdometer(odometer);
std::cout << "Vehicle updated at index " << index << ".\n";
} else {
std::cout << "Invalid index.\n";
}
}
// List Vehicles
void listVehicles() const {
if (vehicles.empty()) {
std::cout << "No vehicles in the system.\n";
return;
}
for (size_t i = 0; i < vehicles.size(); ++i) {
std::cout << "Index: " << i << "\n";
vehicles[i]->getCarInformation();
std::cout << "Fuel Type: ";
switch (vehicles[i]->getType()) {
case Type::GAS: std::cout << "Gas\n"; break;
case Type::DIESEL: std::cout << "Diesel\n"; break;
case Type::ELECTRIC: std::cout << "Electric\n"; break;
}
std::cout << "--------------------------\n";
}
}
// Remove Vehicle
void removeVehicle(int index) {
if (index >= 0 && index < vehicles.size()) {
delete vehicles[index];
vehicles.erase(vehicles.begin() + index);
std::cout << "Vehicle removed from index " << index << ".\n";
} else {
std::cout << "Invalid index.\n";
}
}
// Destructor to Clean Up
~VehicleManagementSystem() {
for (auto vehicle : vehicles) {
delete vehicle;
}
}
};
// Main Function
int main() {
VehicleManagementSystem vms;
// Adding Vehicles
vms.addVehicle(new GasVehicle("Toyota", "Camry", 2015, 75000));
vms.addVehicle(new DieselVehicle("Ford", "F-150", 2018, 60000));
vms.addVehicle(new ElectricVehicle("Tesla", "Model 3", 2020, 30000));
// Listing Vehicles
std::cout << "\nListing Vehicles:\n";
vms.listVehicles();
// Updating a Vehicle
vms.updateVehicle(1, "Ford", "F-150", 2018, 65000);
// Listing Vehicles After Update
std::cout << "\nListing Vehicles After Update:\n";
vms.listVehicles();
// Removing a Vehicle
vms.removeVehicle(0);
// Listing Vehicles After Removal
std::cout << "\nListing Vehicles After Removal:\n";
vms.listVehicles();
return 0;
}
#include <iostream>
#include <string>
class Vehicle {
protected:
std::string make;
std::string model;
int year;
double odometer;
public:
Vehicle(const std::string& make, const std::string& model, int year, double odometer)
: make(make), model(model), year(year), odometer(odometer) {}
virtual ~Vehicle() = default;
virtual std::string getType() const = 0;
// Common accessor methods
std::string getMake() const { return make; }
std::string getModel() const { return model; }
int getYear() const { return year; }
double getOdometer() const { return odometer; }
// Common mutator method
void updateOdometer(double newOdometer) {
if (newOdometer >= odometer) {
odometer = newOdometer;
} else {
std::cerr << "New odometer reading cannot be less than the current reading.\n";
}
}
};
class FuelVehicle : public Vehicle {
public:
FuelVehicle(const std::string& make, const std::string& model, int year, double odometer)
: Vehicle(make, model, year, odometer) {}
virtual std::string getFuelType() const = 0;
void checkOil() const {
// Implement oil check logic
std::cout << "Checking oil for " << getMake() << " " << getModel() << ".\n";
}
};
class GasCar : public FuelVehicle {
public:
GasCar(const std::string& make, const std::string& model, int year, double odometer)
: FuelVehicle(make, model, year, odometer) {}
std::string getType() const override {
return "GasCar";
}
std::string getFuelType() const override {
return "Gasoline";
}
};
class DieselCar : public FuelVehicle {
public:
DieselCar(const std::string& make, const std::string& model, int year, double odometer)
: FuelVehicle(make, model, year, odometer) {}
std::string getType() const override {
return "DieselCar";
}
std::string getFuelType() const override {
return "Diesel";
}
};
class ElectricCar : public Vehicle {
public:
ElectricCar(const std::string& make, const std::string& model, int year, double odometer)
: Vehicle(make, model, year, odometer) {}
std::string getType() const override {
return "ElectricCar";
}
void checkTireRotation() const {
const double rotationInterval = 50000.0; // in kilometers
double remainder = std::fmod(odometer, rotationInterval);
if (remainder == 0) {
std::cout << "Tire rotation is due for " << getMake() << " " << getModel() << ".\n";
} else {
std::cout << "Tires are good to go for " << getMake() << " " << getModel() << ".\n";
}
}
void checkChargerPower() const {
const double rechargeInterval = 400.0; // in kilometers
double remainder = std::fmod(odometer, rechargeInterval);
if (remainder == 0) {
std::cout << "Battery recharge is due for " << getMake() << " " << getModel() << ".\n";
} else {
std::cout << "Battery is sufficiently charged for " << getMake() << " " << getModel() << ".\n";
}
}
};
#include <vector>
#include <memory>
#include <limits>
// Typedef for convenience
using VehiclePtr = std::shared_ptr<Vehicle>;
void addVehicle(std::vector<VehiclePtr>& inventory) {
std::string make, model;
int year, type;
double odometer;
// Input validation functions (implement as needed)
make = getNewMake();
model = getNewModel();
year = getYear();
odometer = getNewOdometer();
type = getNewType();
VehiclePtr vehicle;
switch (type) {
case 0:
vehicle = std::make_shared<GasCar>(make, model, year, odometer);
break;
case 1:
vehicle = std::make_shared<DieselCar>(make, model, year, odometer);
break;
case 2:
vehicle = std::make_shared<ElectricCar>(make, model, year, odometer);
break;
default:
std::cerr << "Invalid vehicle type.\n";
return;
}
inventory.push_back(vehicle);
std::cout << "Vehicle added successfully.\n";
}
void listVehicles(const std::vector<VehiclePtr>& inventory) {
if (inventory.empty()) {
std::cout << "No vehicles in inventory.\n";
return;
}
for (size_t i = 0; i < inventory.size(); ++i) {
const auto& vehicle = inventory[i];
std::cout << i + 1 << ". " << vehicle->getType() << ": "
<< vehicle->getMake() << " " << vehicle->getModel()
<< " (" << vehicle->getYear() << "), Odometer: "
<< vehicle->getOdometer() << " km\n";
}
}
void updateVehicle(std::vector<VehiclePtr>& inventory) {
if (inventory.empty()) {
std::cout << "No vehicles to update.\n";
return;
}
size_t index = selectCar(inventory.size());
double newOdometer = getNewOdometerReading();
inventory[index]->updateOdometer(newOdom
::contentReference[oaicite:0]{index=0}