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

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

Восстановить пароль Регистрация
Другие темы раздела
C++ Моделирование работы концентратора http://www.cyberforum.ru/cpp-beginners/thread1171568.html
Добрый вечер! Задание следующего характера: Необходимо симитировать работу концентратора в сети, а именно отправить пакет от отправителя к получателю, сравнивая соответствующие ip адреса. Намекните как это можно реализовать, в сторону каких функций, буду благодарен за любую информацию! Возможно на других языках программирования
C++ Имитация менеджера запуска приложений Добрый вечер! Подскажите пожалуйста какие методы, функции использовать для решения следующей задачи: Необходимо разработать менеджер запуска программ Реализовать: 1) Установка пути к *.exe файлу 2) Указывать список и время запущеных программ Буду благодарен за помощь! http://www.cyberforum.ru/cpp-beginners/thread1171564.html
C++ Как создать запросы в С++, для базы данных?
Любым способом.
Моделирование процесса инсталяции C++
Доброго времени суток! Прошу помощи в решении следующей задачи Необходимо смоделировать процесс установки программм 1) Программа требует указания пути установки 2)Переписывает папку в новое место 3) Программа делает отметку в системном реестре об установке Какие функции, методы возможно использовать? Возможно кто сталкивался с решением данной задачи, намекните.
C++ Как сделать так чтоб работало? Что с компилятором? http://www.cyberforum.ru/cpp-beginners/thread1171559.html
ошибка: No such file or directory #include <iostream> using namespace std; int main() {const int n=15; int i;double min,max,a; for(i=0;i<n;i++)
C++ Отладка кода У меня задание написать программу и снабдить ее скриншотами отладки. Прогу сделал, а что за скрины делать? Имеется ввиду ее пошаговое выполнение? Т.е. выполнять построчно код и на кажду строку скрин делать или как? подробнее

Показать сообщение отдельно
Mr.X
Эксперт С++
 Аватар для Mr.X
2802 / 1578 / 247
Регистрация: 03.05.2010
Сообщений: 3,666
12.05.2014, 12:47     Имитация работы станка
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
}
 
Текущее время: 04:41. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru