C 程序：机场模拟修改为 3 条跑道

Question

I was going through a book called " Data Structures and Program Design in C " where I came across this problem.

The idea is to create an airport simulation for 1 runway and then further modify it to 2 runways and then 3.

I did understand the implementation for 1 runway, but I need some guidance on how to further approach the problem to modify it to 3 runways. I am attaching the program for 1 runway and the modifications that need to be done for the 3 runway problem.

Exact Assignment wording:

Modify the simulation to have three runways, one always reserved for each of landing and takeoff and the third used for landings unless the landing queue is empty, in which case it can be used for takeoffs.

My Code:

#include <conio.h>
#include <stdlib.h>
#include <ctype.h>
#include <math.h>
#include <time.h>
#include <limits.h>

#define MAX 3
#define ARRIVE 0
#define DEPART 1

struct plane
{
    int id;
    int tm;
};

struct queue
{
    int count;
    int front;
    int rear;
    struct plane p[MAX];
};

void initqueue(struct queue*);
void addqueue(struct queue*, struct plane);
struct plane delqueue(struct queue*);
int size(struct queue);
int empty(struct queue);
int full(struct queue);

void initqueue(struct queue* pq)
{
    pq->count = 0;
    pq->front = 0;
    pq->rear = -1;
}

void addqueue(struct queue* pq, struct plane item)
{
    if (pq->count >= MAX)
    {
        printf("\nQueue is full.\n");
        return;
    }
    (pq->count)++;

    pq->rear = (pq->rear + 1) % MAX;
    pq->p[pq->rear] = item;
}

struct plane delqueue(struct queue* pq)
{
    struct plane p1;

    if (pq->count <= 0)
    {
        printf("\nQueue is empty.\n");
        p1.id = 0;
        p1.tm = 0;
    }
    else
    {
        (pq->count)--;
        p1 = pq->p[pq->front];
        pq->front = (pq->front + 1) % MAX;
    }
    return p1;
}

int size(struct queue q)
{
    return q.count;
}

int empty(struct queue q)
{
    return (q.count <= 0);
}

int full(struct queue q)
{
    return (q.count >= MAX);
}

struct airport
{
    struct queue landing;
    struct queue takeoff;
    struct queue* pl;
    struct queue* pt;
    int idletime;
    int landwait, takeoffwait;
    int nland, nplanes, nrefuse, ntakeoff;
    struct plane pln;
};

void initairport(struct airport*);
void start(int*, double*, double*);
void newplane(struct airport*, int, int);
void refuse(struct airport*, int);
void land(struct airport*, struct plane, int);
void fly(struct airport*, struct plane, int);
void idle(struct airport*, int);
void conclude(struct airport*, int);
int randomnumber(double);
void apaddqueue(struct airport*, char);
struct plane apdelqueue(struct airport*, char);
int apsize(struct airport, char);
int apfull(struct airport, char);
int apempty(struct airport, char);
void myrandomize();

void initairport(struct airport* ap)
{
    initqueue(&(ap->landing));
    initqueue(&(ap->takeoff));

    ap->pl = &(ap->landing);
    ap->pt = &(ap->takeoff);
    ap->nplanes = ap->nland = ap->ntakeoff = ap->nrefuse = 0;
    ap->landwait = ap->takeoffwait = ap->idletime = 0;
}

void start(int* endtime, double* expectarrive, double* expectdepart)
{
    int flag = 0;
    char wish;

    printf("\nProgram that simulates an airport with only one runway.\n");
    printf("One plane can land or depart in each unit of time.\n");
    printf("Up to %d planes can be waiting to land or take off at any time.\n", MAX);
    printf("How many units of time will the simulation run?");
    scanf("%d", endtime);
    myrandomize();
    do
    {
        printf("\nExpected number of arrivals per unit time? ");
        scanf("%lf", expectarrive);
        printf("\nExpected number of departures per unit time? ");
        scanf("%lf", expectdepart);

        if (*expectarrive < 0.0 || *expectdepart < 0.0)
        {
            printf("These numbers must be nonnegative.\n");
            flag = 0;
        }
        else
        {
            if (*expectarrive + *expectdepart > 1.0)
            {
                printf("The airport will become saturated. Read new numbers? ");
                scanf(" %c", &wish);
                if (tolower(wish) == 'y')
                    flag = 0;
                else
                    flag = 1;
            }
            else
                flag = 1;
        }
    } while (flag == 0);
}

void newplane(struct airport* ap, int curtime, int action)
{
    (ap->nplanes)++;
    ap->pln.id = ap->nplanes;
    ap->pln.tm = curtime;

    switch (action)
    {
    case ARRIVE:
        printf("\n");
        printf("Plane %d ready to land.\n", ap->nplanes);
        break;

    case DEPART:
        printf("\nPlane %d ready to take off.\n", ap->nplanes);
        break;
    }
}

void refuse(struct airport* ap, int action)
{
    switch (action)
    {
    case ARRIVE:

        printf("\tplane  %d directed to another airport.\n", ap->pln.id);
        break;

    case DEPART:

        printf("\tplane %d told to try later.\n", ap->pln.id);
        break;
    }
    (ap->nrefuse)++;
}

void land(struct airport* ap, struct plane pl, int curtime)
{
    int wait;

    wait = curtime - pl.tm;
    printf("%d: Plane %d landed ", curtime, pl.id);
    printf("in queue %d units \n", wait);
    (ap->nland)++;
    (ap->landwait) += wait;
}

void fly(struct airport* ap, struct plane pl, int curtime)
{
    int wait;

    wait = curtime - pl.tm;
    printf("%d: Plane %d took off ", curtime, pl.id);
    printf("in queue %d units \n", wait);
    (ap->ntakeoff)++;
    (ap->takeoffwait) += wait;
}

void idle(struct airport* ap, int curtime)
{
    printf("%d: Runway is idle.\n", curtime);
    ap->idletime++;
}

void conclude(struct airport* ap, int endtime)
{
    printf("\tSimulation has concluded after %d units.\n", endtime);
    printf("\tTotal number of planes processed: %d\n", ap->nplanes);
    printf("\tNumber of planes landed: %d\n", ap->nland);
    printf("\tNumber of planes taken off: %d\n", ap->ntakeoff);
    printf("\tNumber of planes refused use: %d\n", ap->nrefuse);
    printf("\tNumber left ready to land: %d\n", apsize(*ap, 'l'));
    printf("\tNumber left ready to take off: %d\n", apsize(*ap, 't'));

    if (endtime > 0)
        printf("\tPercentage of time runway idle: %lf \n", ((double)ap->idletime / endtime) * 100.0);

    if (ap->nland > 0)
        printf("\tAverage wait time to land: %lf \n", ((double)ap->landwait / ap->nland));

    if (ap->ntakeoff > 0)
        printf("\tAverage wait time to take off: %lf \n", ((double)ap->takeoffwait / ap->ntakeoff));
}

int randomnumber(double expectedvalue)
{
    int n = 0; //counter of iteration
    double limit;
    double x;  //pseudo random number
    limit = exp(-expectedvalue);
    x = rand() / (double) RAND_MAX;
    while (x > limit) {
        n++;
        x *= rand() / (double) RAND_MAX;
    }
    return n;
}

void apaddqueue(struct airport* ap, char type)
{
    switch (tolower(type))
    {
    case'l':
        addqueue(ap->pl, ap->pln);
        break;

    case't':
        addqueue(ap->pt, ap->pln);
        break;
    }
}

struct plane apdelqueue(struct airport* ap, char type)
{
    struct plane p1;

    switch (tolower(type))
    {
    case'l':
        p1 = delqueue(ap->pl);
        break;

    case't':
        p1 = delqueue(ap->pl);
        break;
    }

    return p1;
}

int apsize(struct airport ap, char type)
{
    switch (tolower(type))
    {
    case'l':
        return (size(*(ap.pl)));

    case't':
        return (size(*(ap.pt)));
    }

    return 0;
}

int apfull(struct airport ap, char type)
{
    switch (tolower(type))
    {
    case'l':
        return (full(*(ap.pl)));

    case't':
        return (full(*(ap.pt)));
    }

    return 0;
}

int apempty(struct airport ap, char type)
{
    switch (tolower(type))
    {
    case'l':
        return (empty(*(ap.pl)));

    case't':
        return (empty(*(ap.pt)));
    }

    return 0;
}

void myrandomize()
{
    srand((unsigned int)(time(NULL) % 10000));
}

void main()
{
    srand(time(NULL));
    struct airport a;
    int i, pri, curtime, endtime;
    double expectarrive, expectdepart;
    struct plane temp;
    int test;
    test = randomnumber(0.47);
    printf("%d", test);
    initairport(&a);

    start(&endtime, &expectarrive, &expectdepart);

    for (curtime = 1; curtime <= endtime; curtime++)
    {
        pri = randomnumber(expectarrive);

        for (i = 1; i <= pri; i++)
        {
            newplane(&a, curtime, ARRIVE);
            if (apfull(a, 'l'))
                refuse(&a, ARRIVE);
            else
                apaddqueue(&a, 'l');
        }

        pri = randomnumber(expectdepart);
        for (i = 1; i <= pri; i++)
        {
            newplane(&a, curtime, DEPART);
            if (apfull(a, 't'))
                refuse(&a, DEPART);
            else
                apaddqueue(&a, 't');
        }

        if (!(apempty(a, 'l')))
        {
            temp = apdelqueue(&a, 'l');
            land(&a, temp, curtime);
        }
        else
        {
            if (!(apempty(a, 't')))
            {
                temp = apdelqueue(&a, 't');
                fly(&a, temp, curtime);
            }
            else
                idle(&a, curtime);
        }
    }

    conclude(&a, endtime);

} 

Any help or guidance would be highly appreciated.

Answer 1

You should probably do a radical re-design where you create a struct runway , containing a queue for landing, one for take-off and all the needed variables. Essentially what the airport struct is currently doing. Maybe something along the lines of this:

struct runway
{
    struct queue landing;
    struct queue takeoff;
    ... // whatever other variables the individual runway needs

};

struct airport
{
  struct runway runways[3];
  ... // variables not related to runways but the whole airport
};

Now you can also add functionality per runway, to give it a certain behavior. For example there might be a "landing only" runway, which is a certain kind of runway. Before you know it, you might be implementing a simplistic version of the OO concept inheritance.