Попытка чтения или записи в защищенную память - C++ - Ответ 1257447

#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<cmath>
using namespace std;
#include"list.h"
int M = 3;
int MAX_CLIENT = 6;
int entered = 0;
int completed = 0;
long int *ro; //массив счетчиков загрузки клерков
float serve_ave = 0;
float num_ave = 0;
float time_ave = 0;
float queue_ave = 0;
float orders_ave = 0;
int total_ordered = 0;
FILE *timeinshop;
FILE *num;
FILE *order;
long int total;
float get_uniform()
// Равномерное распределение
{
  int number = rand();
  float result = (float)number/(RAND_MAX+1);
  return (result);
}
float get_uniform(int min, int max)
{
    int number = rand();
    float result = min + ((float)number/RAND_MAX) * (max - min);
    return (result);
}
class Client
{
    int id;
    int time;
    public:
    friend class Clerk;
    friend class Shop;
    Client(int i);
};
Client::Client(int i)
{
    id = i;
    time = 0; //счетчик времени, проведенного клиентом в системе
};
class Clerk
{
    const static int path_min = 30;
    const static int path_max = 90;
    const static int money_min = 60;
    const static int money_max = 180;
    int id;
    Client **queue; //массив указателей на клиентов вторичной очереди
    Client *serving;
    int units; //объем текущего заказа
    int to_dpath; //время, оставшееся до конца пути на склад
    int to_bpath; //~к клиентам
    int to_calculate;
    int to_search;
    int from_order;
public:
    friend class Shop;
    Clerk (int i); // добавить параметры времени!!
    ~Clerk();
    void Arrival();
    void TakeAll();
    void ComeBack();
    void Completed();
    ListNode<Client>* TakeOrder(ListNode<Client> *q, int acc);
    void run();
    int QLength();
    int GetState();
};
class Shop
{
    const static int accumulation = 1;
    //const static float input_rate = 0.5;
    int arrival_min;
    int arrival_max;
    ListNode<Client>*queue;
    Clerk **workers;
    int q_length;
    int to_arrival;
    public:
    Shop(Clerk **w, int a_min, int a_max);
    ~Shop();
    void Arrival();
    void run();
    int Choice();
};
Clerk::Clerk(int i)
{
    int j;
    id = i;
    queue = new Client *[MAX_CLIENT];
    for (j = 0; j < MAX_CLIENT; j++)
        queue[j] = NULL;
    serving = NULL;
    units = -1;
    to_dpath = -1;
    to_bpath = -1;
    to_calculate = -1;
    to_search = -1;
    from_order = -1;
}
Clerk::~Clerk()
{
    for(int i = 0; i < QLength(); i++) delete queue[i];
    delete[] queue;
    if (serving) delete serving;
}
int Clerk::QLength()
{
    int k;
    for(int k = 0; k < MAX_CLIENT; k++)
        if (queue[k] == NULL) return (k);
    return (MAX_CLIENT);
}
int Clerk::GetState()
{
    if (units == -1) return (0);
    if (to_dpath > 0) return(1);
    if (to_search > 0) return (2);
    if (to_bpath > 0) return (3);
    if (to_calculate > 0) return (4);
}
ListNode<Client>*Clerk::TakeOrder(ListNode<Client> *q, int acc)
{
    int i;
    ListNode<Client> *ptr = q, *ptr1;
    for (i = 0; i < acc; i++)
    {
        queue[i]  = ptr -> Data();
        ptr = ptr -> Next();
        delete ptr1;
    }
    units = acc;
    from_order = 0;
    to_dpath = get_uniform(path_min, path_max);
    total_ordered++;
    orders_ave = orders_ave * (1 - 1.0/total_ordered) + ((float)units)/total_ordered;
    fprintf(order, "%d\n", acc);
    return (ptr);
}
void Clerk::Arrival()
{
    to_dpath = -1;
    to_search = (int)(get_uniform(2.4 * units, 3.6 * units) * 60);
    if (to_search <= 0) to_search = 1;
}
void Clerk::TakeAll()
{
    to_search = -1;
    to_bpath = get_uniform(path_min, path_max);
}
void Clerk::ComeBack()
{
    int i;
    to_bpath = -1;
    serving = queue[0];
    for(i = 0; i < (MAX_CLIENT - 1); i++)
        queue[i] = queue[i+1];
    queue[MAX_CLIENT - 1] = NULL;
    to_calculate = get_uniform(money_min, money_max);
}
void Clerk::Completed()
{
    int i;
    to_calculate = -1;
    completed++;
    time_ave = time_ave * (1 - 1.0/completed) + (float)(serving -> time)/completed;
    fprintf(timeinshop, "%.3f\n", (float)(serving -> time)/60);
    delete serving;
    serving = NULL;
    if (QLength() == 0)
    {
        units = -1;
        serve_ave = serve_ave *(1 - 1.0/total_ordered) + ((float)from_order)/total_ordered;
        from_order = -1;
        return;
    }
    serving = queue[0];
    for(i = 0; i < (MAX_CLIENT - 1); i++)
        queue[i] = queue[i+1];
    queue[MAX_CLIENT - 1] = NULL;
    to_calculate = get_uniform(money_min, money_max);
}
void Clerk::run()
{
    if (to_dpath > 0) to_dpath--;
    if (to_dpath == 0) Arrival();
    
    if (to_bpath > 0) to_bpath--;
    if (to_bpath == 0) ComeBack();
    
    if (to_calculate > 0) to_calculate--;
    if (to_calculate == 0) Completed();
    
    if (to_search > 0) to_search--;
    if (to_search == 0) TakeAll();
    
    if(units != -1)
    {
        from_order++;
        ro[id-1]++;
    }
}
Shop::Shop(Clerk **w, int a_min, int a_max)
{
    workers = w;
    arrival_min = a_min;
    arrival_max = a_max;
    queue = NULL;
    q_length = 0;
    to_arrival = (int)(get_uniform(arrival_min, arrival_max) * 60);
}
Shop::~Shop()
{
    while (queue) queue = ListDelete<Client>(queue, queue);
}
int Shop::Choice()
{
    int k, i;
    int mas[3];//массив для сохранения номаров свободных клерков
    k = 0;
    for(i = 0; i < M; i++)
    {
        if (workers[i]->GetState() == 0)
        {
            mas[k] = i;
            k++;
        }
    }
    if (k == 0) return (-1); //все клерки заняты
    if (k == 1) return (mas[0]); //свободен только 1 клерк
    i  = rand() % k;
    return (mas[i]);
}
void Shop::Arrival()
{
    Client *p;
    ListNode<Client> *ptr;
    to_arrival = (int)(get_uniform(arrival_min, arrival_max) * 60);
    if (to_arrival == 0) to_arrival = 1;
    entered++;
    p = new Client(entered);
    ptr = new ListNode<Client>(p, NULL);
    if (q_length == 0)
    {
        queue = ptr;
        q_length = 1;
        return;
    }
    ListAdd<Client>(queue, ptr);
    q_length++;
}
void Shop::run()
{
    int k, p, t, i, j;
    ListNode<Client> *ptr;
    if (to_arrival > 0) to_arrival--;
    if (to_arrival == 0) Arrival();
    if (q_length < MAX_CLIENT) p = q_length;
    else p = MAX_CLIENT;
    if (p < accumulation);
    else
    {
        k = Choice();
        if (k == -1);
        else
        {
            queue = workers[k] ->TakeOrder(queue, p);
            q_length -= p;
        }
    }
    if (queue)
    {
        while (ptr)
        {
            (ptr -> Data() -> time)++;
            ptr = ptr -> Next();
        }
    }
    for (i = 0; i < M; i++)
    {
        if (workers[i] ->serving !=NULL) (workers[i] -> serving -> time)++;
        for (j = 0; j < MAX_CLIENT; j++)
        {
            if (workers[i] -> queue[j] !=NULL) 
                (workers[i] -> queue[j] -> time)++;
        }
    }
    p = q_length;
    for (k == 0; k < M; k++)
    {
        p += workers[k] ->QLength();
        if (workers[k] -> GetState() == 4) p++;
    }
    if ((total +1)%60 == 0)
    {
        t = (total + 1)/60;
        fprintf(num, "%d\n", p);
        num_ave = num_ave * (1 - 1.0/t) + ((float)p)/t;
        queue_ave = queue_ave * (1 -1.0/t) + ((float)q_length)/t;
    }
}