Форум программистов, компьютерный форум, киберфорум
С++ для начинающих
Форум программистов и сисадминов Киберфорум > Форум программистов > 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. Показов 7916. Ответов 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,977
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
2895 / 2042 / 992
Регистрация: 21.12.2010
Сообщений: 3,791
Записей в блоге: 9
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 »
Новые блоги и статьи
Контроль заполнения и очистка дат в зависимости от значения перечислений
Maks 12.04.2026
Алгоритм из решения ниже реализован на примере нетипового документа "ПланированиеПерсонала", разработанного в конфигурации КА2. Задача: реализовать контроль корректности заполнения дат назначения. . .
Архитектура слоя интернета для сервера-слоя.
Hrethgir 11.04.2026
В продолжение https:/ / www. cyberforum. ru/ blogs/ 223907/ 10860. html Знаешь что я подумал? Раз мы все источники пишем в голове ветки, то ничего не мешает добавить в голову такой источник, который сам. . .
Подстановка значения реквизита справочника в табличную часть документа
Maks 10.04.2026
Алгоритм из решения ниже реализован на примере нетипового документа "ПланированиеПерсонала", разработанного в конфигурации КА2. Задача: при выборе сотрудника (справочник Сотрудники) в ТЧ документа. . .
Очистка реквизитов документа при копировании
Maks 09.04.2026
Алгоритм из решения ниже применим как для типовых, так и для нетиповых документов на самых различных конфигурациях. Задача: при копировании документа очищать определенные реквизиты и табличную. . .
модель ЗдравоСохранения 8. Подготовка к разному выполнению заданий
anaschu 08.04.2026
https:/ / github. com/ shumilovas/ med2. git main ветка * содержимое блока дэлэй из старой модели теперь внутри зайца новой модели 8ATzM_2aurI
 Блокировка документа от изменений, если он открыт у другого пользователя
Maks 08.04.2026
Алгоритм из решения ниже реализован на примере нетипового документа, разработанного в конфигурации КА2. Задача: запретить редактирование документа, если он открыт у другого пользователя. / / . . .
Система безопасности+живучести для сервера-слоя интернета (сети). Двойная привязка.
Hrethgir 08.04.2026
Далее были размышления о системе безопасности. Сообщения с наклонным текстом - мои. А как нам будет можно проверить, что ссылка наша, а не подделана хулиганами, которая выбросит на другую ветку и. . .
Модель ЗдрввоСохранения 7: больше работников, больше ресурсов.
anaschu 08.04.2026
работников и заданий может быть сколько угодно, но настроено всё так, что используется пока что только 20% kYBz3eJf3jQ
КиберФорум - форум программистов, компьютерный форум, программирование
Поддержать - Реклама - Условия использования - Обратная связь
Powered by vBulletin
Copyright ©2000 - 2026, CyberForum.ru