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

С++ для начинающих

Войти
Регистрация
Восстановить пароль
 
 
Рейтинг: Рейтинг темы: голосов - 32, средняя оценка - 4.63
snayperAlfa
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
#1

Быстрый перевод байта в вектор битов - C++

29.07.2011, 18:42. Просмотров 3965. Ответов 48
Метки нет (Все метки)

Всем привет. Есть тут интересная задачка: перевести байт в вектор битов, да побыстрее.

Я реализовал это дело через таблицу. Кто знает способ лучше ?

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
public: void static CharToBits (const boost::uint8_t & InputByte, std::vector <boost::uint8_t>  & OutputVector)
            {
                /*Converts input unsigned char to 8 bits.Result is in vector vect1
                * MSB is OutputVector[0]
                * LSB is OutputVector[7]*/
 
 
             const boost::uint8_t CharBitsTable[256][8] = {
                         {0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,1},{0,0,0,0,0,0,1,0},{0,0,0,0,0,0,1,1},
                         {0,0,0,0,0,1,0,0},{0,0,0,0,0,1,0,1},{0,0,0,0,0,1,1,0},{0,0,0,0,0,1,1,1},
                         {0,0,0,0,1,0,0,0},{0,0,0,0,1,0,0,1},{0,0,0,0,1,0,1,0},{0,0,0,0,1,0,1,1},
                         {0,0,0,0,1,1,0,0},{0,0,0,0,1,1,0,1},{0,0,0,0,1,1,1,0},{0,0,0,0,1,1,1,1},
                         {0,0,0,1,0,0,0,0},{0,0,0,1,0,0,0,1},{0,0,0,1,0,0,1,0},{0,0,0,1,0,0,1,1},
                         {0,0,0,1,0,1,0,0},{0,0,0,1,0,1,0,1},{0,0,0,1,0,1,1,0},{0,0,0,1,0,1,1,1},
                         {0,0,0,1,1,0,0,0},{0,0,0,1,1,0,0,1},{0,0,0,1,1,0,1,0},{0,0,0,1,1,0,1,1},
                         {0,0,0,1,1,1,0,0},{0,0,0,1,1,1,0,1},{0,0,0,1,1,1,1,0},{0,0,0,1,1,1,1,1},
                         {0,0,1,0,0,0,0,0},{0,0,1,0,0,0,0,1},{0,0,1,0,0,0,1,0},{0,0,1,0,0,0,1,1},
                         {0,0,1,0,0,1,0,0},{0,0,1,0,0,1,0,1},{0,0,1,0,0,1,1,0},{0,0,1,0,0,1,1,1},
                         {0,0,1,0,1,0,0,0},{0,0,1,0,1,0,0,1},{0,0,1,0,1,0,1,0},{0,0,1,0,1,0,1,1},
                         {0,0,1,0,1,1,0,0},{0,0,1,0,1,1,0,1},{0,0,1,0,1,1,1,0},{0,0,1,0,1,1,1,1},
                         {0,0,1,1,0,0,0,0},{0,0,1,1,0,0,0,1},{0,0,1,1,0,0,1,0},{0,0,1,1,0,0,1,1},
                         {0,0,1,1,0,1,0,0},{0,0,1,1,0,1,0,1},{0,0,1,1,0,1,1,0},{0,0,1,1,0,1,1,1},
                         {0,0,1,1,1,0,0,0},{0,0,1,1,1,0,0,1},{0,0,1,1,1,0,1,0},{0,0,1,1,1,0,1,1},
                         {0,0,1,1,1,1,0,0},{0,0,1,1,1,1,0,1},{0,0,1,1,1,1,1,0},{0,0,1,1,1,1,1,1},
                         {0,1,0,0,0,0,0,0},{0,1,0,0,0,0,0,1},{0,1,0,0,0,0,1,0},{0,1,0,0,0,0,1,1},
                         {0,1,0,0,0,1,0,0},{0,1,0,0,0,1,0,1},{0,1,0,0,0,1,1,0},{0,1,0,0,0,1,1,1},
                         {0,1,0,0,1,0,0,0},{0,1,0,0,1,0,0,1},{0,1,0,0,1,0,1,0},{0,1,0,0,1,0,1,1},
                         {0,1,0,0,1,1,0,0},{0,1,0,0,1,1,0,1},{0,1,0,0,1,1,1,0},{0,1,0,0,1,1,1,1},
                         {0,1,0,1,0,0,0,0},{0,1,0,1,0,0,0,1},{0,1,0,1,0,0,1,0},{0,1,0,1,0,0,1,1},
                         {0,1,0,1,0,1,0,0},{0,1,0,1,0,1,0,1},{0,1,0,1,0,1,1,0},{0,1,0,1,0,1,1,1},
                         {0,1,0,1,1,0,0,0},{0,1,0,1,1,0,0,1},{0,1,0,1,1,0,1,0},{0,1,0,1,1,0,1,1},
                         {0,1,0,1,1,1,0,0},{0,1,0,1,1,1,0,1},{0,1,0,1,1,1,1,0},{0,1,0,1,1,1,1,1},
                         {0,1,1,0,0,0,0,0},{0,1,1,0,0,0,0,1},{0,1,1,0,0,0,1,0},{0,1,1,0,0,0,1,1},
                         {0,1,1,0,0,1,0,0},{0,1,1,0,0,1,0,1},{0,1,1,0,0,1,1,0},{0,1,1,0,0,1,1,1},
                         {0,1,1,0,1,0,0,0},{0,1,1,0,1,0,0,1},{0,1,1,0,1,0,1,0},{0,1,1,0,1,0,1,1},
                         {0,1,1,0,1,1,0,0},{0,1,1,0,1,1,0,1},{0,1,1,0,1,1,1,0},{0,1,1,0,1,1,1,1},
                         {0,1,1,1,0,0,0,0},{0,1,1,1,0,0,0,1},{0,1,1,1,0,0,1,0},{0,1,1,1,0,0,1,1},
                         {0,1,1,1,0,1,0,0},{0,1,1,1,0,1,0,1},{0,1,1,1,0,1,1,0},{0,1,1,1,0,1,1,1},
                         {0,1,1,1,1,0,0,0},{0,1,1,1,1,0,0,1},{0,1,1,1,1,0,1,0},{0,1,1,1,1,0,1,1},
                         {0,1,1,1,1,1,0,0},{0,1,1,1,1,1,0,1},{0,1,1,1,1,1,1,0},{0,1,1,1,1,1,1,1},
                         {1,0,0,0,0,0,0,0},{1,0,0,0,0,0,0,1},{1,0,0,0,0,0,1,0},{1,0,0,0,0,0,1,1},
                         {1,0,0,0,0,1,0,0},{1,0,0,0,0,1,0,1},{1,0,0,0,0,1,1,0},{1,0,0,0,0,1,1,1},
                         {1,0,0,0,1,0,0,0},{1,0,0,0,1,0,0,1},{1,0,0,0,1,0,1,0},{1,0,0,0,1,0,1,1},
                         {1,0,0,0,1,1,0,0},{1,0,0,0,1,1,0,1},{1,0,0,0,1,1,1,0},{1,0,0,0,1,1,1,1},
                         {1,0,0,1,0,0,0,0},{1,0,0,1,0,0,0,1},{1,0,0,1,0,0,1,0},{1,0,0,1,0,0,1,1},
                         {1,0,0,1,0,1,0,0},{1,0,0,1,0,1,0,1},{1,0,0,1,0,1,1,0},{1,0,0,1,0,1,1,1},
                         {1,0,0,1,1,0,0,0},{1,0,0,1,1,0,0,1},{1,0,0,1,1,0,1,0},{1,0,0,1,1,0,1,1},
                         {1,0,0,1,1,1,0,0},{1,0,0,1,1,1,0,1},{1,0,0,1,1,1,1,0},{1,0,0,1,1,1,1,1},
                         {1,0,1,0,0,0,0,0},{1,0,1,0,0,0,0,1},{1,0,1,0,0,0,1,0},{1,0,1,0,0,0,1,1},
                         {1,0,1,0,0,1,0,0},{1,0,1,0,0,1,0,1},{1,0,1,0,0,1,1,0},{1,0,1,0,0,1,1,1},
                         {1,0,1,0,1,0,0,0},{1,0,1,0,1,0,0,1},{1,0,1,0,1,0,1,0},{1,0,1,0,1,0,1,1},
                         {1,0,1,0,1,1,0,0},{1,0,1,0,1,1,0,1},{1,0,1,0,1,1,1,0},{1,0,1,0,1,1,1,1},
                         {1,0,1,1,0,0,0,0},{1,0,1,1,0,0,0,1},{1,0,1,1,0,0,1,0},{1,0,1,1,0,0,1,1},
                         {1,0,1,1,0,1,0,0},{1,0,1,1,0,1,0,1},{1,0,1,1,0,1,1,0},{1,0,1,1,0,1,1,1},
                         {1,0,1,1,1,0,0,0},{1,0,1,1,1,0,0,1},{1,0,1,1,1,0,1,0},{1,0,1,1,1,0,1,1},
                         {1,0,1,1,1,1,0,0},{1,0,1,1,1,1,0,1},{1,0,1,1,1,1,1,0},{1,0,1,1,1,1,1,1},
                         {1,1,0,0,0,0,0,0},{1,1,0,0,0,0,0,1},{1,1,0,0,0,0,1,0},{1,1,0,0,0,0,1,1},
                         {1,1,0,0,0,1,0,0},{1,1,0,0,0,1,0,1},{1,1,0,0,0,1,1,0},{1,1,0,0,0,1,1,1},
                         {1,1,0,0,1,0,0,0},{1,1,0,0,1,0,0,1},{1,1,0,0,1,0,1,0},{1,1,0,0,1,0,1,1},
                         {1,1,0,0,1,1,0,0},{1,1,0,0,1,1,0,1},{1,1,0,0,1,1,1,0},{1,1,0,0,1,1,1,1},
                         {1,1,0,1,0,0,0,0},{1,1,0,1,0,0,0,1},{1,1,0,1,0,0,1,0},{1,1,0,1,0,0,1,1},
                         {1,1,0,1,0,1,0,0},{1,1,0,1,0,1,0,1},{1,1,0,1,0,1,1,0},{1,1,0,1,0,1,1,1},
                         {1,1,0,1,1,0,0,0},{1,1,0,1,1,0,0,1},{1,1,0,1,1,0,1,0},{1,1,0,1,1,0,1,1},
                         {1,1,0,1,1,1,0,0},{1,1,0,1,1,1,0,1},{1,1,0,1,1,1,1,0},{1,1,0,1,1,1,1,1},
                         {1,1,1,0,0,0,0,0},{1,1,1,0,0,0,0,1},{1,1,1,0,0,0,1,0},{1,1,1,0,0,0,1,1},
                         {1,1,1,0,0,1,0,0},{1,1,1,0,0,1,0,1},{1,1,1,0,0,1,1,0},{1,1,1,0,0,1,1,1},
                         {1,1,1,0,1,0,0,0},{1,1,1,0,1,0,0,1},{1,1,1,0,1,0,1,0},{1,1,1,0,1,0,1,1},
                         {1,1,1,0,1,1,0,0},{1,1,1,0,1,1,0,1},{1,1,1,0,1,1,1,0},{1,1,1,0,1,1,1,1},
                         {1,1,1,1,0,0,0,0},{1,1,1,1,0,0,0,1},{1,1,1,1,0,0,1,0},{1,1,1,1,0,0,1,1},
                         {1,1,1,1,0,1,0,0},{1,1,1,1,0,1,0,1},{1,1,1,1,0,1,1,0},{1,1,1,1,0,1,1,1},
                         {1,1,1,1,1,0,0,0},{1,1,1,1,1,0,0,1},{1,1,1,1,1,0,1,0},{1,1,1,1,1,0,1,1},
                         {1,1,1,1,1,1,0,0},{1,1,1,1,1,1,0,1},{1,1,1,1,1,1,1,0},{1,1,1,1,1,1,1,1}
                     };
 
 
                OutputVector.clear();
                OutputVector.reserve(8); // 8 бит на байт
                OutputVector.resize(8);
 
                OutputVector[0]=CharBitsTable[InputByte][0];
                OutputVector[1]=CharBitsTable[InputByte][1];
                OutputVector[2]=CharBitsTable[InputByte][2];
                OutputVector[3]=CharBitsTable[InputByte][3];
                OutputVector[4]=CharBitsTable[InputByte][4];
                OutputVector[5]=CharBitsTable[InputByte][5];
                OutputVector[6]=CharBitsTable[InputByte][6];
                OutputVector[7]=CharBitsTable[InputByte][7];
            
            
                /* 
                                 //Это мой старый способ. Он работает немного дольше чем табличный
                boost::uint8_t Base = 1<<7;
 
                for(boost::uint8_t i = 0; i < 8; i++)
                {
                    if( InputByte & Base )
                    {
                        OutputVector.push_back(1);
                    }
                    else
                    {
                        OutputVector.push_back(0);
                    }
                    Base = Base >> 1;
                }
                */
            };
Потом эта функция вызывается для перевода вектора байтов в вектор битов
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
29.07.2011, 18:42
Здравствуйте! Я подобрал для вас темы с ответами на вопрос Быстрый перевод байта в вектор битов (C++):

Перевод таблицы битов и времени в последовательность битов arduino - C++
доброго времени суток в приведенной ниже таблице левый столбец - биты, правый - их длительность. известно, что единичный сигнал длится от...

Перевод байта в знаковый формат - C++
Доброго времени суток. Столкнулся с проблемой. Есть переменная unsigned char, в ней лежит байт. Этот байт нужно перевести в знаковый...

как заполнить вектор векторов прямо в программе (самый быстрый метод) - C++
почему не работает? #include&lt;cstdio&gt; #include &lt;vector&gt; using namespace std; vector&lt;int&gt; a; int main(){ a={4,6}; ...

Операции с побитовыми операторами (число 8 битов и число 9 битов) - C++
Доброго времени суток всем ! Прошу ответа на несложный вопрос (...по крайней мере мне так кажется...) Есть функция: ...

Класс "вектор" с конструкторами, позволяющими создать нулевой вектор и вектор с произвольным числом элементов - C++
Привет! Задача следующая. Нужно реализовать класс &quot;вектор&quot; с конструкторами, которые позволяют создать нулевой вектор и вектор с...

Создать иерархию классов вектор и безопасный вектор с проверкой выхода за пределы - C++
Создать иерархию классов вектор и безопасный вектор с проверкой выхода за пределы. Безопасный вектор определяет переменные нижний и верхний...

48
alex_x_x
бжни
2447 / 1652 / 84
Регистрация: 14.05.2009
Сообщений: 7,162
29.07.2011, 19:18 #2
а если развернуть цикл?

Добавлено через 8 минут
C++
1
2
3
4
5
6
7
8
OutputVector[0]=InputByte & 1;
OutputVector[1]=InputByte & 2;
OutputVector[2]=InputByte & 4;
OutputVector[3]=InputByte & 8;
OutputVector[4]=InputByte & 16;
OutputVector[5]=InputByte & 32;
OutputVector[6]=InputByte & 64;
OutputVector[7]=InputByte & 128;
ну и reserve тут ни к чему
0
snayperAlfa
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
29.07.2011, 23:58  [ТС] #3
Надо будет проверить на время выполнения.
0
easybudda
Модератор
Эксперт CЭксперт С++
9663 / 5613 / 952
Регистрация: 25.07.2009
Сообщений: 10,775
30.07.2011, 00:22 #4
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
#include <stdio.h>
#include <limits.h>
#include <string.h>
 
#define bits2arr(arr, val) ({ char tmp[8] = { val >> 7 & 1, val >> 6 & 1, val >> 5 & 1, val >> 4 & 1, val >> 3 & 1, val >> 2 & 1, val >> 1 & 1, val & 1 }; memcpy(arr, tmp, 8);})
 
int main(void){
    char arr[CHAR_BIT];
    int i;
    
    if ( CHAR_BIT != 8 ){
        fprintf(stderr, "Shit!\n");
        return 1;
    }
    
    while ( printf("Number from 0 to 255: ") && scanf("%d", &i) == 1 && i > -1 && i < 256 ){
        bits2arr(arr, i);
        for ( i = 0; i < CHAR_BIT; ++i )
            printf("%d", arr[i]);
        printf("\n");
    }
    
    return 0;
}
Быстрый перевод байта в вектор битов
0
snayperAlfa
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 01:10  [ТС] #5
memcpy() использовать нельзя. од будет запускаться на ARM архитектуре и могут быть грабли с BigEndian / LittleEndian
0
TheAthlete
153 / 153 / 13
Регистрация: 31.08.2010
Сообщений: 535
30.07.2011, 09:46 #6
Здравствуйте! Есть проще вариант. В с++ есть библиотечный тип bitset, который позволяет удобно работать с наборами битов. Приведу простой пример вывода на экран значения битов. Думаю, перевести в вектор не составит труда (если нужно)

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include <bitset>
 
using std::cout;
using std::endl;
using std::bitset;
 
int main() {
  bitset<8> bitvec1(25); // инициализируем набор битов беззнаковым значением unsigned long либо size_t
  
  cout << bitvec1 << endl; // передаем биты набора bitvec1 в поток cout
  cout << bitvec1.size() << endl; // выводим на экран количество битов в наборе bitvec1
 
  return 0;
}
0
alex_x_x
30.07.2011, 14:05
  #7

Не по теме:

TheAthlete, эт понятно, но автор чтото сетовал на скорость

0
Evg
Эксперт CАвтор FAQ
17933 / 6159 / 408
Регистрация: 30.03.2009
Сообщений: 16,906
Записей в блоге: 27
30.07.2011, 16:08 #8
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Я реализовал это дело через таблицу. Кто знает способ лучше ?
Что ты подразумеваешь под "лучше"?

Вариант со статической инициализацией векторов и дальнейшего использования нужного вектора - это максимально быстрый способ, очевидным минусом котрого является расход памяти. Точно так 30 лет назад в игрушках строились таблицы синусов и косинусов, чтобы на медленных процессорах не терять время на вычисление.
0
snayperAlfa
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 20:56  [ТС] #9
Под "лучше" я подразумеваю "быстрее". Время выполнения кода очень критично.
0
alex_x_x
бжни
2447 / 1652 / 84
Регистрация: 14.05.2009
Сообщений: 7,162
30.07.2011, 21:56 #10
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Время выполнения кода очень критично.
и при этом используются стлные контейнеры?
0
snayperAlfa
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 22:24  [ТС] #11
Да. В программе нужны операции над битами (битстаффинг, скремблинг). Для хранения битов используются вектора байтов.
0
Evg
Эксперт CАвтор FAQ
17933 / 6159 / 408
Регистрация: 30.03.2009
Сообщений: 16,906
Записей в блоге: 27
30.07.2011, 23:23 #12
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Время выполнения кода очень критично.
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Да. В программе нужны операции над битами (битстаффинг, скремблинг). Для хранения битов используются вектора байтов.
Если критично, мне кажется это лучше на си или на ассемблере писать. Для битовых операций типа срамбла на некоторых процессорах есть операции, хз как на Arm'е
0
igorrr37
1647 / 1275 / 133
Регистрация: 21.12.2010
Сообщений: 1,932
Записей в блоге: 7
30.07.2011, 23:31 #13
вот так получилось быстрее таблицы
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
void CharToBits (const uint8_t& InputByte, std::vector<uint8_t>& OutputVector){
    OutputVector.clear();
    OutputVector.resize(8);
    uint8_t Base = 1;
    OutputVector[0]=InputByte>>7;
    OutputVector[1]=InputByte>>6&Base;
    OutputVector[2]=InputByte>>5&Base;
    OutputVector[3]=InputByte>>4&Base;
    OutputVector[4]=InputByte>>3&Base;
    OutputVector[5]=InputByte>>2&Base;
    OutputVector[6]=InputByte>>1&Base;
    OutputVector[7]=InputByte&Base;
}
0
Evg
Эксперт CАвтор FAQ
17933 / 6159 / 408
Регистрация: 30.03.2009
Сообщений: 16,906
Записей в блоге: 27
30.07.2011, 23:40 #14
Цитата Сообщение от igorrr37 Посмотреть сообщение
вот так получилось быстрее таблицы
У него просто таблица коряво реализована. В таблице должно быть просто копирование подготовленного значения без каких-либо дополнительный вычислений
0
snayperAlfa
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
31.07.2011, 01:24  [ТС] #15
А почему коряво? Заносим в вектор значение по заданному индексу из массива. push_back() уже вычисленное значение.
0
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
31.07.2011, 01:24
Привет! Вот еще темы с ответами:

Есть квадратная матрица А порядка n и вектор b с n элементами. Получить вектор Аb. - C++
Привет. Не могу разобратся, вот задание: Есть квадратная матрица А порядка n и вектор b с n элементами. Получить вектор Аb.

Почему матрица на вектор умножается быстрее чем вектор на матрицу? - C++
Почему матрица на вектор умножается быстрее чем вектор на матрицу?

матрица на вектор, вроде правильно, а вектор на матрицу? посмотрите пожалуйста? - C++
#include &lt;iostream&gt; #include &lt;iomanip&gt; #include &lt;cstdlib&gt; #include &lt;ctime&gt; using namespace std; int main() { ...

Создать иерархию классов вектор(longint) и безопасный вектор с проверкой выхода за пределы - C++
Помогите не знаю как сделать! Создать иерархию классов вектор(longint) и безопасный вектор с проверкой выхода за пределы. Безопасный...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
15
Yandex
Объявления
31.07.2011, 01:24
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru