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

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

Восстановить пароль Регистрация
 
 
Рейтинг: Рейтинг темы: голосов - 32, средняя оценка - 4.63
snayperAlfa
2 / 2 / 0
Регистрация: 13.08.2008
Сообщений: 84
29.07.2011, 18:42     Быстрый перевод байта в вектор битов #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
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;
                }
                */
            };
Потом эта функция вызывается для перевода вектора байтов в вектор битов
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
29.07.2011, 18:42     Быстрый перевод байта в вектор битов
Посмотрите здесь:

Visual C++ перевод битов в байты!!!
C++ Создать иерархию классов вектор(longint) и безопасный вектор с проверкой выхода за пределы
Создать иерархию классов вектор и безопасный вектор с проверкой выхода за пределы C++
C++ Есть квадратная матрица А порядка n и вектор b с n элементами. Получить вектор Аb.
C++ Builder Перевод битов в байты
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
alex_x_x
бжни
 Аватар для alex_x_x
2441 / 1646 / 84
Регистрация: 14.05.2009
Сообщений: 7,163
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 тут ни к чему
snayperAlfa
2 / 2 / 0
Регистрация: 13.08.2008
Сообщений: 84
29.07.2011, 23:58  [ТС]     Быстрый перевод байта в вектор битов #3
Надо будет проверить на время выполнения.
easybudda
Модератор
Эксперт С++
 Аватар для easybudda
9371 / 5421 / 914
Регистрация: 25.07.2009
Сообщений: 10,423
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;
}
Быстрый перевод байта в вектор битов
snayperAlfa
2 / 2 / 0
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 01:10  [ТС]     Быстрый перевод байта в вектор битов #5
memcpy() использовать нельзя. од будет запускаться на ARM архитектуре и могут быть грабли с BigEndian / LittleEndian
TheAthlete
 Аватар для TheAthlete
151 / 151 / 12
Регистрация: 31.08.2010
Сообщений: 529
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;
}
alex_x_x
30.07.2011, 14:05
  #7

Не по теме:

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

Evg
Эксперт С++Автор FAQ
 Аватар для Evg
16821 / 5242 / 318
Регистрация: 30.03.2009
Сообщений: 14,118
Записей в блоге: 26
30.07.2011, 16:08     Быстрый перевод байта в вектор битов #8
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Я реализовал это дело через таблицу. Кто знает способ лучше ?
Что ты подразумеваешь под "лучше"?

Вариант со статической инициализацией векторов и дальнейшего использования нужного вектора - это максимально быстрый способ, очевидным минусом котрого является расход памяти. Точно так 30 лет назад в игрушках строились таблицы синусов и косинусов, чтобы на медленных процессорах не терять время на вычисление.
snayperAlfa
2 / 2 / 0
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 20:56  [ТС]     Быстрый перевод байта в вектор битов #9
Под "лучше" я подразумеваю "быстрее". Время выполнения кода очень критично.
alex_x_x
бжни
 Аватар для alex_x_x
2441 / 1646 / 84
Регистрация: 14.05.2009
Сообщений: 7,163
30.07.2011, 21:56     Быстрый перевод байта в вектор битов #10
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Время выполнения кода очень критично.
и при этом используются стлные контейнеры?
snayperAlfa
2 / 2 / 0
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 22:24  [ТС]     Быстрый перевод байта в вектор битов #11
Да. В программе нужны операции над битами (битстаффинг, скремблинг). Для хранения битов используются вектора байтов.
Evg
Эксперт С++Автор FAQ
 Аватар для Evg
16821 / 5242 / 318
Регистрация: 30.03.2009
Сообщений: 14,118
Записей в блоге: 26
30.07.2011, 23:23     Быстрый перевод байта в вектор битов #12
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Время выполнения кода очень критично.
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Да. В программе нужны операции над битами (битстаффинг, скремблинг). Для хранения битов используются вектора байтов.
Если критично, мне кажется это лучше на си или на ассемблере писать. Для битовых операций типа срамбла на некоторых процессорах есть операции, хз как на Arm'е
igorrr37
 Аватар для igorrr37
1593 / 1221 / 118
Регистрация: 21.12.2010
Сообщений: 1,868
Записей в блоге: 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;
}
Evg
Эксперт С++Автор FAQ
 Аватар для Evg
16821 / 5242 / 318
Регистрация: 30.03.2009
Сообщений: 14,118
Записей в блоге: 26
30.07.2011, 23:40     Быстрый перевод байта в вектор битов #14
Цитата Сообщение от igorrr37 Посмотреть сообщение
вот так получилось быстрее таблицы
У него просто таблица коряво реализована. В таблице должно быть просто копирование подготовленного значения без каких-либо дополнительный вычислений
snayperAlfa
2 / 2 / 0
Регистрация: 13.08.2008
Сообщений: 84
31.07.2011, 01:24  [ТС]     Быстрый перевод байта в вектор битов #15
А почему коряво? Заносим в вектор значение по заданному индексу из массива. push_back() уже вычисленное значение.
Deviaphan
Делаю внезапно и красиво
Эксперт C++
 Аватар для Deviaphan
1283 / 1217 / 50
Регистрация: 22.03.2011
Сообщений: 3,744
31.07.2011, 07:14     Быстрый перевод байта в вектор битов #16
Максимальная эффективность будет только у таблицы менее 256 значений, остальные уже менее эффективны будут даже в асме.
Поэтому вот код:
C++
1
2
3
4
5
6
7
8
    OutputVector[0]=InputByte & (1<<7);
    OutputVector[1]=InputByte & (1<<6);
    OutputVector[2]=InputByte & (1<<5);
    OutputVector[3]=InputByte & (1<<4);
    OutputVector[4]=InputByte & (1<<3);
    OutputVector[5]=InputByte & (1<<2);
    OutputVector[6]=InputByte & (1<<1);
    OutputVector[7]=InputByte & 1;
Разумеется, тестировать нужно в релизе со включенными оптимизациями. Выражение в скобочках вычисляется во время компиляции.
ValeryLaptev
Эксперт C++
1004 / 783 / 46
Регистрация: 30.04.2011
Сообщений: 1,595
31.07.2011, 10:00     Быстрый перевод байта в вектор битов #17
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Под "лучше" я подразумеваю "быстрее". Время выполнения кода очень критично.
Тогда не вектор, а массив.
Через таблицу - самое быстрое.
Хотя можно не массив из 8 элементов, а константы-строки "00000001", "00000010"... И.т.д.
Меньше памяти.
Evg
Эксперт С++Автор FAQ
 Аватар для Evg
16821 / 5242 / 318
Регистрация: 30.03.2009
Сообщений: 14,118
Записей в блоге: 26
31.07.2011, 10:46     Быстрый перевод байта в вектор битов #18
Цитата Сообщение от snayperAlfa Посмотреть сообщение
А почему коряво? Заносим в вектор значение по заданному индексу из массива. push_back() уже вычисленное значение.
В таблице у тебя должны быть не байты, а уже готовые вектора, которые нужно просто скопировать. А ещё лучше - взять ссылку на готовый вектор (read-only, естественно), тогда это будет сравнимо по скорости с индексацией одного элемента скалярного массива
snayperAlfa
2 / 2 / 0
Регистрация: 13.08.2008
Сообщений: 84
31.07.2011, 17:51  [ТС]     Быстрый перевод байта в вектор битов #19
Цитата Сообщение от Evg Посмотреть сообщение
В таблице у тебя должны быть не байты, а уже готовые вектора, которые нужно просто скопировать. А ещё лучше - взять ссылку на готовый вектор (read-only, естественно), тогда это будет сравнимо по скорости с индексацией одного элемента скалярного массива
Хм. То-есть, каждый раз при вызове этой функции будет создаваться 256 векторов, в каждый из них будут push_back() соответствующие биты, потом эти вектора заноситься в массив, а потом уже возвращаться в качестве преобразованного значения?
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
31.07.2011, 18:30     Быстрый перевод байта в вектор битов
Еще ссылки по теме:

C++ задан вектор С, который состоит из 12 действительных чисел. Сформировать вектор D, нечетные элементы которого есть целая часть нечетных
Считать вектор из файла, записать вектор в файл C++
C++ Нужно реализовать класс "вектор" с конструкторами, которые позволяют создать нулевой вектор и вектор с произвольным кол-во элементов.

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

Или воспользуйтесь поиском по форуму:
Evg
Эксперт С++Автор FAQ
 Аватар для Evg
16821 / 5242 / 318
Регистрация: 30.03.2009
Сообщений: 14,118
Записей в блоге: 26
31.07.2011, 18:30     Быстрый перевод байта в вектор битов #20
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Хм. То-есть, каждый раз при вызове этой функции будет создаваться 256 векторов, в каждый из них будут push_back() соответствующие биты, потом эти вектора заноситься в массив, а потом уже возвращаться в качестве преобразованного значения?
Нет. В самом начале программы у тебя будет инициализация таблицы. Ты делаешь 256 раз по 8 push_back'ов. А в том месте, где тебе нужно сконвертировать байт в вектор, ты просто копируешь соотвествующий вектор из таблицы
Yandex
Объявления
31.07.2011, 18:30     Быстрый перевод байта в вектор битов
Ответ Создать тему
Опции темы

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