c++写数据结构设计 停车场有M个入口，P个出口，停车场共有N个车位，其中每5个车位为一个小型立体车库，先来后到原则进行入场，入场后开始进行计费。若停车场满了之后，门口的车一次排队，出来一辆车之后，放行一辆车再入场。 要求：1）每个入口使用队列结构模拟排队场景，排序车辆需要记录排队时间，根据时间先后进场放行。 2）每个小型立体车库只用散列表进行模拟入库及出库。 3）计费原则：15分钟以下免费，超过15分钟按0.5元/15分钟。小型车夜间停车1元/小时。

好的，这是一个比较复杂的数据结构设计，需要用到多个数据结构和算法。以下是一个基本的实现思路：

1. 创建一个停车场类，包含停车场的属性和方法。
2. 在停车场类中，定义一个queue数组来表示每个入口的排队队列，用一个变量记录每个队列中的车辆数量。
3. 定义一个散列表数组，用来表示每个小型立体车库的状态（空闲或占用），用一个变量记录被占用的小型车库数量。
4. 定义一个车辆类，包含车辆的属性和方法。
5. 当一辆车到达停车场时，将其加入到最少排队的入口队列中，并记录其排队时间。
6. 当一辆车到达小型立体车库时，查询散列表中可用的车库，将其分配给车辆，并将散列表对应位置设置为占用状态。
7. 当车辆离开停车场时，根据其停车时间计算停车费用，并从散列表中释放车库，使其变为空闲状态。
8. 当停车场已满时，将新到达的车辆加入到停车场的等待队列中，直到有车辆离开停车场。
9. 对于夜间停车的小型车辆，需要额外计算停车费用。

下面是一个简单的C++代码实现示例，仅供参考：

#include <iostream>
#include <queue>
#include <unordered_map>
#include <string>
#include <ctime>

using namespace std;

class Car {
public:
    string id;  // 车牌号
    time_t enter_time;  // 进入时间
    time_t leave_time;  // 离开时间
    int parking_time;  // 停车时间（分钟）

    Car(string id, time_t enter_time) {
        this->id = id;
        this->enter_time = enter_time;
    }

    void leave(time_t leave_time) {
        this->leave_time = leave_time;
        this->parking_time = (int)(this->leave_time - this->enter_time) / 60;
    }

    double get_fee() {
        if (this->parking_time <= 15) {
            return 0.0;
        } else {
            return (double)(this->parking_time - 15) / 15 * 0.5;
        }
    }

    double get_night_fee() {
        time_t midnight = time(NULL);
        struct tm* tm_midnight = localtime(&midnight);
        tm_midnight->tm_hour = 0;
        tm_midnight->tm_min = 0;
        tm_midnight->tm_sec = 0;
        time_t midnight_time = mktime(tm_midnight);
        int parking_hour = (int)(this->leave_time - midnight_time) / 3600 + 1;
        return parking_hour * 1.0;
    }
};

class ParkingLot {
private:
    int m;  // 入口数量
    int p;  // 出口数量
    int n;  // 总停车位数
    int l;  // 小型车库容量
    int small_parking_count;  // 小型车库已使用数量
    queue<Car> *entry_queue;  // 入口队列数组
    unordered_map<int, Car> *small_parking;  // 小型车库散列表

public:
    ParkingLot(int m, int p, int n, int l) {
        this->m = m;
        this->p = p;
        this->n = n;
        this->l = l;
        this->entry_queue = new queue<Car>[m];
        this->small_parking = new unordered_map<int, Car>[n / l];
        this->small_parking_count = 0;
    }

    ~ParkingLot() {
        delete[] entry_queue;
        delete[] small_parking;
    }

    bool is_full() {
        return small_parking_count == n / l;
    }

    bool is_small_full(int index) {
        return small_parking[index].size() == l;
    }

    int get_available_small_parking() {
        for (int i = 0; i < n / l; i++) {
            if (!is_small_full(i)) {
                return i;
            }
        }
        return -1;
    }

    void enter(Car car, int entry_index) {
        entry_queue[entry_index].push(car);
    }

    void leave(Car car, int small_parking_index) {
        small_parking[small_parking_index].erase(small_parking_index);
        small_parking_count--;
    }

    void park(Car car, int small_parking_index) {
        small_parking[small_parking_index][small_parking[small_parking_index].size()] = car;
        small_parking_count++;
    }

    void process() {
        time_t now = time(NULL);
        for (int i = 0; i < m; i++) {
            if (!entry_queue[i].empty()) {
                Car car = entry_queue[i].front();
                if (!is_full()) {
                    int index = get_available_small_parking();
                    park(car, index);
                    entry_queue[i].pop();
                }
            }
        }
        for (int i = 0; i < n / l; i++) {
            for (auto it = small_parking[i].begin(); it != small_parking[i].end();) {
                Car car = it->second;
                if ((now - car.enter_time) >= 900) {
                    double fee = car.get_fee();
                    double night_fee = 0.0;
                    if ((now - car.leave_time) >= 3600 && now >= mktime(localtime(&now))) {
                        night_fee = car.get_night_fee();
                    }
                    cout << car.id << " 离开停车场，停车时长：" << car.parking_time << "分钟，停车费用：" << fee << "元，夜间停车费用：" << night_fee << "元" << endl;
                    leave(car, i);
                    it = small_parking[i].erase(it);
                } else {
                    ++it;
                }
            }
        }
    }
};

int main() {
    ParkingLot parking_lot(3, 2, 10, 5);

    time_t now = time(NULL);
    parking_lot.enter(Car("A12345", now), 0);
    parking_lot.enter(Car("B67890", now), 1);
    parking_lot.enter(Car("C45678", now), 2);
    parking_lot.enter(Car("D13579", now), 0);
    parking_lot.enter(Car("E24680", now), 1);

    while (true) {
        parking_lot.process();
        if (parking_lot.is_full()) {
            cout << "停车场已满，等待车辆排队" << endl;
            while (parking_lot.is_full()) {
                parking_lot.process();
            }
            cout << "停车场有空位，开始放行车辆" << endl;
        }
        now = time(NULL);
        if (now % 60 == 0) {
            parking_lot.enter(Car("F12345", now), 2);
        }
        if (now >= mktime(localtime(&now))) {
            break;
        }
    }

    return 0;
}