Форум программистов, компьютерный форум, киберфорум
С++ для начинающих
Форум программистов и сисадминов Киберфорум > Форум программистов > C/C++ > C++ > С++ для начинающих
Войти
Регистрация
Восстановить пароль
Блоги Сообщество Поиск Заказать работу  
 
1 из 3 1 23 »
 
Рейтинг 4.76/37: Рейтинг темы: голосов - 37, средняя оценка - 4.76
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84

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

29.07.2011, 18:42. Показов 7726. Ответов 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
Programming
Эксперт
39485 / 9562 / 3019
Регистрация: 12.04.2006
Сообщений: 41,671
Блог
 29.07.2011, 18:42
Ответы с готовыми решениями:

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

Вектор битов и машинные слова
Всем здравствуйте. Делаю задание по универу и никак не могу разобраться в этой теме. Методичка еще прекрасно составлена олдовым человеком...

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

48
бжни
 Аватар для alex_x_x
2473 / 1684 / 135
Регистрация: 14.05.2009
Сообщений: 7,162
29.07.2011, 19:18
а если развернуть цикл?

Добавлено через 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
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
29.07.2011, 23:58  [ТС]
Надо будет проверить на время выполнения.
0
Модератор
Эксперт PythonЭксперт JavaЭксперт CЭксперт С++
 Аватар для easybudda
12843 / 7592 / 1766
Регистрация: 25.07.2009
Сообщений: 13,973
30.07.2011, 00:22
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
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 01:10  [ТС]
memcpy() использовать нельзя. од будет запускаться на ARM архитектуре и могут быть грабли с BigEndian / LittleEndian
0
 Аватар для TheAthlete
174 / 170 / 19
Регистрация: 31.08.2010
Сообщений: 575
30.07.2011, 09:46
Здравствуйте! Есть проще вариант. В с++ есть библиотечный тип 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
30.07.2011, 14:05

Не по теме:

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

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

Вариант со статической инициализацией векторов и дальнейшего использования нужного вектора - это максимально быстрый способ, очевидным минусом котрого является расход памяти. Точно так 30 лет назад в игрушках строились таблицы синусов и косинусов, чтобы на медленных процессорах не терять время на вычисление.
0
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 20:56  [ТС]
Под "лучше" я подразумеваю "быстрее". Время выполнения кода очень критично.
0
бжни
 Аватар для alex_x_x
2473 / 1684 / 135
Регистрация: 14.05.2009
Сообщений: 7,162
30.07.2011, 21:56
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Время выполнения кода очень критично.
и при этом используются стлные контейнеры?
0
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 22:24  [ТС]
Да. В программе нужны операции над битами (битстаффинг, скремблинг). Для хранения битов используются вектора байтов.
0
Evg
Эксперт CАвтор FAQ
 Аватар для Evg
21281 / 8305 / 637
Регистрация: 30.03.2009
Сообщений: 22,660
Записей в блоге: 30
30.07.2011, 23:23
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Время выполнения кода очень критично.
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Да. В программе нужны операции над битами (битстаффинг, скремблинг). Для хранения битов используются вектора байтов.
Если критично, мне кажется это лучше на си или на ассемблере писать. Для битовых операций типа срамбла на некоторых процессорах есть операции, хз как на Arm'е
0
 Аватар для igorrr37
2872 / 2019 / 991
Регистрация: 21.12.2010
Сообщений: 3,751
Записей в блоге: 10
30.07.2011, 23:31
вот так получилось быстрее таблицы
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
 Аватар для Evg
21281 / 8305 / 637
Регистрация: 30.03.2009
Сообщений: 22,660
Записей в блоге: 30
30.07.2011, 23:40
Цитата Сообщение от igorrr37 Посмотреть сообщение
вот так получилось быстрее таблицы
У него просто таблица коряво реализована. В таблице должно быть просто копирование подготовленного значения без каких-либо дополнительный вычислений
0
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
31.07.2011, 01:24  [ТС]
А почему коряво? Заносим в вектор значение по заданному индексу из массива. push_back() уже вычисленное значение.
0
Делаю внезапно и красиво
Эксперт С++
 Аватар для Deviaphan
1313 / 1228 / 72
Регистрация: 22.03.2011
Сообщений: 3,744
31.07.2011, 07:14
Максимальная эффективность будет только у таблицы менее 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;
Разумеется, тестировать нужно в релизе со включенными оптимизациями. Выражение в скобочках вычисляется во время компиляции.
0
Эксперт С++
1069 / 848 / 60
Регистрация: 30.04.2011
Сообщений: 1,659
31.07.2011, 10:00
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Под "лучше" я подразумеваю "быстрее". Время выполнения кода очень критично.
Тогда не вектор, а массив.
Через таблицу - самое быстрое.
Хотя можно не массив из 8 элементов, а константы-строки "00000001", "00000010"... И.т.д.
Меньше памяти.
0
Evg
Эксперт CАвтор FAQ
 Аватар для Evg
21281 / 8305 / 637
Регистрация: 30.03.2009
Сообщений: 22,660
Записей в блоге: 30
31.07.2011, 10:46
Цитата Сообщение от snayperAlfa Посмотреть сообщение
А почему коряво? Заносим в вектор значение по заданному индексу из массива. push_back() уже вычисленное значение.
В таблице у тебя должны быть не байты, а уже готовые вектора, которые нужно просто скопировать. А ещё лучше - взять ссылку на готовый вектор (read-only, естественно), тогда это будет сравнимо по скорости с индексацией одного элемента скалярного массива
0
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
31.07.2011, 17:51  [ТС]
Цитата Сообщение от Evg Посмотреть сообщение
В таблице у тебя должны быть не байты, а уже готовые вектора, которые нужно просто скопировать. А ещё лучше - взять ссылку на готовый вектор (read-only, естественно), тогда это будет сравнимо по скорости с индексацией одного элемента скалярного массива
Хм. То-есть, каждый раз при вызове этой функции будет создаваться 256 векторов, в каждый из них будут push_back() соответствующие биты, потом эти вектора заноситься в массив, а потом уже возвращаться в качестве преобразованного значения?
0
Evg
Эксперт CАвтор FAQ
 Аватар для Evg
21281 / 8305 / 637
Регистрация: 30.03.2009
Сообщений: 22,660
Записей в блоге: 30
31.07.2011, 18:30
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Хм. То-есть, каждый раз при вызове этой функции будет создаваться 256 векторов, в каждый из них будут push_back() соответствующие биты, потом эти вектора заноситься в массив, а потом уже возвращаться в качестве преобразованного значения?
Нет. В самом начале программы у тебя будет инициализация таблицы. Ты делаешь 256 раз по 8 push_back'ов. А в том месте, где тебе нужно сконвертировать байт в вектор, ты просто копируешь соотвествующий вектор из таблицы
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
inter-admin
Эксперт
29715 / 6470 / 2152
Регистрация: 06.03.2009
Сообщений: 28,500
Блог
 31.07.2011, 18:30
Помогаю со студенческими работами здесь

Самый быстрый способ дополнить вектор массивом
есть вектор заполненный нулями: vector&lt;int&gt; v(100000); есть большой массив: int ar; for (int i = 0; i &lt; 100000;...

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

Из двух целых чисел А и B собрать одно, состоящее из четных битов A и нечетных битов B...
Нужна помощь с задачей. Из двух целых чисел А и B собрать одно, состоящее из четных битов A и нечетных битов B

Чтение байта в режиме SPI 9 битов
Разбираюсь с интерфейсом SPI 9 битов, возник вопрос по чтению из дисплея от Nokia. При записи в дисплей команды/данных посылаем 9 битов,...

Запись битов ячейки памяти (2 байта) в обратном порядке (вставка в программе на С++)
3. С помощью логических операций реализуйте запись битов в данной ячейки памяти, размером в 2 байта, в обратном порядке.


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

Или воспользуйтесь поиском по форуму:
20
Ответ Создать тему
1 из 3 1 23 »
Новые блоги и статьи
http://iceja.net/ математические сервисы
iceja 20.01.2026
Обновила свой сайт http:/ / iceja. net/ , приделала Fast Fourier Transform экстраполяцию сигналов. Однако предсказывает далеко не каждый сигнал (см ограничения http:/ / iceja. net/ fourier/ docs ). Также. . .
http://iceja.net/ сервер решения полиномов
iceja 18.01.2026
Выкатила http:/ / iceja. net/ сервер решения полиномов (находит действительные корни полиномов методом Штурма). На сайте документация по API, но скажу прямо VPS слабенький и 200 000 полиномов. . .
Расчёт переходных процессов в цепи постоянного тока
igorrr37 16.01.2026
/ * Дана цепь(не выше 3-го порядка) постоянного тока с элементами R, L, C, k(ключ), U, E, J. Программа находит переходные токи и напряжения на элементах схемы классическим методом(1 и 2 з-ны. . .
Восстановить юзерскрипты Greasemonkey из бэкапа браузера
damix 15.01.2026
Если восстановить из бэкапа профиль Firefox после переустановки винды, то список юзерскриптов в Greasemonkey будет пустым. Но восстановить их можно так. Для этого понадобится консольная утилита. . .
Сукцессия микоризы: основная теория в виде двух уравнений.
anaschu 11.01.2026
https:/ / rutube. ru/ video/ 7a537f578d808e67a3c6fd818a44a5c4/
WordPad для Windows 11
Jel 10.01.2026
WordPad для Windows 11 — это приложение, которое восстанавливает классический текстовый редактор WordPad в операционной системе Windows 11. После того как Microsoft исключила WordPad из. . .
Classic Notepad for Windows 11
Jel 10.01.2026
Old Classic Notepad for Windows 11 Приложение для Windows 11, позволяющее пользователям вернуть классическую версию текстового редактора «Блокнот» из Windows 10. Программа предоставляет более. . .
Почему дизайн решает?
Neotwalker 09.01.2026
В современном мире, где конкуренция за внимание потребителя достигла пика, дизайн становится мощным инструментом для успеха бренда. Это не просто красивый внешний вид продукта или сайта — это. . .
КиберФорум - форум программистов, компьютерный форум, программирование
Поддержать - Реклама - Условия использования - Обратная связь
Powered by vBulletin
Copyright ©2000 - 2026, CyberForum.ru