用 C++ 设计停车系统

2025年3月17日 | 阅读 8 分钟

引言

停车位是当今发展中不可或缺的元素，尤其是在城市多功能建筑和结构中。尽管机场、城市和购物中心有大量的公共停车空间，但有效管理它们可能是一场噩梦。高效的停车场系统可以保持交通畅通，监控停车位占用情况，并确保高效的停车操作。在本文中，我们将讨论如何使用 C++ 实现一个简单的停车场设计。我们将编辑问题，提及所需的所有组件，并为该问题构建一个简单的解决方案。

问题陈述

我们需要创建一个停车场系统，该系统可以同时容纳多辆车，并记录剩余的停车位数。所考虑的系统应具有以下功能：

停车： 场地可用性管理 - 每当车辆开到场地时，相关的泊车员将始终邀请观察者到至少一个空位。
移车： 如果有车辆停放，系统应标记该停车位现已空闲。
跟踪可用车位： 在这种系统的操作中，将在特定时间准确提及可用车位的相当数量。

很明显，这个停车场没有无限的车位，我们还假设可以在单个停车场内停放各种类型的车辆（例如，汽车、摩托车和公共汽车），并且停车位会因车辆类型而异。

程序 1

示例

 
#include <iostream>
#include <vector>
#include <string>

using namespace std;

// Enum to define vehicle sizes
enum VehicleSize { MOTORCYCLE, COMPACT, LARGE };

// Abstract class for a vehicle
class Vehicle {
protected:
    VehicleSize size;
    int spotsNeeded;
public:
    virtual VehicleSize getSize() = 0;
    virtual int getSpotsNeeded() = 0;
};

class Motorcycle : public Vehicle {
public:
    Motorcycle() {
        size = MOTORCYCLE;
        spotsNeeded = 1;
    }
    VehicleSize getSize() override {
        return MOTORCYCLE;
    }
    int getSpotsNeeded() override {
        return 1;
    }
};

class Car : public Vehicle {
public:
    Car() {
        size = COMPACT;
        spotsNeeded = 1;
    }
    VehicleSize getSize() override {
        return COMPACT;
    }
    int getSpotsNeeded() override {
        return 1;
    }
};

class Bus : public Vehicle {
public:
    Bus() {
        size = LARGE;
        spotsNeeded = 5;
    }
    VehicleSize getSize() override {
        return LARGE;
    }
    int getSpotsNeeded() override {
        return 5;
    }
};

// Class to represent a parking spot
class ParkingSpot {
private:
    VehicleSize spotSize;
    Vehicle* currentVehicle;
    int spotNumber;
public:
    ParkingSpot(VehicleSize size, int num) : spotSize(size), spotNumber(num), currentVehicle(nullptr) {}

    bool isAvailable() {
        return currentVehicle == nullptr;
    }

    bool canFitVehicle(Vehicle* vehicle) {
        return isAvailable() && vehicle->getSize() <= spotSize;
    }

    void parkVehicle(Vehicle* vehicle) {
        currentVehicle = vehicle;
    }

    void removeVehicle() {
        currentVehicle = nullptr;
    }

    int getSpotNumber() const {
        return spotNumber;
    }
};

// Class to represent a parking level
class ParkingLevel {
private:
    int floorNumber;
    vector<ParkingSpot> spots;
    int availableSpots;
public:
    ParkingLevel(int floor, int numberOfSpots) : floorNumber(floor), availableSpots(numberOfSpots) {
        for (int i = 0; i < numberOfSpots; ++i) {
            spots.push_back(ParkingSpot(COMPACT, i));
        }
    }

    bool parkVehicle(Vehicle* vehicle) {
        int spotsNeeded = vehicle->getSpotsNeeded();
        for (int i = 0; i < spots.size(); ++i) {
            if (spots[i].canFitVehicle(vehicle)) {
                spots[i].parkVehicle(vehicle);
                availableSpots--;
                return true;
            }
        }
        return false;
    }

    void removeVehicle(int spotNumber) {
        spots[spotNumber].removeVehicle();
        availableSpots++;
    }

    int getAvailableSpots() {
        return availableSpots;
    }
};

// Class to represent the parking lot
class ParkingLot {
private:
    vector<ParkingLevel> levels;
public:
    ParkingLot(int numLevels, int spotsPerLevel) {
        for (int i = 0; i < numLevels; ++i) {
            levels.push_back(ParkingLevel(i, spotsPerLevel));
        }
    }

    bool parkVehicle(Vehicle* vehicle) {
        for (auto& level : levels) {
            if (level.parkVehicle(vehicle)) {
                return true;
            }
        }
        return false;
    }

    void removeVehicle(int levelNumber, int spotNumber) {
        levels[levelNumber].removeVehicle(spotNumber);
    }

    void displayAvailableSpots() {
        for (int i = 0; i < levels.size(); ++i) {
            cout << "Level " << i << ": " << levels[i].getAvailableSpots() << " spots available." << endl;
        }
    }
};

int main() {
    // Create a parking lot with 3 levels and 10 spots per level
    ParkingLot parkingLot(3, 10);

    Vehicle* car = new Car();
    Vehicle* motorcycle = new Motorcycle();
    Vehicle* bus = new Bus();

    // Park vehicles
    parkingLot.parkVehicle(car);
    parkingLot.parkVehicle(motorcycle);
    parkingLot.parkVehicle(bus);

    // Display available spots
    parkingLot.displayAvailableSpots();

    return 0;
}   

编译并运行

输出

 
Level 0: 8 spots available.
Level 1: 10 spots available.
Level 2: 10 spots available.

代码解释

车辆类（Vehicle Class）是抽象类，包含摩托车（Motorcycle）、汽车（Car）和公共汽车（Bus）等子类，这些子类实现了结构中所需的停车位数。
停车位类（ParkingSpot Class）： 此类表示具有独立尺寸的停车空间，也称为停车位。它能够验证停车位是否被占用以及是否可以容纳车辆。
停车层类（ParkingLevel Class）： 它包含多个停车位，并负责车辆在停车区域的正确停放。只有在有空停车位的情况下才能停车。当车辆驶出停车区时，可以从该层移除车辆。
停车场类（ParkingLot Class）： 它控制多个停车场区域内的多个层。它特别优化用于需要在可用空间内停放一个或多个车辆，然后随时移除的情况。

程序 2

示例

 
#include <iostream>
#include <vector>
#include <chrono>
#include <string>

using namespace std;

// Enum to define vehicle sizes
enum VehicleSize { MOTORCYCLE, COMPACT, LARGE };

// Abstract class for a vehicle
class Vehicle {
protected:
    string licensePlate;
    VehicleSize size;
    int spotsNeeded;
public:
    Vehicle(string plate) : licensePlate(plate) {}

    string getLicensePlate() const {
        return licensePlate;
    }

    virtual VehicleSize getSize() = 0;
    virtual int getSpotsNeeded() = 0;
};

class Motorcycle : public Vehicle {
public:
    Motorcycle(string plate) : Vehicle(plate) {
        size = MOTORCYCLE;
        spotsNeeded = 1;
    }
    VehicleSize getSize() override {
        return MOTORCYCLE;
    }
    int getSpotsNeeded() override {
        return 1;
    }
};

class Car : public Vehicle {
public:
    Car(string plate) : Vehicle(plate) {
        size = COMPACT;
        spotsNeeded = 1;
    }
    VehicleSize getSize() override {
        return COMPACT;
    }
    int getSpotsNeeded() override {
        return 1;
    }
};

class Bus : public Vehicle {
public:
    Bus(string plate) : Vehicle(plate) {
        size = LARGE;
        spotsNeeded = 5;
    }
    VehicleSize getSize() override {
        return LARGE;
    }
    int getSpotsNeeded() override {
        return 5;
    }
};

// Class to represent a parking spot
class ParkingSpot {
private:
    VehicleSize spotSize;
    Vehicle* currentVehicle;
    int spotNumber;
    bool isReserved;  // Reserved spot feature

public:
    ParkingSpot(VehicleSize size, int num) : spotSize(size), spotNumber(num), currentVehicle(nullptr), isReserved(false) {}

    bool isAvailable() {
        return currentVehicle == nullptr && !isReserved;
    }

    bool canFitVehicle(Vehicle* vehicle) {
        return isAvailable() && vehicle->getSize() <= spotSize;
    }

    void parkVehicle(Vehicle* vehicle) {
        currentVehicle = vehicle;
    }

    void removeVehicle() {
        currentVehicle = nullptr;
    }

    int getSpotNumber() const {
        return spotNumber;
    }

    bool reserveSpot() {
        if (!isReserved && isAvailable()) {
            isReserved = true;
            return true;
        }
        return false;
    }

    void unreserveSpot() {
        isReserved = false;
    }

    bool isReservedSpot() {
        return isReserved;
    }
};

// Class to track parking duration and fee calculation
class ParkingTicket {
private:
    chrono::time_point<chrono::system_clock> entryTime;
    chrono::time_point<chrono::system_clock> exitTime;
    double hourlyRate;

public:
    ParkingTicket(double rate = 5.0) : hourlyRate(rate) {
        entryTime = chrono::system_clock::now();
    }

    void setExitTime() {
        exitTime = chrono::system_clock::now();
    }

    double calculateFee() {
        chrono::duration<double> duration = exitTime - entryTime;
        return duration.count() * hourlyRate;
    }
};

// Class to represent a parking level
class ParkingLevel {
private:
    int floorNumber;
    vector<ParkingSpot> spots;
    int availableSpots;
    int totalSpots;

public:
    ParkingLevel(int floor, int numberOfSpots) : floorNumber(floor), availableSpots(numberOfSpots), totalSpots(numberOfSpots) {
        for (int i = 0; i < numberOfSpots; ++i) {
            spots.push_back(ParkingSpot(COMPACT, i));
        }
    }

    bool parkVehicle(Vehicle* vehicle) {
        int spotsNeeded = vehicle->getSpotsNeeded();
        for (int i = 0; i < spots.size(); ++i) {
            if (spots[i].canFitVehicle(vehicle)) {
                spots[i].parkVehicle(vehicle);
                availableSpots--;
                return true;
            }
        }
        return false;
    }

    void removeVehicle(int spotNumber) {
        spots[spotNumber].removeVehicle();
        availableSpots++;
    }

    int getAvailableSpots() const {
        return availableSpots;
    }

    int getTotalSpots() const {
        return totalSpots;
    }

    bool reserveSpot(int spotNumber) {
        if (spots[spotNumber].isAvailable()) {
            spots[spotNumber].reserveSpot();
            availableSpots--;
            return true;
        }
        return false;
    }

    void unreserveSpot(int spotNumber) {
        if (spots[spotNumber].isReservedSpot()) {
            spots[spotNumber].unreserveSpot();
            availableSpots++;
        }
    }
};

// Class to represent the parking lot
class ParkingLot {
private:
    vector<ParkingLevel> levels;

public:
    ParkingLot(int numLevels, int spotsPerLevel) {
        for (int i = 0; i < numLevels; ++i) {
            levels.push_back(ParkingLevel(i, spotsPerLevel));
        }
    }

    bool parkVehicle(Vehicle* vehicle) {
        for (auto& level : levels) {
            if (level.parkVehicle(vehicle)) {
                return true;
            }
        }
        return false;
    }

    void removeVehicle(int levelNumber, int spotNumber) {
        levels[levelNumber].removeVehicle(spotNumber);
    }

    void displayAvailableSpots() {
        for (int i = 0; i < levels.size(); ++i) {
            cout << "Level " << i << ": " << levels[i].getAvailableSpots() << " spots available." << endl;
        }
    }

    bool reserveSpot(int levelNumber, int spotNumber) {
        return levels[levelNumber].reserveSpot(spotNumber);
    }

    void unreserveSpot(int levelNumber, int spotNumber) {
        levels[levelNumber].unreserveSpot(spotNumber);
    }
};

// Main function to test the system
int main() {
    // Create a parking lot with 3 levels and 10 spots per level
    ParkingLot parkingLot(3, 10);

    // Create vehicles
    Vehicle* car = new Car("CAR123");
    Vehicle* motorcycle = new Motorcycle("MOTO456");
    Vehicle* bus = new Bus("BUS789");

    // Park vehicles
    parkingLot.parkVehicle(car);
    parkingLot.parkVehicle(motorcycle);
    parkingLot.parkVehicle(bus);

    // Display available spots
    parkingLot.displayAvailableSpots();

    // Reserve a spot
    if (parkingLot.reserveSpot(0, 2)) {
        cout << "Spot 2 on Level 0 reserved successfully." << endl;
    } else {
        cout << "Failed to reserve spot 2 on Level 0." << endl;
    }

    // Unreserve a spot
    parkingLot.unreserveSpot(0, 2);

    // Display available spots again
    parkingLot.displayAvailableSpots();

    return 0;
}   

编译并运行

输出

 
Level 0: 8 spots available.
Level 1: 10 spots available.
Level 2: 10 spots available.
Spot 2 on Level 0 reserved successfully.
Level 0: 8 spots available.
Level 1: 10 spots available.
Level 2: 10 spots available.

说明

车辆登记和识别： 车辆类现在包含一个 licensePlate 属性，用于跟踪每辆车的车牌号。
停车费： 停车票类（ParkingTicket class）使用简单的每小时费率计算基于进出时间的停车费。
动态车位分配： 车辆根据其大小（摩托车、紧凑型、大型）停放，不同类型的车辆可以停放到其他车位中。
预订系统： 用户可以预订停车位。系统会阻止车辆占用预订的车位，并且可以取消预订以腾出空间。
显示可用车位： 系统显示每个级别的可用停车位数。

结论

总之，这个用 C++ 开发的简单停车场系统展示了如何组织车辆并管理其在多个级别上的可用空间。该设计可以增强以包含更复杂的功能，例如支付选项处理、移动动态车位占用和实时更新信息。该设计可以用作任何复杂停车系统解决方案的基础。

下一主题C++ 中的朋友配对问题

用 C++ 设计停车系统

引言

问题陈述

程序 1

示例

代码解释

程序 2

示例

说明

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C++ 教程

C++ 控制语句

C++ 函数

C++ 数组

C++ 类和对象

C++ 构造函数

C++ 继承

C++ 多态

C++ 抽象

C++ 命名空间

C++ 模板

C++ 字符串

C++ 指针

信号处理

C++ 异常

C++ 文件与流

C++ STL 教程

面试题

选择题

C++ 程序

C++ STL Stack

C++ STL Bitset

C++ STL Deque

C++ STL List

C++ STL Map

C++ STL Math

C++ STL priority_queue

C++ STL Queue

C++ STL Multiset

C++ STL Multimap

C++ STL Set

C++ STD Strings

C++ STL Vector

C++ 操纵符

C++ STL Algorithms

C++ Algorithm

C++ Iterators

C++ 杂项

用 C++ 设计停车系统

引言

问题陈述

程序 1

示例

代码解释

程序 2

示例

说明

结论

相关帖子

C++ 中的自数

C++ 中计算时针和分针之间的角度

C++ 中在七段显示器中使用最少段查找元素

C++ 缓存友好代码

C++ 中检查两个三角形全等的程序

C++ 中的填字游戏求解器

C++ Kasai 算法

C++ 中的经济数

C++ 中查找最终安全状态

C++ pthread_cond_broadcast() 方法

订阅 Tpoint Tech