Форум программистов, компьютерный форум CyberForum.ru

Имитация работы станка - C++

Восстановить пароль Регистрация
 
dmitriu098
0 / 0 / 0
Регистрация: 16.04.2013
Сообщений: 17
10.05.2014, 18:40     Имитация работы станка #1
Добрый вечер! Прошу помощи в решении следующей задачи.
Необходимо симитировать работу такого станка:
В первый ящик попадает деталь в интервале от 1 до 5 секунд. При попадании счетчик увеличивается (+1)
Станок обрабатывает деталь в течении 5 секунд. При выборке днталей из ящика счетчик уменьшается (-1)
Подключить генератор случайных чисел от 1 до 5 секунд. Закончить данный процесс через 60 секунд.
Продемонстрировать процесс переполнения, простоя. Какие функции, методы лучше использовать, буду благодарен за любую информацию!
Лучшие ответы (1)
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
10.05.2014, 18:40     Имитация работы станка
Посмотрите здесь:

C++ Имитация работы АЗС (ООП)
C++ Имитация нажатия клавиш С/С++
Имитация работы процессора C++
C++ Имитация командной строки
Имитация действий пользователя C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Mr.X
Эксперт С++
 Аватар для Mr.X
2798 / 1574 / 246
Регистрация: 03.05.2010
Сообщений: 3,651
12.05.2014, 12:47     Имитация работы станка #2
Сообщение было отмечено автором темы, экспертом или модератором как ответ
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
/////////////////////////////////////////////////////////////////////////////////////////
//Необходимо сымитировать работу такого станка:
//В первый ящик попадает деталь в интервале от 1 до 5 секунд. При попадании счетчик увеличивается (+1)
//Станок обрабатывает деталь в течении 5 секунд. При выборке днталей из ящика счетчик уменьшается (-1)
//Подключить генератор случайных чисел от 1 до 5 секунд. Закончить данный процесс через 60 секунд.
//Продемонстрировать процесс переполнения, простоя.
/////////////////////////////////////////////////////////////////////////////////////////
#include <conio.h>
#include <ctime>
#include <cstdlib>
#include <iostream>
#include <sstream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
typedef double          T_sec;
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_mashine_parameters
{
    T_sec   sec_interval_of_machine_operation_;
    T_sec   min_sec_interval_for_detail_adding_;
    T_sec   max_sec_interval_for_detail_adding_;
    T_sec   sec_interval_for_processing_of_detail_;
};
/////////////////////////////////////////////////////////////////////////////////////////
class  T_machine_operation
{
    //-----------------------------------------------------------------------------------
    const clock_t   MIN_TIME_INTERVAL_FOR_DETAIL_ADDING_;
    const clock_t   MAX_TIME_INTERVAL_FOR_DETAIL_ADDING_;
    const clock_t   TIME_INTERVAL_FOR_PROCESSING_OF_DETAIL_;
    //-----------------------------------------------------------------------------------
    int             details_counter_;
    int             machine_overflows_counter_;
    int             machine_stoppages_counter_;
    clock_t         start_time_;
    clock_t         finish_time_;
    clock_t         time_of_adding_detail_;
    clock_t         time_of_finish_processing_detail_;
    bool            processing_detail_flag_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_machine_operation( const T_mashine_parameters&  mashine_parameters )
        :
        MIN_TIME_INTERVAL_FOR_DETAIL_ADDING_    ( sec_to_clock( mashine_parameters  .min_sec_interval_for_detail_adding_    )   ),
        MAX_TIME_INTERVAL_FOR_DETAIL_ADDING_    ( sec_to_clock( mashine_parameters  .max_sec_interval_for_detail_adding_    )   ),
        TIME_INTERVAL_FOR_PROCESSING_OF_DETAIL_ ( sec_to_clock( mashine_parameters  .sec_interval_for_processing_of_detail_ )   ),
 
        details_counter_                            (),
        machine_overflows_counter_                  (),
        machine_stoppages_counter_                  (),
        start_time_                                 ( clock()   ),
        time_of_finish_processing_detail_           (),
        processing_detail_flag_                     ()
    {
        finish_time_            =       start_time_
                                    +   sec_to_clock( mashine_parameters    .sec_interval_of_machine_operation_ );
 
        time_of_adding_detail_  =       start_time_
                                    +   generate_time_interval_for_adding_detail();
 
        processor();
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    clock_t  sec_to_clock( T_sec  sec )
    {
        return  clock_t( sec * CLOCKS_PER_SEC );
    }
    //-----------------------------------------------------------------------------------
    void    processor()
    {
        clock_t     cur_time    =   start_time_;
        print_cur_time_and_start_mashine_message( cur_time );
 
        for(
                ;
                cur_time < finish_time_;
                cur_time = clock()
            )
        {
            check_adding_detail         ( cur_time );
            check_processing_detail     ( cur_time );
        }
 
        print_cur_time_and_stop_mashine_message     ( cur_time );
        print_machine_overflows_counter_message     ();
        print_machine_stoppages_counter_message     ();
    }
    //-----------------------------------------------------------------------------------
    void  print_cur_time_and_start_mashine_message( clock_t  time )
    {
        print_cur_time_and_message( time, "Станок запущен." );
    }
    //-----------------------------------------------------------------------------------
    void  check_adding_detail( clock_t  cur_time )
    {
        if( cur_time >= time_of_adding_detail_ )
        {
            ++details_counter_;
            time_of_adding_detail_  +=  generate_time_interval_for_adding_detail();
            print_cur_time_and_adding_detail_message( cur_time );
 
            if( details_counter_ > 1 )
            {
                ++machine_overflows_counter_;
                print_cur_time_and_machine_overflow_message( cur_time );
            }
        }//if
    }
    //-----------------------------------------------------------------------------------
    void  check_processing_detail( clock_t  cur_time )
    {
        if( !processing_detail_flag_ )
        {
            if( details_counter_ > 0 )
            {
                processing_detail_flag_     =   true;
                --details_counter_;
 
                time_of_finish_processing_detail_   =       cur_time
                                                        +   TIME_INTERVAL_FOR_PROCESSING_OF_DETAIL_;
 
                print_cur_time_and_begin_processing_detail_message( cur_time );
            }
        }//if
        else
        {
            if( cur_time >= time_of_finish_processing_detail_ )
            {
                processing_detail_flag_     =   false;
                print_cur_time_and_end_processing_detail_message( cur_time );
 
                if( details_counter_ == 0 )
                {
                    ++machine_stoppages_counter_;
                    print_cur_time_and_mashine_stoppage_message( cur_time );
                }
            }//if
        }//else
    }
    //-----------------------------------------------------------------------------------
    void  print_cur_time_and_stop_mashine_message( clock_t  cur_time )
    {
        print_cur_time_and_message( cur_time, "Станок остановлен. Работа закончена." );
    }
    //-----------------------------------------------------------------------------------
    void  print_machine_overflows_counter_message()
    {
        std::cout   <<  "Всего переполнений"
                    <<  '\t'
                    <<  machine_overflows_counter_
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    void  print_machine_stoppages_counter_message()
    {
        std::cout   <<  "Всего простоев"
                    <<  '\t'
                    <<  '\t'
                    <<  machine_stoppages_counter_
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    void  print_cur_time_and_mashine_stoppage_message( clock_t  time )
    {
        print_cur_time_and_message( time, "Простой! Нет заготовок!" );
    }
    //-----------------------------------------------------------------------------------
    clock_t  generate_time_interval_for_adding_detail()
    {
        double  rand_coef   =   rand() / double( RAND_MAX );
 
        return  clock_t
                    (
                                MIN_TIME_INTERVAL_FOR_DETAIL_ADDING_
 
                        +       (
                                        MAX_TIME_INTERVAL_FOR_DETAIL_ADDING_ 
                                    -   MIN_TIME_INTERVAL_FOR_DETAIL_ADDING_
                                )
                            *   rand_coef
                    );
    }
    //-----------------------------------------------------------------------------------
    void  print_cur_time_and_adding_detail_message( clock_t  cur_time )
    {
        std::ostringstream  sout;
 
        sout    <<  "В ящик добавлена "
                <<  details_counter_
                <<  "-я заготовка.";
 
        print_cur_time_and_message
            (
                cur_time,
                sout.str()
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_cur_time_and_machine_overflow_message( clock_t  cur_time )
    {
        print_cur_time_and_message( cur_time, "Переполнение ящика с заготовками." );
    }
    //-----------------------------------------------------------------------------------
    void  print_cur_time_and_begin_processing_detail_message( clock_t  time )
    {
        std::ostringstream  sout;
 
        sout    <<  "Начало обработки детали. В ящике осталось "
                <<  details_counter_
                <<  " заготовок.";
 
        print_cur_time_and_message
            (
                time,
                sout.str()
            );
    }
    //-----------------------------------------------------------------------------------
    void  print_cur_time_and_end_processing_detail_message( clock_t  time )
    {
        print_cur_time_and_message( time, "Окончание обработки детали." );
    }
    //-----------------------------------------------------------------------------------
    void  print_cur_time_and_message
        (
            clock_t         time,
            const T_str&    s
        )
    {
        std::cout   <<  cur_sec_time( time )
                    <<  '\t'
                    <<  s
                    <<  std::endl
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
    T_sec  cur_sec_time( clock_t  time )
    {
        return  ( time - start_time_ ) / double( CLOCKS_PER_SEC );
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
void  print_prompt_and_input_sec_value_not_less_than
    (
        const T_str&    prompt,
        T_sec&          sec_val,
        T_sec           lower_bound
    )
{
    do
    {
        std::cout   <<  prompt;
        std::cin    >>  sec_val;
    }
    while( sec_val < lower_bound );
}
/////////////////////////////////////////////////////////////////////////////////////////
void  input_parameters( T_mashine_parameters&  mashine_parameters )
{
    std::cout   <<  std::endl
                <<  std::endl
                <<  std::endl
                <<  std::endl;
 
    print_prompt_and_input_sec_value_not_less_than
        (
            "Время работы станка в секундах: ",
            mashine_parameters  .sec_interval_of_machine_operation_,
            0
        );
 
    std::cout   <<  std::endl
                <<  "Интервалы подачи заготовки в секундах:"
                <<  std::endl;
 
    print_prompt_and_input_sec_value_not_less_than
        (
            "\tминимальный\t: ",
            mashine_parameters  .min_sec_interval_for_detail_adding_,
            0
        );
 
    print_prompt_and_input_sec_value_not_less_than
        (
            "\tмаксимальный\t: ",
            mashine_parameters  .max_sec_interval_for_detail_adding_,
            mashine_parameters  .min_sec_interval_for_detail_adding_
        );
 
    std::cout   <<  std::endl;
 
    print_prompt_and_input_sec_value_not_less_than
        (
            "Время обработки детали\t: ",
            mashine_parameters.sec_interval_for_processing_of_detail_,
            0
        );
 
    std::cout   <<  std::endl
                <<  std::endl
                <<  std::endl;
}
/////////////////////////////////////////////////////////////////////////////////////////
void  machine_operation( const T_mashine_parameters&  mashine_parameters )
{
    T_machine_operation     machine_operation( mashine_parameters );
}
/////////////////////////////////////////////////////////////////////////////////////////
int  main()
{
    std::locale::global(std::locale(""));
 
    srand( unsigned( time(0) ) );
 
    T_mashine_parameters  mashine_parameters;
 
    for(;;)
    {
        input_parameters    ( mashine_parameters );
        machine_operation   ( mashine_parameters );
    }//for
}
Tulosba
12.05.2014, 13:52
  #3

Не по теме:

любопытное форматирование кода

dmitriu098
0 / 0 / 0
Регистрация: 16.04.2013
Сообщений: 17
12.05.2014, 18:50  [ТС]     Имитация работы станка #4
Спасибо за помощь, честно не ожидал, что программный код будет таких размеров.
outoftime
║XLR8║
 Аватар для outoftime
505 / 427 / 33
Регистрация: 25.07.2009
Сообщений: 2,297
12.05.2014, 23:31     Имитация работы станка #5
Mr.X, Tulosba, есть ли преимущество вашем способе инициализации переменных класса? Имеется в виду прирост производительности либо другие плюшки.

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
    T_machine_operation( const T_mashine_parameters&  mashine_parameters )
        :
        MIN_TIME_INTERVAL_FOR_DETAIL_ADDING_    ( sec_to_clock( mashine_parameters  .min_sec_interval_for_detail_adding_    )   ),
        MAX_TIME_INTERVAL_FOR_DETAIL_ADDING_    ( sec_to_clock( mashine_parameters  .max_sec_interval_for_detail_adding_    )   ),
        TIME_INTERVAL_FOR_PROCESSING_OF_DETAIL_ ( sec_to_clock( mashine_parameters  .sec_interval_for_processing_of_detail_ )   ),
 
        details_counter_                            (),
        machine_overflows_counter_                  (),
        machine_stoppages_counter_                  (),
        start_time_                                 ( clock()   ),
        time_of_finish_processing_detail_           (),
        processing_detail_flag_                     ()
    {
        
    }
monolit
179 / 179 / 21
Регистрация: 24.03.2011
Сообщений: 641
Завершенные тесты: 1
13.05.2014, 00:08     Имитация работы станка #6
Ну, преимущество то есть. Если в производительности - то небольшое.
Инициализация полей с помощью списка инициализации происходит до начала исполнения тела конструктора, что в некоторых ситуациях бывает важно. Так, например, список инициализации - это способ задать начальные значения констант и ссылок.
Yandex
Объявления
13.05.2014, 00:08     Имитация работы станка
Ответ Создать тему
Опции темы

Текущее время: 21:25. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru