Файл: Курсовая работа по дисциплине Технология программирования.docx

Количество полос : 3
2-е направление

Интервал времени между прибытием машин : 1 - 3 сек

Интервал времени задержки машин на перекрёстке : 2 - 4 сек

Количество полос : 1
3-е направление

Интервал времени между прибытием машин : 4 - 6 сек

Интервал времени задержки машин на перекрёстке : 2 - 12 сек

Количество полос : 5
4-е направление

Интервал времени между прибытием машин : 5 - 10 сек

Интервал времени задержки машин на перекрёстке : 6 - 7 сек

Количество полос : 2

Результаты моделирования:
1-е направление

Количество машин, проехавших через перекрёсток = 71

по 1-ой полосе : 25

по 2-ой полосе : 24

по 3-ой полосе : 21

Среднее время ожидания в пробке = 12 сек

Среднее время ожидания на светофоре = 3 сек
2-е направление

Количество машин, проехавших через перекрёсток = 89

по 1-ой полосе : 89

Среднее время ожидания в пробке = 3 мин 2 сек

Среднее время ожидания на светофоре = 2 сек

3-е направление

Количество машин, проехавших через перекрёсток = 35

по 1-ой полосе : 13

по 2-ой полосе : 9

по 3-ой полосе : 7

по 4-ой полосе : 4

по 5-ой полосе : 2

Среднее время ожидания на светофоре = 4 сек
4-е направление

Количество машин, проехавших через перекрёсток = 23

по 1-ой полосе : 13

по 2-ой полосе : 10

Среднее время ожидания в пробке = 1 сек

Среднее время ожидания на светофоре = 3 сек

Вывод
В некоторых случаях суммарное количество машин, проехавших по каждой полосе, не равно общему количеству машин, проехавших по данному направлению. Это можно объяснить тем, что программа считает усреднённые значения по всем итерациям. А при подсчёте среднего значения происходит утечка дробных значений, которая и приводит к погрешности.

Заключение

При выполнении курсовой работы были использованы такие приёмы ООП как композиция, наследование, использование статических данных-элементов при наследовании. В программе реализованы все требования, перечисленные в разделе «Постановка задачи».

Пожелания по дальнейшему развитию проекта:

-Для того, чтобы моделирование перекрёстка со светофором было более реалистично при времени моделирования равном 24 часа и более, нужно предложить пользователю возможность задания разной интенсивности потока машин в разное время суток.

-Предоставить пользователю возможность сымитировать препятствие на какой-либо полосе движения путём увеличения времени задержки машины на этой полосе. Например, это может быть яма или неровность, на преодоление которой требуется некоторое количество времени, которое и предлагается задать пользователю.

---

-Добавить в программу имитацию пешеходов, которые появляются в случайный момент времени и нажимают на кнопку, которая меняет знак разрешающего сигнала светофора на запрещающий (для автомобилей). Пользователю предлагается ввести интервал времени между появлением пешеходов и время, в течение которого для машин будет гореть запрещающий сигнал светофора в случае нажатия пешеходом кнопки.

Список использованной литературы

1. 
   Шахмаметов Р.Г. «Программирование на языках высокого уровня. Методические указания» – Новосибирск: кафедра АСУ НГТУ, 2006
   
2. 
   Подбельский В.В. «Язык С++» ― Москва: Финансы и статистика, 2004
   
3. 
   Б.Страуструп. «Язык программирования С++. Специальное издание» ― Москва: издательство Бином, 2004
   

Листинг

#include "random.h"

#include

#include

#include

#include

#include

#include

#include "Form1.h"
using namespace std;
class Simulation{

public:

Simulation();

Simulation(int, int*, int*, int*, int*, int*, int, int, int);//конструктор

void RunSimulation();

//статические переменные используются для того, чтобы из значения, заданные в начале,

//были доступны элементам класса Mashina (когда создаётся элемент класса Mashina,

//то эти переменные не инициализируются, а используются значения, инициализированные

//при создании объекта класса Simulation в функции main)

int N; //количество итераций программы

static int **Pol; //номер полосы

static int *kolPol; //количество полос для движения
static int **countE; // [N][4] - хранит кличество машин, проехавших через перекрёсток, для каждой итерации

static int **srTimeOjOch; // [N][4] среднее время ожидания в пробке по каждому из 4-х направлений по каждой из N-ти итераций

static int **srTimeOjSv;

protected:

RandomNumber rnd;

static int TGlobal;

static int time; // длина моделируемого периода работы

static int *arrivalLow; //диапазон времени между приходами машин

static int *arrivalHigh;

static int *delayLow; //диапазон времени задержки машин на перекрёстке

static int *delayHigh;

static int TimeGreen; //время горения разрешающего сигнала светофора (в секундах)

static int TimeRed; //время горения запрещающего сигнала светофора (в секундах)

//данные-элементы для хранения результатов по всем 4-м направлениям

static int *countElem;

static int **ojOch; //время ожидания в очереди (т.е. в случае, когда при прибытии машины на перекрёсток, предыдущая машина ещё не покинула перекрёсток)

static int **ojSv; //время ожидания при запрещающем сигнале светофора

private:

int SrTimeOjOch(int h); //возвращает среднее время ожидания в пробке.

//В качестве аргумента функции передаётся номер направления

int SrTimeOjSv(int h); //возвращает среднее время ожидания на светофоре.
};
class Mashina : public Simulation{

public:

Mashina();

Mashina *pHead; // указатель на первый элемент списка

Mashina *pPrev; // указатель на последний элемент списка

Mashina *next; // указатели на следующий

Mashina *pred; //и на предыдущий элементы списка

void addToList(int tprib, int nPol, int napr, int iter); //функция добавки элемента в список

//tprib - время прибытия, nPol - номер полосы, napr - номер направления, iter - номер итерации

int KolOstMash(int); //в качестве параметра функции передаётся время пибытия очередной машины.

//Функция возвращает количество машин, время отбытия которых (Totb) больше, чем время прибытия очередной машины (tprib)

//(т.е. количество машин, ещё не уехавших с перекрёстка в момент прибытия очередной машины)

private:

int Tprib; //время прибытия

int TojPer; //время ожидания на перекрёстке

int TojOch; //время ожидания в очереди (т.е. в случае, когда при прибытии машины на перекрёсток, предыдущая машина ещё не покинула перекрёсток)

int TojSv; //время ожидания при запрещающем сигнале светофора

int Totb; //время отбытия с перекрёстка

};
//===================================================

//=====реализация класса Simulation==================

//===================================================
int Simulation::TGlobal = 0;

int Simulation::time = 0;

int *Simulation::kolPol = new int[4];

int *Simulation::countElem = new int[4];

int *Simulation::arrivalLow = new int[4];

int *Simulation::arrivalHigh = new int[4];

int *Simulation::delayLow = new int[4];

int *Simulation::delayHigh = new int[4];

int Simulation::TimeGreen = 0;

int Simulation::TimeRed = 0;
int **Simulation::Pol = new int* [4];

int **Simulation::ojOch = new int* [4];

int **Simulation::ojSv = new int* [4];
int **Simulation::srTimeOjOch = new int*() ;

int **Simulation::srTimeOjSv = new int*() ;

int **Simulation::countE = new int*() ;
//-----------------------------------------------------------------------------------

Simulation::Simulation()

{

}

Simulation::Simulation(int t, int *k, int *al, int *ah, int *dl, int *dh, int tg, int tr, int n)

{

int i,j, ii, jj;

N = n;

time = t;

TimeGreen = tg;

TimeRed = tr;

for (i=0; i<4; i++)

{

kolPol[i] = k[i];

arrivalLow[i] = al[i];

arrivalHigh[i] = ah[i];

delayLow[i] = dl[i];

delayHigh[i] = dh[i];

}
for (int i = 0; i < 4; i++)

{

Pol[i] = new int [1000];

ojOch[i] = new int [1000];

ojSv[i] = new int [1000];

}

srTimeOjOch = new int* [N] ;

srTimeOjSv = new int* [N] ;

countE = new int* [N] ;

for (int i = 0; i < N; i++)

{

srTimeOjOch[i] = new int [4];

srTimeOjSv[i] = new int [4];

countE[i] = new int [4];

}

}

//-----------------------------------------------------------------------

void Simulation::RunSimulation(){

Mashina *M;

for (int iter=0; iter
for (int j=0; j<4; j++) // моделирование по j-му направлению

{

M = new Mashina[kolPol[j]];

TGlobal = 0;

countElem[j]=0;

int tprib = rnd.Random(arrivalHigh[j] - arrivalLow[j] + 1) + arrivalLow[j] ;
while (tprib <= time*60)

{

//поиск списка с минимальным количеством не уехавших машин в очереди

int min = M->KolOstMash(tprib);

int min_i = 0;

for (int i = 0; i < kolPol[j]; i++)

if ((M+i)->KolOstMash(tprib) < min)

{

min = (M+i)->KolOstMash(tprib);

min_i = i;

}

(M + min_i)->addToList(tprib, min_i+1, j, iter);

tprib = TGlobal + rnd.Random(arrivalHigh[j] - arrivalLow[j] + 1) + arrivalLow[j] ;

}
countE[iter][j] = countElem[j]; //сбор статистики по каждой из итераций

srTimeOjOch[iter][j] = SrTimeOjOch(j);

srTimeOjSv[iter][j] = SrTimeOjSv(j);

}

return;

}
//среднее время ожидания в очереди по h-му направлению

int Simulation::SrTimeOjOch(int h)

{

int sum = 0, i;

int sr;

for (i = 0 ; i < countElem[h] ; i++)

sum = sum + ojOch[h][i];

sr = sum/countElem[h];
return sr;

}
int Simulation::SrTimeOjSv(int h)

{

int sum = 0, sr, i;

for (i = 0 ; i < countElem[h] ; i++)

sum = sum + ojSv[h][i];

sr = sum/countElem[h];

return sr;

}
//=============================================================================

//--------------------реализация класса Mashina--------------------------------

//=============================================================================
Mashina::Mashina(){

pHead = NULL;

pPrev = NULL;

}
//реализация функции добавления

void Mashina::addToList(int tprib, int nPol, int napr, int iter)

{

int i, j;

Mashina *temp = new Mashina; //создается временный элемент
if(pHead == NULL) //если это первый элемент, то

{

temp->pred = NULL; //обнуляем указатель на предшествующий элемент т.к. его нет

temp->next = NULL; //то же самое с последующим элементом

pHead = temp; //"голова" указывает на созданный элемент
temp->Tprib = tprib;
temp->TojPer = rnd.Random(delayHigh[napr] - delayLow[napr] + 1) + delayLow[napr];

temp->TojOch = 0; //Время ожидания в очереди равно 0, т.к. это первая машина

//расчёт времени ожидания на запрещающем сигнале светофора

int PeriodSv = temp->Tprib / (TimeGreen + TimeRed); //количество периодов смены сигнала светофора, произошедших к моменту прибытия машины

// Green,Red, Green,Red, Green,Red, ...

int Tpr = temp->Tprib - (TimeGreen + TimeRed)*PeriodSv; // время прибытия относительно последнего завершившегося полного периода смены сигнала светофора
if ((napr == 0) || (napr == 1))

{

if (Tpr <= TimeGreen) //если во время прибытия машины горел разрешающий сигнал светофора

temp->TojSv = 0;

else{ //иначе, если во время прибытия машины горел запрещающий сигнал светофора

int Tkr = Tpr - TimeGreen; // время, сколько уже горел запрещающий сигнал светофора к моменту прибытия машины

temp->TojSv = TimeRed - Tkr;

}

}

else

{

if (Tpr <= TimeGreen)

temp->TojSv = TimeGreen - Tpr;

else temp->TojSv = 0;

}

//конец рассчёта
temp->Totb = temp->Tprib + temp->TojPer + temp->TojSv;

}

else //если не первый, то

{

pPrev->next = temp; //предыдущий указывает на него

temp->Tprib = tprib;

temp->TojPer = rnd.Random(delayHigh[napr] - delayLow[napr] + 1) + delayLow[napr]; //время ожидания на перекрёстке
//рассчёт времени ожидания в очереди

if (pPrev->Totb > temp->Tprib ){ // если время отбытия предыдущей машины больше времени прибытия данной машины

//т.е. данная машина прибыла, а предыдущая ещё не отбыла, то

temp->TojOch = pPrev->Totb - temp->Tprib; //время ожидания в очереди

}

else

{

temp->TojOch = 0;

}

//расчёт времени ожидания на запрещающем сигнале светофора

int PeriodSv = (temp->Tprib + temp->TojOch) / (TimeGreen + TimeRed); //количество периодов смены сигнала светофора, произошедших к моменту прибытия машины

// Green,Red, Green,Red, Green,Red, ...

int Tpr = (temp->Tprib + temp->TojOch) - (TimeGreen + TimeRed)*PeriodSv; // время прибытия относительно последнего завершившегося полного периода смены сигнала светофора
if ((napr == 0) || (napr == 1))

{

if (Tpr <= TimeGreen) //если во время прибытия машины горел разрешающий сигнал светофора

temp->TojSv = 0;

else{ //иначе, если во время прибытия машины горел запрещающий сигнал светофора

int Tkr = Tpr - TimeGreen; // время, сколько уже горел запрещающий сигнал светофора к моменту прибытия машины

temp->TojSv = TimeRed - Tkr;

}

}

else

{

if (Tpr <= TimeGreen)

temp->TojSv = TimeGreen - Tpr;

else temp->TojSv = 0;

}

//конец рассчёта
temp->Totb = temp->Tprib + temp->TojPer + temp->TojOch + temp->TojSv; //время отбытия с перекрёстка

}
TGlobal = temp->Tprib;
Pol[napr][countElem[napr]] = nPol;

ojOch[napr][countElem[napr]] = temp->TojOch;

ojSv[napr][countElem[napr]] = temp->TojSv;
temp->next = NULL; //последующего элемента нет (добавляем же в конец)

temp->pred = pPrev; //указываем на предыдущий элемент, на который «нацелен» pPrev

pPrev = temp; //а теперь хвостовой элемент указывает на последний (добавленный)

countElem[napr]++; //увеличиваем счетчик элементов в списке

return;

}
int Mashina::KolOstMash(int tprib){

int k = 0;

Mashina *pTemp = pHead; //создается временный элемент

if (pHead) //если список не пуст, то

while(pTemp != NULL) //пока врем. элем. не будет указывать на хвост

{

if (pTemp->Totb > tprib) k++;

pTemp = pTemp->next; //и переходим на следующий за ним элем.

}

return k;

}

//Спецификация класса RandomNumber

//Класс RandomNumber – класс датчиков случайных чисел

# include

// эти числа используются для создания случайного числа

// из текущего seed-значения

const unsigned long maxshort = 65536L ;

const unsigned long multiplier = 1194211693L ;

const unsigned long adder = 12345L ;

class RandomNumber

{

private:

unsigned long randSeed; // текущее seed-значение

public:

RandomNumber () ; // конструктор

// функция, которая возвращает целое случайное число,

// равномерно распределенное в диапазоне [ 0, n -1 ]

unsigned short Random ( unsigned long n ) ;

} ;
RandomNumber :: RandomNumber ()

{

randSeed = time ( 0 ) ; // seed-значение, заданное

// посредством функции time ( )

}

unsigned short RandomNumber :: Random ( unsigned long n )

{

randSeed = multiplier * randSeed + adder ; // новое seed-значение

// возврат целого случайного числа в диапазоне [ 0, n -1 ]

return (unsigned short) ( (randSeed >> 16 ) % n ) ;

}

//Спецификация класса Form1

#pragma endregion

//запустить моделирование

private: System::Void button1_Click(System::Object^ sender, System::EventArgs^ e) {

int t, tg, tr, n;

int *k = new int[4];

int *al = new int[4];

int *ah = new int[4];

int *dl= new int[4];

int *dh = new int[4];

n = System::Convert::ToInt32(textBox9->Text);

t = System::Convert::ToInt32(textBox1->Text);

tg = System::Convert::ToInt32(textBox7->Text);

tr = System::Convert::ToInt32(textBox8->Text);
k[0] = System::Convert::ToInt32(textBox2->Text);

al[0] = System::Convert::ToInt32(textBox3->Text);

ah[0] = System::Convert::ToInt32(textBox4->Text);

dl[0] = System::Convert::ToInt32(textBox5->Text);

dh[0] = System::Convert::ToInt32(textBox6->Text);
k[1] = System::Convert::ToInt32(textBox14->Text);

al[1] = System::Convert::ToInt32(textBox13->Text);

ah[1] = System::Convert::ToInt32(textBox12->Text);

dl[1] = System::Convert::ToInt32(textBox11->Text);

dh[1] = System::Convert::ToInt32(textBox10->Text);
k[2] = System::Convert::ToInt32(textBox19->Text);

al[2] = System::Convert::ToInt32(textBox18->Text);

ah[2] = System::Convert::ToInt32(textBox17->Text);

dl[2] = System::Convert::ToInt32(textBox16->Text);

dh[2] = System::Convert::ToInt32(textBox15->Text);
k[3] = System::Convert::ToInt32(textBox24->Text);

al[3] = System::Convert::ToInt32(textBox23->Text);

ah[3] = System::Convert::ToInt32(textBox22->Text);

dl[3] = System::Convert::ToInt32(textBox21->Text);

dh[3] = System::Convert::ToInt32(textBox20->Text);
ofstream data("data.txt");

data<
data<
data<
data<
for (int i =0; i<4; i++)

{

data<
data<
data<
data<

data<
}

data.close();
Simulation S(t, k, al, ah, dl, dh, tg, tr, n);

S.RunSimulation();

label10->Visible = true;
for (int h=0; h<4; h++)

{

int i, j, sr=0, srsv=0, sum=0;
//рассчёт среднего количества машин, проехавших через переурёсток (за N итераций)

int kolmash[4];

for (i=0; i
sum += S.countE[i][h];

kolmash[h] = sum/S.N;

//расчёт среднего количества машин, проехавших по каждой полосе, максимум - 10 полос

int **kolMash = new int*[S.N]; //

for ( i = 0 ; i < S.N ; i++)

kolMash[i] = new int[10];

for ( i = 0 ; i < S.N ; i++)

for ( j = 1 ; j <= S.kolPol[h] ; j++)

kolMash[i][j] = 0;
for (int it=0; it
for (i = 0 ; i < S.countE[it][h] ; i++)

for (j = 1 ; j <= S.kolPol[h] ; j++)

if (S.Pol[h][i] == j) kolMash[it][j]++;

int summa[10];

for (i=0; i<10; i++)

summa[i]=0;
for (j = 1 ; j <= S.kolPol[h] ; j++)

for (int it=0; it
summa[j] = summa[j] + kolMash[it][j];
int kol[10];

for (i=0; i<10; i++)

kol[i]=0;
for (j = 1 ; j <= S.kolPol[h] ; j++)

kol[j] = summa[j]/S.N;
//рассчёт среднего времени ожидания в пробке (и на светофоре) за 10 итераций моделирования.

for (i=0; i
{

sr = sr + S.srTimeOjOch[i][h];

srsv = srsv + S.srTimeOjSv[i][h];

}

sr = sr/S.N;

srsv = srsv/S.N;

//

switch (h)

{

case 0: richTextBox1->Text =richTextBox1->Text+"Количество машин, проехавших через перекрёсток = " + kolmash[0] + "\r\n";break;

case 1: richTextBox2->Text =richTextBox2->Text+"Количество машин, проехавших через перекрёсток = " + kolmash[1] + "\r\n";break;

case 2: richTextBox3->Text =richTextBox3->Text+"Количество машин, проехавших через перекрёсток = " + kolmash[2] + "\r\n";break;

case 3: richTextBox4->Text =richTextBox4->Text+"Количество машин, проехавших через перекрёсток = " + kolmash[3] + "\r\n";break;

}
for ( i = 1 ; i <= S.kolPol[h] ; i++)

switch (h)

{

case 0: richTextBox1->Text = richTextBox1->Text + "по " + i + "-ой полосе : " + kol[i] + "\r\n";break;

case 1: richTextBox2->Text = richTextBox2->Text + "по " + i + "-ой полосе : " + kol[i] + "\r\n";break;

case 2: richTextBox3->Text = richTextBox3->Text + "по " + i + "-ой полосе : " + kol[i] + "\r\n";break;

case 3: richTextBox4->Text = richTextBox4->Text + "по " + i + "-ой полосе : " + kol[i] + "\r\n";break;

}
switch (h)

{

case 0: richTextBox1->Text=richTextBox1->Text+"\r\n";break;

case 1: richTextBox2->Text=richTextBox2->Text+"\r\n";break;

case 2: richTextBox3->Text=richTextBox3->Text+"\r\n";break;

case 3: richTextBox4->Text=richTextBox4->Text+"\r\n";break;

}
if (sr < 60)

switch (h)

{

case 0: richTextBox1->Text= richTextBox1->Text+"Среднее время ожидания в пробке = " + sr +" сек\r\n";break;

case 1: richTextBox2->Text= richTextBox2->Text+"Среднее время ожидания в пробке = " + sr +" сек\r\n";break;

case 2: richTextBox3->Text= richTextBox3->Text+"Среднее время ожидания в пробке = " + sr +" сек\r\n";break;

case 3: richTextBox4->Text= richTextBox4->Text+"Среднее время ожидания в пробке = " + sr +" сек\r\n";break;

}

if ((sr >=60) && (sr <3600)){

int min = sr/60;

int sec = sr - min*60;

switch (h)

{

case 0: richTextBox1->Text =richTextBox1->Text+"Среднее время ожидания в пробке = " + min +" мин "+ sec + " сек\r\n";break;

case 1: richTextBox2->Text =richTextBox2->Text+"Среднее время ожидания в пробке = " + min +" мин "+ sec + " сек\r\n";break;

case 2: richTextBox3->Text =richTextBox3->Text+"Среднее время ожидания в пробке = " + min +" мин "+ sec + " сек\r\n";break;

case 3: richTextBox4->Text =richTextBox4->Text+"Среднее время ожидания в пробке = " + min +" мин "+ sec + " сек\r\n";break;

}

}

if (sr >= 3600){

int chas = sr/3600;

int min = (sr - chas*3600)/60;

int sec = sr - chas*3600 - min*60;

switch (h)

{

case 0: richTextBox1->Text= "Среднее время ожидания в пробке = " +chas+" ч "+ min +" мин "+ sec + " сек\r\n";break;

case 1: richTextBox2->Text= "Среднее время ожидания в пробке = " +chas+" ч "+ min +" мин "+ sec + " сек\r\n";break;

case 2: richTextBox3->Text= "Среднее время ожидания в пробке = " +chas+" ч "+ min +" мин "+ sec + " сек\r\n";break;

case 3: richTextBox4->Text= "Среднее время ожидания в пробке = " +chas+" ч "+ min +" мин "+ sec + " сек\r\n";break;

}

}


if (srsv < 60)

switch (h)

{

case 0: richTextBox1->Text= richTextBox1->Text+"Среднее время ожидания на светофоре = " + srsv +" сек\r\n";break;

case 1: richTextBox2->Text= richTextBox2->Text+"Среднее время ожидания на светофоре = " + srsv +" сек\r\n";break;

case 2: richTextBox3->Text= richTextBox3->Text+"Среднее время ожидания на светофоре = " + srsv +" сек\r\n";break;

case 3: richTextBox4->Text= richTextBox4->Text+"Среднее время ожидания на светофоре = " + srsv +" сек\r\n";break;

}

if ((srsv >=60) && (srsv <3600)){

int min = srsv/60;

int sec = srsv - min*60;

switch (h)

{

case 0: richTextBox1->Text =richTextBox1->Text+"Среднее время ожидания на светофоре = " + min +" мин "+ sec + " сек\r\n";break;

case 1: richTextBox2->Text =richTextBox2->Text+"Среднее время ожидания на светофоре = " + min +" мин "+ sec + " сек\r\n";break;

case 2: richTextBox3->Text =richTextBox3->Text+"Среднее время ожидания на светофоре = " + min +" мин "+ sec + " сек\r\n";break;

case 3: richTextBox4->Text =richTextBox4->Text+"Среднее время ожидания на светофоре = " + min +" мин "+ sec + " сек\r\n";break;

}

}

if (srsv >= 3600){

int chas = srsv/3600;

int min = (srsv - chas*3600)/60;

int sec = srsv - chas*3600 - min*60;

switch (h)

{

case 0: richTextBox1->Text= richTextBox1->Text+"Среднее время ожидания на светофоре = " +chas+" ч "+ min +" мин "+ sec + " сек\r\n";break;

case 1: richTextBox2->Text= richTextBox2->Text+"Среднее время ожидания на светофоре = " +chas+" ч "+ min +" мин "+ sec + " сек\r\n";break;

case 2: richTextBox3->Text= richTextBox3->Text+"Среднее время ожидания на светофоре = " +chas+" ч "+ min +" мин "+ sec + " сек\r\n";break;

case 3: richTextBox4->Text= richTextBox4->Text+"Среднее время ожидания на светофоре = " +chas+" ч "+ min +" мин "+ sec + " сек\r\n";break;

}

}

switch (h)

{

case 0: richTextBox1->Text=richTextBox1->Text+"\r\n";break;

case 1: richTextBox2->Text=richTextBox2->Text+"\r\n";break;

case 2: richTextBox3->Text=richTextBox3->Text+"\r\n";break;

case 3: richTextBox4->Text=richTextBox4->Text+"\r\n";break;

}

}

}

//

private: System::Void Form1_Load(System::Object^ sender, System::EventArgs^ e) {

int t, tg, tr, n;

int *k = new int[4];

int *al = new int[4];

int *ah = new int[4];

int *dl= new int[4];

int *dh = new int[4];
ifstream data("data.txt");

if (data)

{

data>>n>>t>>tg>>tr;

for (int i=0; i<4; i++)

data>>k[i]>>al[i]>>ah[i]>>dl[i]>>dh[i];

textBox9->Text = System::Convert::ToString(n);

textBox1->Text = System::Convert::ToString(t);

textBox2->Text = System::Convert::ToString(k[0]);

textBox3->Text = System::Convert::ToString(al[0]);

textBox4->Text = System::Convert::ToString(ah[0]);

textBox5->Text = System::Convert::ToString(dl[0]);

textBox6->Text = System::Convert::ToString(dh[0]);

textBox7->Text = System::Convert::ToString(tg);

textBox8->Text = System::Convert::ToString(tr);

textBox14->Text = System::Convert::ToString(k[1]);

textBox13->Text = System::Convert::ToString(al[1]);

textBox12->Text = System::Convert::ToString(ah[1]);

textBox11->Text = System::Convert::ToString(dl[1]);

textBox10->Text = System::Convert::ToString(dh[1]);
textBox19->Text = System::Convert::ToString(k[2]);

textBox18->Text = System::Convert::ToString(al[2]);

textBox17->Text = System::Convert::ToString(ah[2]);

textBox16->Text = System::Convert::ToString(dl[2]);

textBox15->Text = System::Convert::ToString(dh[2]);
textBox24->Text = System::Convert::ToString(k[3]);

textBox23->Text = System::Convert::ToString(al[3]);

textBox22->Text = System::Convert::ToString(ah[3]);

textBox21->Text = System::Convert::ToString(dl[3]);

textBox20->Text = System::Convert::ToString(dh[3]);

}

data.close();

}

private: System::Void label7_Click(System::Object^ sender, System::EventArgs^ e) {

}

private: System::Void label30_Click(System::Object^ sender, System::EventArgs^ e) {

}

private: System::Void label2_Click(System::Object^ sender, System::EventArgs^ e) {

}

private: System::Void textBox2_TextChanged(System::Object^ sender, System::EventArgs^ e) {

}

private: System::Void pictureBox2_Click(System::Object^ sender, System::EventArgs^ e) {

}
//очистить экран

private: System::Void button2_Click(System::Object^ sender, System::EventArgs^ e) {

richTextBox1->Text ="";

richTextBox2->Text="";

richTextBox3->Text="";

richTextBox4->Text="";

}

};

}

---