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

Битовые операции. Консольные формулы - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Как скомпилировать CLR программу в статический .exe? http://www.cyberforum.ru/cpp-beginners/thread1231409.html
Подскажите как скомпелировать CLR программу в статический .exe? Пробовал компелировать стандартными настройками (динамически)но при переносе приложения на другой компьютр начинаються чудеса... программа может запуститься но для запуска но ей понадабятся билиотеки а может не запуститься выдав ошибку ( скрины во вложених)
C++ Написать обучающую систему по конечным автоматам помогите пожалуйста написать программу - обучающая система по конечным автоматам на языке С++ Добавлено через 47 минут Она должна содержать теорию и тестовые вопросы по теме. Я думаю, что должны быть разделы с определениями, Анализ КА, Синтез конечных автоматов и минимизация КА. Нужно оформить в виде программы, включающей теоретические разделы и разделы ч тестами. Тесты выбираются с помощью... http://www.cyberforum.ru/cpp-beginners/thread1231398.html
Передача данных в функцию C++
Добрый день, форумчане! Интересует следующий странно глупый вопрос... Не могу понять! Вот никак. Есть фукция: int solve(int count_of_digits) { int start, end; if (count_of_digits == 2) { start = 10; end = 99; } if (count_of_digits == 3) { start = 100; end = 999; }
Сборка POCO проекта C++
Запускаю файл build_vs100.cmd и батник создает кучу файлов с расширением lib. Копирую их в C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\lib Теперь программа компилируется без проблем, но вылетает с сообщением PocoFoundation.dll not found
C++ С какой целью необходимо передвать по ссылке переменную в конструкторе копирования? http://www.cyberforum.ru/cpp-beginners/thread1231344.html
Почему аргумент в конструктор копирования передается не по значению, а по ссылке? Объясните понятным языком, пожалуйста. ClassName(const ClassName&) По сути же мы берем, например, obj1(уже инициализированный) и хотим чтобы obj2 был полной копией obj1(их соответствующие поля должны быть одинаковы). Но зачем тут фигурирует ссылка? Мы же просто можем переписать значения полей.
C++ Заполнение квадратной матрицы змейкой по горизонтали помогите пожалуйста Даны числа n и m. Создайте массив A и заполните его змейкой вот код #include <iostream> using namespace std; int main () { подробнее

Показать сообщение отдельно
Mr.X
Эксперт С++
 Аватар для Mr.X
2799 / 1575 / 246
Регистрация: 03.05.2010
Сообщений: 3,656
23.07.2014, 12:32     Битовые операции. Консольные формулы
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
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
/////////////////////////////////////////////////////////////////////////////////////////
//получение таблицы истиности по логической функции (2, 3, 4 переменные)
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <bitset>
#include <cctype>
#include <functional>
#include <iostream>
#include <iterator>
#include <stack>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
int     const   MAX_VAR_COUNT   =   60;
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_str;
typedef T_str::size_type                T_pos;
typedef T_str                           T_expr;
typedef T_str                           T_expr;
typedef std::stack  < char          >   T_char_stack;
typedef std::stack  < bool          >   T_bool_stack;
typedef std::bitset < MAX_VAR_COUNT >   T_bitset;
/////////////////////////////////////////////////////////////////////////////////////////
char    const   NOT_SYMB                =   '!';
char    const   AND_SYMB                =   '&';
char    const   OR_SYMB                 =   '|';
char    const   XOR_SYMB                =   '^';
char    const   ENTAILMENT_SYMB         =   '>';
char    const   EQ_SYMB                 =   '=';
char    const   NOT_EQ_SYMB             =   '#';
char    const   LEFT_PARENTHESIS_SYMB   =   '(';
char    const   RIGHT_PARENTHESIS_SYMB  =   ')';
char    const   TRUE_SYMB               =   '1';
/////////////////////////////////////////////////////////////////////////////////////////
void    print_prompt()
{
    std::cout   <<  "Введите формулу (можно с круглыми скобками) из односимвольных переменных"
                <<  std::endl
                <<  "(латинских букв) и следующих логических операторов:"
                <<  std::endl
                <<  NOT_SYMB            <<  '\t'    <<  "отрицание"         <<  std::endl
                <<  AND_SYMB            <<  '\t'    <<  "и"                 <<  std::endl
                <<  OR_SYMB             <<  '\t'    <<  "или"               <<  std::endl
                <<  XOR_SYMB            <<  '\t'    <<  "исключающее или"   <<  std::endl
                <<  ENTAILMENT_SYMB     <<  '\t'    <<  "импликация"        <<  std::endl
                <<  EQ_SYMB             <<  '\t'    <<  "эквивалентно"      <<  std::endl
                <<  NOT_EQ_SYMB         <<  '\t'    <<  "не эквивалентно"   <<  std::endl
                <<  std::endl;
}
/////////////////////////////////////////////////////////////////////////////////////////
void    remove_spaces( T_expr   &   expr )
{
    T_expr  res_expr;
 
    std::remove_copy_if
        (
            expr.begin          (),
            expr.end            (),
            std::back_inserter  ( res_expr ),
            isspace
        );
 
    expr = res_expr;
}
/////////////////////////////////////////////////////////////////////////////////////////
char    get_symb( T_expr  &   expr )
{
    char    res     =   expr.front();
    expr.erase( 0, 1 );
    return  res;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    is_var( char    symb )
{
    return  isalpha( symb ) != 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     priority( char  symb )
{
    switch( symb )
    {
    case    NOT_SYMB                :   return  6;
    case    AND_SYMB                :   return  5;
    case    OR_SYMB                 :   return  4;
    case    XOR_SYMB                :   return  4;
    case    ENTAILMENT_SYMB         :   return  3;
    case    EQ_SYMB                 :   return  2;
    case    NOT_EQ_SYMB             :   return  2;
    case    RIGHT_PARENTHESIS_SYMB  :   return  1;
    case    LEFT_PARENTHESIS_SYMB   :   return  0;
 
    default                         :   return  -1;
    }//switch
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    is_op_or_parenthesis( char    symb )
{
    return  priority( symb ) >= 0;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    succsessfully_set_from_expr_to_expr_postf
    (
        T_expr      expr,
        T_expr  &   expr_postf
    )
{
    bool            bool_res    =   !expr.empty();
    T_char_stack    char_stack;
 
    if( bool_res )
    {
        while   (
                    !expr.empty()
                )
        {
            char    cur_symb    =   get_symb( expr );
 
            if  (
                    is_var( cur_symb )
                )
            {
                expr_postf.push_back( cur_symb );
            }
            else if( cur_symb == LEFT_PARENTHESIS_SYMB )
            {
                char_stack.push( cur_symb );
            }
            else if (
                        is_op_or_parenthesis( cur_symb )
                    )
            {
                if  (
                        char_stack.empty()
                    )
                {
                    char_stack.push( cur_symb );
                }
                else
                {
                    while   (
                                    !char_stack.empty()
                                &&  priority( char_stack.top() ) >= priority( cur_symb )
                            )
                    {
                        expr_postf.push_back
                            (
                                char_stack.top()
                            );
 
                        char_stack.pop();
                    }
 
                    if( cur_symb == RIGHT_PARENTHESIS_SYMB )
                    {
                        bool_res    =       !char_stack.empty()
                                        &&  char_stack.top() == LEFT_PARENTHESIS_SYMB;
 
                        if( !bool_res )
                        {
                            break;
                        }
 
                        char_stack.pop();
                    }
                    else
                    {
                        char_stack.push( cur_symb );
                    }//else
                }//else
            }//else if
            else
            {
                bool_res    =   false;
                break;
            }//else
        }//while
    }//if
 
    if( bool_res )
    {
        while   (
                    !char_stack.empty()
                )
        {
            expr_postf.push_back
                (
                    char_stack.top()
                );
 
            char_stack.pop();
        }//while
    }//if
 
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
struct  T_is_not_var
{
    bool    operator() ( char   symb )
    {
        return  isalpha( symb ) == 0;
    }
};
/////////////////////////////////////////////////////////////////////////////////////////
T_str   get_variables_str( T_expr  const   &  expr )
{
    T_str   res_str;
 
    std::remove_copy_if
        (
            expr.begin          (),
            expr.end            (),
            std::back_inserter  ( res_str ),
            T_is_not_var        ()
        );
 
    std::sort
        (
            res_str.begin   (),
            res_str.end     ()
        );
 
    auto    new_end     =   std::unique
                                (
                                    res_str.begin   (),
                                    res_str.end     ()
                                );
 
    return  T_str
                (
                    res_str.begin(),
                    new_end
                );
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    get_bool_val_of_var_with_variables_str_and_var_values_str
    (
        char                cur_symb,
        T_str   const   &   variables_str,
        T_str   const   &   var_values_str
    )
{
    T_pos   pos     =   variables_str.find( cur_symb );
    return  var_values_str[ pos ]   ==  TRUE_SYMB;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    xor
    (
        bool    L,
        bool    R
    )
{
    return  L + R == 1;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    entailment
    (
        bool    L,
        bool    R
    )
{
    return  !L || R;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    successfully_execute_bin_op_with_bool_stack
    ( 
        char                bin_op_symb,
        T_bool_stack    &   bool_stack
    )
{
    bool    right_val   =   bool_stack.top();
    bool_stack.pop();
 
    bool    bool_res    =   !bool_stack.empty();
 
    if( bool_res )
    {
        bool    left_val    =   bool_stack.top();
        bool_stack.pop();
        bool    op_result   =   false;
 
        switch( bin_op_symb )
        {
        case    AND_SYMB                :   op_result   =   left_val    &&  right_val;                  break;
        case    OR_SYMB                 :   op_result   =   left_val    ||  right_val;                  break;
        case    XOR_SYMB                :   op_result   =   xor         ( left_val,     right_val   );  break;
        case    ENTAILMENT_SYMB         :   op_result   =   entailment  ( left_val,     right_val   );  break;
        case    EQ_SYMB                 :   op_result   =   left_val    ==  right_val;                  break;
        case    NOT_EQ_SYMB             :   op_result   =   left_val    !=  right_val;                  break;
 
        default                         :   bool_res = false;
        }
 
        bool_stack.push( op_result );
    }//if
 
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    successfully_calc_expr_postf_with_variables_str_and_var_values_and_set_res
    (
        T_expr              expr_postf,
        T_str   const   &   variables_str,
        T_str   const   &   var_values_str,
        bool            &   op_res
    )
{
    bool            bool_res    =   !expr_postf.empty();
    T_bool_stack    bool_stack;
 
    if( bool_res )
    {
        while   (
                    !expr_postf.empty()
                )
        {
            char    cur_symb    =   get_symb( expr_postf );
 
            if  (
                    is_var( cur_symb )
                )
            {
                bool_stack.push
                    (
                        get_bool_val_of_var_with_variables_str_and_var_values_str
                            (
                                cur_symb,
                                variables_str,
                                var_values_str
                            )
                    );
            }
            else
            {
                bool_res    =   !bool_stack.empty();
 
                if( !bool_res )
                {
                    break;
                }
 
                if( cur_symb == NOT_SYMB )
                {
                    bool_stack.top()    =   !bool_stack.top();
                }
                else
                {
                    bool_res    =   successfully_execute_bin_op_with_bool_stack
                                        (
                                            cur_symb,
                                            bool_stack
                                        );
                }//else
            }//else
        }//while
    }//if
 
    if( bool_res )
    {
        bool_res    =   bool_stack.size() == 1;
 
        if( bool_res )
        {
            op_res  =   bool_stack.top();
        }
    }//if
 
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
void    inc_bitset( T_bitset    &   var_values )
{
    var_values  =   T_bitset
                        (
                            int (
                                    var_values.to_ulong() + 1
                                )
                        );
}
/////////////////////////////////////////////////////////////////////////////////////////
bool    successfully_print_truth_table_for_expr_and_expr_postf
    (
        T_expr  const   &  expr,
        T_expr  const   &  expr_postf
    )
{
    static  T_str   const   SPACES_STR  =   "\t";
 
    bool        bool_res        =   false;
    T_str       variables_str   =   get_variables_str   ( expr_postf );
    int         var_count       =   variables_str.size  ();
    T_bitset    var_values;
 
    std::cout   <<  std::endl
                <<  "Таблица истинности"
                <<  std::endl
                <<  variables_str
                <<  SPACES_STR
                <<  expr
                <<  std::endl;
 
    unsigned    long    func_values_count   =   1 << var_count;
 
    for( unsigned   long  i = 0; i < func_values_count; ++i )
    {
        T_str   var_values_str  =   var_values.to_string().substr
                                        (
                                            MAX_VAR_COUNT - var_count,
                                            var_count
                                        );
 
        bool    op_res  =   false;
        bool_res        =   successfully_calc_expr_postf_with_variables_str_and_var_values_and_set_res
                                (
                                    expr_postf,
                                    variables_str,
                                    var_values_str,
                                    op_res
                                );
 
        if( !bool_res )
        {
            break;
        }
 
        std::cout   <<  var_values_str
                    <<  SPACES_STR
                    <<  op_res
                    <<  std::endl;
 
        inc_bitset( var_values );
    }//for
 
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
 
    for(;;)
    {
        T_expr  expr;
        T_expr  expr_postf;
 
        print_prompt    ();
        getline         ( std::cin, expr );
        remove_spaces   ( expr );
 
        if  (
                    !succsessfully_set_from_expr_to_expr_postf
                        (
                            expr,
                            expr_postf
                        )
 
                ||  !successfully_print_truth_table_for_expr_and_expr_postf
                        (
                            expr,
                            expr_postf
                        )
            )
        {
            std::cout   <<  "Выражение некорректно."
                        <<  std::endl;
        }//if
        std::cout   <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }//for
}
 
Текущее время: 07:56. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru