ООп курсовая. Курсовая работа по дисциплине Объектноориентированное программирование
 Скачать 0.53 Mb.
|
| |||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| Студент гр. 6363 | | Листратенко В. В. |
| Преподаватель | | Егоров С.С. |
Санкт-Петербург
2019
ЗАДАНИЕ
на курсовую работу
| Студент Листратенко В.В. | ||
| Группа 6363 | ||
| Исходные данные: В задании описана некоторая предметная область (ПрО), все процессы в которой развиваются во времени. Следует разработать программу в объектно-ориентированной парадигме, которая смоделирует на задаваемом пользователем интервале времени Т в ускоренном режиме с масштабом времени 1:М (1 ед. времени работы программы соответствует М ед. времени функционирования моделируемой ПрО) ее жизненный цикл. Требуется: Провести анализ заданной ПрО, Разработать класс «МОДЕЛЬ», описывающий основной субъект задания (АЗС, Парикмахерская, Завод и т. п.) и интегрирующий выделенные детализирующие его классы предметов и понятий. Задать отношения между классами ПрО и отразить их в протоколах классах, Специфицировать существенные с точки зрения решаемой задачи свойства (поля) объектов выделенных классов ПрО, Специфицировать методы классов ПрО, позволяющие организовать процесс моделирования во времени жизненного цикла объектов ПрО, При необходимости использовать в ОМ про конструкторские классы, предоставляемые выбранной объектной библиотекой. Для подсистемы «Интерфейс» использовать конструкторские классы, предоставляемые выбранной объектной библиотекой. Общий интерфейс программы должен включать меню команд, позволяющих в произвольные моменты работы программы: вызывать окно, для просмотра и корректировки заданных параметров ПрО, вызывать окно отображения (в мнемонической, текстовой или графической форме) динамики изменения состояний объектов ПрО, запускать/останавливать работу подсистемы «Модель», а также устанавливать время моделирования Т, в том числе неограниченное, и масштаб времени М моделирования. Задание 6 Технические устройства (ТУ) в количестве 3 ед. могут время от времени выходить из строя (отказывают). Поток отказов для каждого ТУ имеет интенсивность равную Z отказов в сутки. Время восстановления ТУ имеет экспоненциальное распределение. Математическое ожидание времени обслуживания - R суток. Количество каналов, выполняющих обслуживание ТУ, равно 2 ед. Количество заявок в очереди ограничено значением 2. Статистика: Время восстановления ТУ. | ||
| Содержание пояснительной записки: «Содержание», «Введение», «Заключение», «Описание работы программы», «Диаграмма классов», «Код программы», «Интерфейс программы», «Список использованных источников». | ||
| Предполагаемый объем пояснительной записки: Не менее 50 страниц. | ||
| Дата выдачи задания: 15.03.2019 | ||
| Дата сдачи реферата: 16.05.2019 | ||
| Дата защиты реферата: 16.05.2018 | ||
| Студент | | Листратенко В. В. |
| Преподаватель | | Егоров С.С. |
Аннотация
Проект, состоящий из двух программ, одна из которых представляет собой сервер, обрабатывающий запросы клиента, другая – собственно, клиент, представляющая собой графический интерфейс, в котором можно настроить начальные данные для работы с программой. Весь процесс просчитывается сервером, а клиенту отправляются результаты работы через UDP-сокет.
Summary
The project consists of two programs – server and client. Server processes client’s requests. Client is a GUI application that initializes data for work with program. Whole process is computed by server and result is sent through UDP-socket.
содержание
| | Введение | 6 |
| 1. | Описание работы программы | 7 |
| 2. | Диаграмма классов | 10 |
| 3. 3.1. 3.2. | Код программы Заголовочные файлы Исходники | 12 12 22 |
| 4. | Интерфейс программы | 49 |
| | Заключение | 50 |
| | Список использованных источников | 51 |
введение
Необходимо смоделировать цикл работы трех технических устройств, которые с установленной вероятностью могут выходить из строя. Вероятность и математическое ожидание срока ремонта устанавливает пользователь.
1. ОПИСАНИЕ РАБОТЫ ПРОГРАММЫ
Модель имеет следующую структуру классов:
TApplication – класс приложения. Описаны методы:
Запуск основного цикла;
Обработчик сообщений, пришедших в сокет.
Данный класс является фундаментом. Он связывает классы устройств, статистики и сокета. Так же в нем происходит главный цикл, в котором определяется, сломается ли устройство; при поломке, добавление этого устройства в очередь и присвоение ему соответствующего состояния, вычисление времени ремонта. А так же вызов методов класса статистики для сбора данных. Далее в цикле обрабатывается очередь устройств. Если время их ремонта закончилось, то они возвращаются в строй, иначе это время декрементируется. Далее происходит отправка состояний устройств и текущей статистики клиенту через сокет.
Technical – класс технических устройств. Описаны методы:
Установить и вернуть идентификатор;
Установить и вернуть состояние;
Установить и вернуть время восстановления;
Установить и вернуть вероятность поломки;
Установить и вернуть мат. ожидание времени восстановления.
Этот класс реализует модель технического устройства. У него есть идентификатор, состояния (активное, в очереди, в ремонте) и время до восстановления. А так же вероятность поломки и мат. ожидание времени восстановления.
Statistic – класс, собирающий статистику. Описаны методы:
Увеличить главный счетчик;
Увеличить главную сумму;
Посчитать мат. ожидание;
Увеличить счетчик отклонения;
Увеличить сумму отклонения;
Вернуть главный счетчик, главную сумму, мат. ожидание и отклонение.
Класс собирает информацию и считает математическое ожидание и среднеквадратичное отклонение.
TNetSocket – класс, реализующий обертку над UDP сокетом. Описаны методы:
Прием и отправку датаграммы.
Для отправки сообщений используется слот, принимающий массив данных либо строку. Слот приема сообщений испускает сигнал о прочитанном сообщении и передавая его в качестве параметра в виде массива данных.
Клиент имеет следующую структуру классов:
TApplication – класс приложения.
Данный класс является фундаментом. Он связывает классы интерфейса и сокета.asd
TInterface – класс, реализующий пользовательский интерфейс. Описаны методы:
Прием данных для инициализации от класс Init
Подготовку данных для отправки для инициализации, старта, паузы и остановки.
Класс представляет собой набор виджетов, составленных в графическом окне. При запуске клиента появляется небольшое окно, которое предлагает установить данные для инициализации технических устройств. Это объект класса Init. После нажатия на кнопку «Создать» это окно закрывается, и появляется основное окно. В нем присутствуют две области для вывода текста: левая для состояний и правая для статистики. Также имеются кнопки «Старт», «Пауза» и «Стоп».
TInit – класс, реализующий окно инициализации. Описаны методы:
Подготовить данные для отправки в главное окно.
Класс имеет два счетчика: для установки вероятности поломки ТУ и для мат. ожидания времени его ремонта.
TNetSocket – класс, реализующий обертку над UDP сокетом.
Идентичен классу, описанному в разделе для модели.
2. Диаграмма классов
Модель:
Клиент:
3. КОД ПРОГРАММЫ
3.1. ЗАГОЛОВОЧНЫЕ ФАЙЛЫ
Модель:
tapplication.h
#ifndef TAPPL_H
#define TAPPL_H
#include
#include
#include
#include
#include "tnetsocket.h"
#include "technical.h"
#include "statistic.h"
enum EActions
{
SET_INIT_DATA,
START,
PAUSE,
STOP
};
class TApplication : public QCoreApplication
{
private:
Q_OBJECT
TNetSocket *_socket;
QQueue
QMap
QMap
bool _fContinue;
QString _dataToSend;
public:
TApplication(int, char**);
public slots:
void slotSocketHandler(QByteArray&);
void slotRun();
signals:
void sigRun();
void sigDataToSend(const QString&);
void sigQuit();
};
#endif
technical.h
#ifndef TECHNICAL_H
#define TECHNICAL_H
#include
class Technical
{
public:
enum class States{
ACTIVE,
IN_QUEUE,
REPAIR
};
private:
quint8 _id;
States _state;
quint32 _timeToRepair;
static qreal _probability;
static quint32 _servTime;
public:
Technical();
quint8 id();
void setId(quint8);
States state() const;
void setState(Technical::States);
quint32 timeToRepair() const;
void setTimeToRepair(quint32);
void decTimeToRepair();
static qreal probability();
static void setProbability(qreal);
static quint32 servTime();
static void setServTime(quint32);
};
#endif // TECHNICAL_H
statistic.h
#ifndef STATISTIC_H
#define STATISTIC_H
#include
#include
class Statistic
{
quint32 _sum;
quint32 _counter;
quint32 _counterDeviation;
quint32 _sumDeviation;
quint32 _randomValue;
qreal _expectedValue;
public:
Statistic();
void incCount();
void summate(quint32);
void incSum();
void calculate();
void incDeviation();
void sumDeviation(quint32);
quint32 sum() const;
quint32 counter() const;
qreal deviation() const;
qreal expectedValue() const;
};
QTextStream& operator<<(QTextStream&, const Statistic&);
#endif // STATISTIC_H
tnetsocket.h
#ifndef TNETSOCKET_H
#define TNETSOCKET_H
#include
#include
struct TNetParams
{
QHostAddress host;
quint16 port;
QHostAddress peerHost;
quint16 peerPort;
};
class TNetSocket : public QObject
{
Q_OBJECT
QUdpSocket *_socket;
TNetParams _params;
public slots:
void readPendingDatagram();
void slotSend(const QByteArray&);
void slotSend(const QString&);
signals:
void sigRead(QByteArray&);
public:
TNetSocket(const TNetParams&);
virtual TNetSocket();
bool dataExist();
};
#endif // TNETSOCKET_H
Клиент:
tapplication.h
#ifndef APPLICATION_H
#define APPLICATION_H
#include
#include "tnetsocket.h"
#include "tinterface.h"
class TApplication : public QApplication
{
Q_OBJECT
TNetSocket *_socket;
TInterface *_interface;
public:
TApplication(int, char**);
};
#endif // APPLICATION_H
tinterface.h
#ifndef TINTERFACE_H
#define TINTERFACE_H
#include
#include
#include
#include
#include
#include
#include "tinit.h"
enum EActions
{
SET_INIT_DATA,
START,
PAUSE,
STOP
};
class TInterface : public QWidget
{
Q_OBJECT
TInit *_init;
QLabel *_labMessages, *_labStatistic;
QTextEdit *_txtMssages, *_txtStatistic;
QPushButton *_btnStart, *_btnPause, *_btnStop;
QVBoxLayout *_layLeft, *_layRight, *_layMainV;
QHBoxLayout *_layMainH, *_layButtons;
public:
TInterface(QWidget *parent = nullptr);
TInterface();
public slots:
void slotSetInitValues(qreal, quint32);
void slotStart();
void slotPause();
void slotStop();
void slotSetText(QByteArray&);
signals:
void sigInitDataReady(const QByteArray&);
void sigStart(const QByteArray&);
void sigPause(const QByteArray&);
void sigStop(const QByteArray&);
};
#endif // TINTERFACE_H
tinit.h
#ifndef TINIT_H
#define TINIT_H
#include
#include
#include
#include
#include
class TInit : public QWidget
{
Q_OBJECT
QLabel *_labProbability, *_labServTime;
QDoubleSpinBox *_spinProbability;
QSpinBox *_spinServTime;
QPushButton *_btnCreate;
QVBoxLayout *_layLeft, *_layRight, *_layMain;
QHBoxLayout *_layH;
public:
TInit();
public slots:
void slotGetInitValues();
signals:
void sigSetInitValues(qreal, quint32);
};
#endif // TINIT_H
tnetsocket.h
#ifndef TNETSOCKET_H
#define TNETSOCKET_H
#include
#include
struct TNetParams
{
QHostAddress host;
quint16 port;
QHostAddress peerHost;
quint16 peerPort;
};
class TNetSocket : public QObject
{
Q_OBJECT
QUdpSocket *_socket;
TNetParams _params;
public:
TNetSocket(const TNetParams&);
virtual TNetSocket();
public slots:
void readPendingDatagram();
void slotSend(const QByteArray&);
signals:
void sigRead(QByteArray&);
};
#endif // TNETSOCKET_H
3.2. ИСХОДНИКИ
Модель:
main.cpp
#include "tapplication.h"
int main(int argc, char **argv)
{
TApplication app(argc, argv);
return app.exec();
}
tapplication.cpp
#include
#include
#include
#include
#include
#include
#include "tapplication.h"
qreal Technical::_probability;
quint32 Technical::_servTime;
TApplication::TApplication(int argc, char **argv) :
QCoreApplication(argc, argv),
_fContinue(false)
{
TNetParams params = { QHostAddress("127.0.0.1"), 10000,
QHostAddress("127.0.0.1"), 10001 };
_socket = new TNetSocket(params);
connect(_socket, SIGNAL(sigRead(QByteArray&)), SLOT(slotSocketHandler(QByteArray&)));
connect(this, SIGNAL(sigRun()), SLOT(slotRun()));
connect(this, SIGNAL(sigDataToSend(const QString&)), _socket, SLOT(slotSend(const QString&)));
connect(this, SIGNAL(sigQuit()), SLOT(quit()));
}
void TApplication::slotRun()
{
QTextStream out(&_dataToSend, QIODevice::WriteOnly);
// generate ids
for (int i = 0; i < 3; ++i) {
quint8 tmp = static_cast
if (_tech.contains(tmp)){
--i;
continue;
}else{
_tech[tmp] = Technical();
_tech[tmp].setId(tmp);
_statistic[tmp] = Statistic();
}
}
// main loop
int days = 1;
do
{
if (_fContinue)
{
system("cls");
out << "
Day " << days++ << "
";for (auto it : _tech) {
out << "
style=\"font-size: 18px\">Tech " << it.id() << " state: "
<< (it.state() == Technical::States::ACTIVE ? "active" :
(it.state() == Technical::States::IN_QUEUE ? "in queue"
: "repair")) << "
";
if (it.state() != Technical::States::ACTIVE){
out << "time to repair: " << it.timeToRepair() << "
";
}
}
out << "
";
// randomize probability and set state
for (auto it = _tech.begin(); it != _tech.end(); ++it)
{
if (it.value().state() == Technical::States::ACTIVE)
{
quint8 probability = static_cast
(QRandomGenerator::global()->generate()) % 101;
if (probability <= Technical::probability() * 100)
{
out << "tech " << it.value().id() << " has broken" << "
";
it.value().setState(Technical::States::IN_QUEUE);
it.value().setTimeToRepair(QRandomGenerator::global()->generate() %
(2 * Technical::servTime() + 1));
_queue.enqueue(it.value().id());
out << "Time to repair " << it.value().timeToRepair() << "
";
// statistic. count of breaking and days to repair
_statistic[it.value().id()].incCount();
_statistic[it.value().id()].incDeviation();
_statistic[it.value().id()].sumDeviation(it.value().timeToRepair());
}
}
}
// take tech from queue
if (!_queue.isEmpty())
{
// work with first in the queue
quint8 first = _queue.head();
if (_tech[first].state() == Technical::States::IN_QUEUE)
{
_tech[first].setState(Technical::States::REPAIR);
}
if (_tech[first].state() == Technical::States::REPAIR)
{
if (_tech[first].timeToRepair() == 0)
{
_tech[first].setState(Technical::States::ACTIVE);
_statistic[first].calculate();
out << "Tech " << _tech[first].id() << " is active" << "
";
_queue.dequeue();
// set next to the queue
if (!_queue.isEmpty()){
first = _queue.head();
_tech[first].setState(Technical::States::REPAIR);
}
}else{
_tech[first].decTimeToRepair();
}
}
// increment staticsic at every tech in queue
for (auto it : _queue){
_statistic[it].incSum();
}
}
out << "
";
qDebug() << "datatosend states:" << _dataToSend;
// send states of tech in _dataToSend
emit sigDataToSend(_dataToSend);
// clean _dataToSend
_dataToSend.clear();
// print statistic
out << "
style=\"font-size: 18px\">";
for (auto it = _statistic.begin(); it != _statistic.end(); ++it)
{
out << "Tech " << it.key() << ":
" << it.value() << "
";
}
out << "
";
qDebug() << "datatosend statistic:" << _dataToSend;
// send statistic of tech in _dataToSend
emit sigDataToSend(_dataToSend);
// clean _dataToSend
_dataToSend.clear();
}
_socket->dataExist();
QThread::sleep(1);
} while (true);
}
void TApplication::slotSocketHandler(QByteArray& datagram)
{
QDataStream in(&datagram, QIODevice::ReadOnly);
in.setVersion(QDataStream::Qt_5_12);
int action;
in >> action;
if (action == EActions::SET_INIT_DATA)
{
qreal probability;
in >> probability;
Technical::setProbability(probability);
quint32 servTime;
in >> servTime;
Technical::setServTime(servTime);
emit sigRun();
return;
}
if (action == EActions::START){
_fContinue = true;
return;
}
if (action == EActions::PAUSE){
_fContinue = false;
return;
}
if (action == EActions::STOP){
system("pause");
emit sigQuit();
}
}
technical.cpp
#include "technical.h"
Technical::Technical() :
_state(),
_timeToRepair()
{}
quint8 Technical::id()
{
return _id;
}
void Technical::setId(quint8 id)
{
_id = id;
}
Technical::States Technical::state() const
{
return _state;
}
void Technical::setState(Technical::States state)
{
_state = state;
}
quint32 Technical::timeToRepair() const
{
return _timeToRepair;
}
void Technical::setTimeToRepair(quint32 time)
{
_timeToRepair = time;
}
void Technical::decTimeToRepair()
{
--_timeToRepair;
}
qreal Technical::probability()
{
return _probability;
}
void Technical::setProbability(qreal probability)
{
_probability = probability;
}
quint32 Technical::servTime()
{
return _servTime;
}
void Technical::setServTime(quint32 servTime)
{
_servTime = servTime;
}
statistic.cpp
#include
#include "statistic.h"
Statistic::Statistic() :
_sum(0),
_counter(0),
_randomValue(0),
_expectedValue(0.0)
{}
void Statistic::incCount()
{
++_counter;
}
void Statistic::summate(quint32 addend)
{
_sum += addend;
}
void Statistic::incSum()
{
++_sum;
}
void Statistic::calculate()
{
_expectedValue = static_cast
static_cast
}
void Statistic::incDeviation()
{
++_counterDeviation;
}
void Statistic::sumDeviation(quint32 newValue)
{
_sumDeviation += pow(newValue - _expectedValue, 2);
}
quint32 Statistic::sum() const
{
return _sum;
}
quint32 Statistic::counter() const
{
return _counter;
}
qreal Statistic::deviation() const
{
return sqrt(_sumDeviation / _counterDeviation);
}
qreal Statistic::expectedValue() const
{
return _expectedValue;
}
QTextStream& operator<<(QTextStream& out, const Statistic& stat)
{
out << "couter: " <
<< "sum: " << stat.sum() << "
"
<< "expected: " << stat.expectedValue() << "
"
<< "deviation: " << sqrt(stat.deviation()) << "
";
return out;
}
tnetsocket.cpp
#include
#include
#include "tnetsocket.h"
TNetSocket::TNetSocket(const TNetParams& params) :
_socket(new QUdpSocket(this)),
_params(params)
{
if (!_socket->bind(_params.host, _params.port,
QAbstractSocket::ShareAddress | QAbstractSocket::ReuseAddressHint)){
qDebug() << "bind error" << endl;
exit(-1);
}
connect(_socket, SIGNAL(readyRead()), this, SLOT(readPendingDatagram()));
}
TNetSocket::TNetSocket(){}
void TNetSocket::readPendingDatagram()
{
QByteArray datagram;
do {
datagram.resize(static_cast
_socket->readDatagram(datagram.data(), datagram.size());
} while (_socket->hasPendingDatagrams());
emit sigRead(datagram);
}
void TNetSocket::slotSend(const QByteArray& message)
{
_socket->writeDatagram(message, _params.peerHost, _params.peerPort);
}
void TNetSocket::slotSend(const QString& message)
{
QByteArray data;
QDataStream out(&data, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_5_12);
out << message;
_socket->writeDatagram(data, _params.peerHost, _params.peerPort);
}
bool TNetSocket::dataExist()
{
if (_socket->hasPendingDatagrams()){
emit _socket->readyRead();
return true;
}
return false;
}
Клиент:
main.cpp
#include
#include "tapplication.h"
int main(int argc, char** argv)
{
TApplication app(argc, argv);
return app.exec();
}
tapplication.cpp
#include "tapplication.h"
TApplication::TApplication(int argc, char** argv) :
QApplication (argc, argv),
_interface(new TInterface)
{
TNetParams params = { QHostAddress("127.0.0.1"), 10001,
QHostAddress("127.0.0.1"), 10000 };
_socket = new TNetSocket(params);
connect(_interface, SIGNAL(sigInitDataReady(const QByteArray&)),
_socket, SLOT(slotSend(const QByteArray&)));
connect(_interface, SIGNAL(sigStart(const QByteArray&)),
_socket, SLOT(slotSend(const QByteArray&)));
connect(_interface, SIGNAL(sigPause(const QByteArray&)),
_socket, SLOT(slotSend(const QByteArray&)));
connect(_interface, SIGNAL(sigStop(const QByteArray&)),
_socket, SLOT(slotSend(const QByteArray&)));
connect(_socket, SIGNAL(sigRead(QByteArray&)),
_interface, SLOT(slotSetText(QByteArray&)));
}
tinterface.cpp
#include
#include "tinterface.h"
#include "tnetsocket.h"
#ifdef TINTERFACE_H
TInterface::TInterface(QWidget *parent) :
QWidget(parent),
_init(new TInit)
{
_init->setWindowTitle("Initialization");
_init->show();
_labMessages = new QLabel("
States
");_labStatistic = new QLabel("
Statistic
");_txtMssages = new QTextEdit;
_txtMssages->setReadOnly(true);
_txtStatistic = new QTextEdit;
_txtStatistic->setReadOnly(true);
_btnStart = new QPushButton;
_btnStart->setIcon(QIcon("D:/prog/3_curs_oop_labs/course/client/interface/icons/start.ico"));
_btnStart->setFixedSize(32, 32);
_btnPause = new QPushButton;
_btnPause->setIcon(QIcon("D:/prog/3_curs_oop_labs/course/client/interface/icons/pause.ico"));
_btnPause->setFixedSize(32, 32);
_btnStop = new QPushButton;
_btnStop->setIcon(QIcon("D:/prog/3_curs_oop_labs/course/client/interface/icons/stop.ico"));
_btnStop->setFixedSize(32, 32);
_layLeft = new QVBoxLayout;
_layLeft->addWidget(_labMessages);
_layLeft->addWidget(_txtMssages);
_layRight = new QVBoxLayout;
_layRight->addWidget(_labStatistic);
_layRight->addWidget(_txtStatistic);
_layMainH = new QHBoxLayout;
_layMainH->addLayout(_layLeft);
_layMainH->addLayout(_layRight);
_layButtons = new QHBoxLayout;
_layButtons->addWidget(_btnStart, 5, Qt::AlignRight);
_layButtons->addWidget(_btnPause, 1, Qt::AlignCenter);
_layButtons->addWidget(_btnStop, 5, Qt::AlignLeft);
_layMainV = new QVBoxLayout;
_layMainV->addLayout(_layMainH);
_layMainV->addLayout(_layButtons);
setLayout(_layMainV);
resize(600, 550);
connect(_init, SIGNAL(sigSetInitValues(qreal, quint32)),
SLOT(slotSetInitValues(qreal, quint32)));
connect(_btnStart, SIGNAL(clicked()), SLOT(slotStart()));
connect(_btnPause, SIGNAL(clicked()), SLOT(slotPause()));
connect(_btnStop, SIGNAL(clicked()), SLOT(slotStop()));
}
TInterface::TInterface(){}
void TInterface::slotSetInitValues(qreal probability, quint32 servTime)
{
_init->hide();
this->show();
QByteArray buffer;
QDataStream out(&buffer, QIODevice::Append);
out.setVersion(QDataStream::Qt_5_12);
out << EActions::SET_INIT_DATA << probability << servTime;
emit sigInitDataReady(buffer);
}
void TInterface::slotStart()
{
QByteArray buffer;
QDataStream out(&buffer, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_5_12);
out << EActions::START;
emit sigStart(buffer);
}
void TInterface::slotPause()
{
QByteArray buffer;
QDataStream out(&buffer, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_5_12);
out << EActions::PAUSE;
emit sigPause(buffer);
}
void TInterface::slotStop()
{
QByteArray buffer;
QDataStream out(&buffer, QIODevice::WriteOnly);
out.setVersion(QDataStream::Qt_5_12);
out << EActions::STOP;
emit sigStop(buffer);
exit(0);
}
void TInterface::slotSetText(QByteArray& data)
{
QDataStream out(&data, QIODevice::ReadOnly);
out.setVersion(QDataStream::Qt_5_12);
QString buffer;
out >> buffer;
if (buffer.contains("Day"))
{
_txtMssages->setHtml(buffer);
}else{
_txtStatistic->setHtml(buffer);
}
}
#endif
tinit.cpp
#include "tinit.h"
TInit::TInit()
{
_labServTime = new QLabel("Service time");
_labProbability = new QLabel("Probability");
_spinServTime = new QSpinBox;
_spinServTime->setValue(2);
_spinProbability = new QDoubleSpinBox;
_spinProbability->setValue(0.5);
_spinProbability->setRange(0, 1);
_btnCreate = new QPushButton("Create");
_layLeft = new QVBoxLayout;
_layLeft->addWidget(_labProbability);
_layLeft->addWidget(_spinProbability);
_layRight = new QVBoxLayout;
_layRight->addWidget(_labServTime);
_layRight->addWidget(_spinServTime);
_layH = new QHBoxLayout;
_layH->addLayout(_layLeft);
_layH->addLayout(_layRight);
_layMain = new QVBoxLayout;
_layMain->addLayout(_layH);
_layMain->addWidget(_btnCreate);
setLayout(_layMain);
setFixedSize(300, 120);
connect(_btnCreate, SIGNAL(clicked()), SLOT(slotGetInitValues()));
}
void TInit::slotGetInitValues()
{
emit sigSetInitValues(_spinProbability->value(), static_cast
}
tnetsocket.cpp
#include
#include
#include "tnetsocket.h"
TNetSocket::TNetSocket(const TNetParams& params) :
_socket(new QUdpSocket(this)),
_params(params)
{
if (!_socket->bind(_params.host, _params.port, QAbstractSocket::ReuseAddressHint)){
qDebug() << "bind error" << endl;
exit(-1);
}
connect(_socket, SIGNAL(readyRead()), this, SLOT(readPendingDatagram()));
}
TNetSocket::TNetSocket(){}
void TNetSocket::readPendingDatagram()
{
QByteArray datagram;
do {
datagram.resize(static_cast
_socket->readDatagram(datagram.data(), datagram.size());
} while (_socket->hasPendingDatagrams());
emit sigRead(datagram);
}
void TNetSocket::slotSend(const QByteArray& message)
{
_socket->writeDatagram(message, _params.peerHost, _params.peerPort);
}
4. Интерфейс программы
При запуске первым появляется окно инициализации. Оно имеет два поля для установки значения и кнопку, после нажатия на которую произойдет установка значений, закрытие этого окна и появление основного окна.
В основном окне есть два поля, куда выводятся сообщения, пришедшие от сервера. Ниже этих полей расположены кнопки управления процессом.
заключение
Представленная программа удовлетворяет техническому заданию. В ней реализованы все необходимые функции. Проанализировав результаты работы программы, можно отметить, что среднее время ожидания превышает заданное в 3.5 раза. Это происходит из-за того, что в очереди могут находиться другие устройства.
список использованных источников
Егоров С.С. Методические указания к выполнению курсовой работы по курсу «Объектно-ориентированное программирование». 24 с.
Шлее М. Qt 5.10. Профессиональное программирование на С++. - СПб.: БХВ-Петербург, 2018