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

Упаковка битовых групп - C++

Восстановить пароль Регистрация
 
Рейтинг: Рейтинг темы: голосов - 15, средняя оценка - 4.60
theFEAR
0 / 0 / 0
Регистрация: 14.12.2009
Сообщений: 6
25.11.2010, 20:07     Упаковка битовых групп #1
Доброго времени суток. Подскажите пожалуйста где я ошибся? Задание в шапке проги
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
// File !lab4-2.cpp
// Упаковка битовых групп
// 
//Эта программа упаковывает битовые группы в динное беззнаковое число
//         31----+-----+-----+-----0
//         ! mod ! kop ! reg !scale!  value
//         +-----+-----+-----+-----+
//            9     5     11    7
// Выходные данные:
// Длинное целое беззнаковое число, которое содержит указанные битовые группы
//           15---8------0
//           ! 00 !  mod !  mod
//           +----+------+
//                    9
//           7----4------0
//           ! 00 !  kop !  kop
//           +----+------+
//                    5
//           15---10-----0
//           ! 00 !  reg !  reg
//           +----+------+
//                    11
//           7----6------0
//           ! 00 ! scale!  scale
//           +----+------+
//                    7
//-===================================================================
#include <iostream>
#include <iomanip>
#include <stdio.h>
using namespace std;
unsigned long  value, value_a;
unsigned char  kop, scale, kop_a,scale_a;
unsigned short mod, reg, mod_a, reg_a;
unsigned short tmp;
int main() 
{
    setlocale(LC_ALL,"rus");
    cout <<"\n\tУпаковка битовых групп";
    cout <<"\n\tУпаковать битовые группы, содержащиеся в целых числах";
    cout <<"\n\tВ 32-битовое целое число Value  ";
    for (;;)
    {
    // Выделить битовые группы из числа Value
        cout << "\nПожалуйста, введите 3 16-ые цифры для MOD :";
        cin  >> hex >> tmp; mod = tmp;
        cout << "\nПожалуйста, введите 2 16-х цифры для KOP :";
        cin  >> hex >> tmp; kop = tmp;
        cout << "\nПожалуйста, введите 3 16-х цифры для REG :";
        cin  >> hex >> tmp; reg = tmp;
        cout << "\nПожалуйста, введите 2 16-х цифры для SCALE :";
        cin  >> hex >> tmp; scale = tmp;
    // Сделать копии исходных чисел для фагмента на ассемблере
        mod_a = mod; kop_a = kop; reg_a = reg; scale_a = scale;
 
 
 
    
//============================ Assembler =============================
    // Упаковать битовые группы
       __asm{
    // Очистить старшие биты в каждом исходном числе
       and      mod_a,0x1ff
       and      kop_a,0x1f
       and      reg_a,0x7ff
       and      scale_a,0x7f
       xor      eax,eax
// объединить поле mod с value
       or               ax,mod_a      
         shl        eax,5       
// объединить поле kop с value
       or           al,kop_a      
       shl          eax,11       
// объединить поле reg с value
       or         ax,reg_a      
       shl            eax,7        
// объединить поле scale с value
       or               al,scale_a     
       mov            value_a,eax   
        }
    // Форматный вывод результатов 
        cout << hex
       << "Результирующее упакованное число (C++): " << value
       << "\nРезультирующее упакованное число (Asm): " << value_a
       << endl;
    };
    return 0;
    }
И ещё нужно сделать то же самое на с++
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
25.11.2010, 20:07     Упаковка битовых групп
Посмотрите здесь:

C++ Обработка Битовых последовательностей
Упаковка и распаковка групп чисел и вероятность выпадения граней костей C++
C++ Использование битовых операторов для bool
C++ Есть строка, состоящая из групп нулей и единиц. Каждая группа отделяется друг от друга одним или несколькими пробелами. Найти и вывести на экран групп
C++ Вывод битовых полей изображения
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
illuminati
20 / 20 / 4
Регистрация: 14.06.2010
Сообщений: 108
25.11.2010, 20:16     Упаковка битовых групп #2
ХАИ ?
Day
 Аватар для Day
1149 / 954 / 57
Регистрация: 29.10.2009
Сообщений: 1,384
25.11.2010, 20:18     Упаковка битовых групп #3
А можно без ассссемблера?
C
1
  value = scale + (reg<<7) + (kop<<18) + (mod<<23);
Все переменные д.б. unsigned long (или unsigned int для 32-разрядных платформ)
Вводить числа можно и просто в десятичном виде, но это уж - как удобней
Если же нужен именно ассемблер - тогда я - пас.
theFEAR
0 / 0 / 0
Регистрация: 14.12.2009
Сообщений: 6
25.11.2010, 20:27  [ТС]     Упаковка битовых групп #4
Цитата Сообщение от illuminati Посмотреть сообщение
ХАИ ?
Хех) Оно самое)
Сори, я через пару минут выложу другой код, это образец)

Добавлено через 3 минуты
В общем задание состоит из двух частей, упаковка и распаковка, распаковку я сделал, она работает корректно, код приведен ниже. Осталось сделать упаковку, данные те же.

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
//====================================================================
// Распаковка битовых групп
//
// Эта программа распаковывает битовые группы из целого беззнакового числа
//
// Входные данные:
// Длинное целое число, которое содержит несколько битовых групп
//
//         31-----+------+-----+-----+-----+-----+0
//         | mod  | reg1 | r_m | kop |  w  | reg2| value
//         +------+------+-----+-----+-----+-----+
//            4      6     12     4     1     5
//
// Выходные данные:
//           7----4------0
//           ! 00 !  mod !  mod
//           +----+------+
//                    4
//           7----4------0
//           ! 00 ! reg1 !  reg1
//           +----+------+
//                    6
//           15---10-----0
//           ! 00 !  r_m !  r_m
//           +----+------+
//                    12
//           7----6------0
//           ! 00 !  kop !  kop
//           +----+------+
//                    4
//           7----6------0
//           ! 00 !   w  !  w
//           +----+------+
//                    1
//           7----6------0
//           ! 00 ! reg2 !  reg2
//           +----+------+
//                    5
//====================================================================
#include <iostream>
#include <iomanip>
#include <stdio.h>
using namespace std;
unsigned long  value;
unsigned char  mod, reg1, kop, w, reg2, reg1_a, kop_a, w_a, reg2_a;
unsigned short mod_a, r_m, r_m_a;
 
int main() 
{
    setlocale(LC_ALL,"rus");
    printf("\tРаспаковка битовых групп");
    printf("\n\tРаспаковать 32-битовое число Value");
    printf("\n\nПожалуйста, введите 8 шестнадцатеричных цифр) : ");
    for (;;)
        {
            scanf("%x",&value);
//=============================== C ==================================
   // Выделить битовые группы из числа Value
       reg2 = value & 0x1f;           // выделить 5 младших битов(4-0) из Value
       w = (value >> 5)  & 0x1;       // выделить 1 бит (6-5)  из Value
         kop = (value >> 6) & 0xf;      // выделить 4 бита (10-7) из Value
       r_m = (value >> 10) & 0xfff;   // выделить 12 битов (22-11) из Value
             reg1 = (value >> 22) & 0x3f;   // выделить 6 битов (28-23) из Value
             mod = (value >> 28) & 0xf;     // выделить 4 бита (32-29) из Value
//============================ Assembler =============================
   // Выделить битоые группы из числа Value
       __asm{
        mov    eax,value   
   // выделить 5 младших битов(4-0) из Value
        mov    reg2_a,al     
        and    reg2_a,0x1f   
        shr    eax,5       
   // выделить 1 бит (6-5)  из Value
        mov    w_a,al     
        and    w_a,0x1   
        shr    eax,1       
   // выделить 4 бита (11-7) из Value
        mov    kop_a,al     
        and    kop_a,0xf   
        shr    eax,4       
   // выделить 12 битов (24-12) из Value
        mov    r_m_a,ax   
        and    r_m_a,0xfff  
        shr    eax,12      
   // выделить 6 битов (30-24) из Value
        mov    reg1_a,al     
        and    reg1_a,0x3f  
        shr    eax,6       
        // выделить 4 бита (35-31) из Value
        mov    mod_a,ax   
        and    mod_a,0xf
 
         }
   // Форматный вывод результатов 
      cout << hex
           << "\n\tБитовая группа REG2 (C++): " << (int) reg2
           << "\n\tБитовая группа W (C++): " << (int) w
           << "\n\tБитовая группа KOP (C++): " << (int) kop
           << "\n\tБитовая группа R_M (C++): " << (int) r_m
                     << "\n\tБитовая группа REG1 (C++): " << (int) reg1
                     << "\n\tБитовая группа MOD (C++): " << (int) mod
           << "\n\tБитовая группа REG2_A (Asm): " << (int) reg2_a
           << "\n\tБитовая группа W_A (Asm): " << (int) w_a
           << "\n\tБитовая группа KOP_A (Asm): " << (int) kop_a
           << "\n\tБитовая группа R_M_A (Asm): " << (int) r_m_a
                     << "\n\tБитовая группа REG1_A (Asm): " << (int) reg1_a
                     << "\n\tБитовая группа MOD_A (Asm): " << (int) mod_a
              << endl;
   } 
      return 0;
   }
Добавлено через 2 минуты
Цитата Сообщение от Day Посмотреть сообщение
А можно без ассссемблера?
C
1
  value = scale + (reg<<7) + (kop<<18) + (mod<<23);
Все переменные д.б. unsigned long (или unsigned int для 32-разрядных платформ)
Вводить числа можно и просто в десятичном виде, но это уж - как удобней
Если же нужен именно ассемблер - тогда я - пас.
Ну с ассемблером я постараюсь разобраться, а
C
1
  value = scale + (reg<<7) + (kop<<18) + (mod<<23);
просто складывает числа или добавляет биты через указанное смещение, как указано в задании?

Вот программа которая у меня получилась, но она неправильно вычисляет значения(

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
//====================================================================
// Упаковка битовых групп
//
// Эта программа упаковывает битовые в целое беззнаковое числа
//
// Входные данные:
//           7----4------0
//           ! 00 !  mod !  mod
//           +----+------+
//                    4
//           7----4------0
//           ! 00 ! reg1 !  reg1
//           +----+------+
//                    6
//           15---10-----0
//           ! 00 !  r_m !  r_m
//           +----+------+
//                    12
//           7----6------0
//           ! 00 !  kop !  kop
//           +----+------+
//                    4
//           7----6------0
//           ! 00 !   w  !  w
//           +----+------+
//                    1
//           7----6------0
//           ! 00 ! reg2 !  reg2
//           +----+------+
//                    5
//
// Ожидаемый результат:
// Длинное целое число, которое содержит несколько битовых групп
//
//         31-----+------+-----+-----+-----+-----+0
//         | mod  | reg1 | r_m | kop |  w  | reg2| value
//         +------+------+-----+-----+-----+-----+
//            4      6     12     4     1     5
//====================================================================
#include <iostream>
#include <iomanip>
#include <stdio.h>
using namespace std;
unsigned long  value, value_a;
unsigned char  mod, reg1, kop, w, reg2, reg1_a, kop_a, w_a, reg2_a;
unsigned short mod_a, r_m, r_m_a;
unsigned short tmp;
int main() 
{
    setlocale(LC_ALL,"rus");
    cout <<"\n\tУпаковка битовых групп";
    cout <<"\n\tУпаковать битовые группы, содержащиеся в целых числах";
  cout <<"\n\tВ 32-битовое целое число Value  ";
    for (;;)
    {
    // Выделить битовые группы из числа Value
        cout << "\nПожалуйста, введите 4 16-ые цифры для mod :";
        cin  >> hex >> tmp; mod = tmp;  
        cout << "\nПожалуйста, введите 6 16-х цифр для reg1 :";
        cin  >> hex >> tmp; reg1 = tmp;
        cout << "\nПожалуйста, введите 12 16-х цифр для r_m :";
        cin  >> hex >> tmp; r_m = tmp;
        cout << "\nПожалуйста, введите 4 16-х цифры для kop :";
      cin  >> hex >> tmp; kop = tmp;
        cout << "\nПожалуйста, введите 1 16-ю цифру для w :";
        cin  >> hex >> tmp; w = tmp;
        cout << "\nПожалуйста, введите 5 16-х цифр для reg2 :";
        cin  >> hex >> tmp; reg2 = tmp;
    // Сделать копии исходных чисел для фагмента на ассемблере
        mod_a = mod; reg1 = reg1_a; r_m = r_m_a; kop_a = kop; w = w; reg2_a = reg2;
 
//============================ Assembler =============================                       
    // Упаковать битовые группы                                                                                                          
       __asm{
    // Очистить старшие биты в каждом исходном числе
       and      reg2_a, 0x1f
       and      w_a,    0x1      
       and      kop_a,  0xf         
       and      r_m_a,  0xfff     
       and      reg1_a, 0x3f   
         and    mod_a,  0xf       
         xor        eax,eax
// объединить поле scale с value
       or            ax,mod_a     
       mov         value_a,eax    
// объединить поле reg с value
       or         al,reg1_a      
       shl        eax,6     
// объединить поле kop с value
       or           ax,r_m_a      
       shl          eax,12 
// объединить поле kop с value
       or           al,kop_a      
       shl          eax,4  
// объединить поле kop с value
       or           al,w_a      
       shl          eax,1 
// объединить поле mod с value
       or               al,reg2_a      
     shl            eax,5  
 
        }
    // Форматный вывод результатов 
        cout << hex
       << "Результирующее упакованное число (C++): " << value
       << "\nРезультирующее упакованное число (Asm): " << value_a
       << endl;
    };
    return 0;
    }
Day
 Аватар для Day
1149 / 954 / 57
Регистрация: 29.10.2009
Сообщений: 1,384
25.11.2010, 21:09     Упаковка битовых групп #5
theFEAR,
просто складывает числа или добавляет биты через указанное смещение, как указано в задании?
Просто складывает числа.
А можно и так
C
1
value = (scale | (reg<<7) | (kop<<18) | (mod<<23));
Тогда будет побитовое сложение.
Но если переменные строго лежат в предполагаемых пределах, то это одно и тоже
Yandex
Объявления
25.11.2010, 21:09     Упаковка битовых групп
Ответ Создать тему
Опции темы

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