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

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

29.07.2011, 18:42. Показов 6745. Ответов 48
Метки нет (Все метки)
Author24 — интернет-сервис помощи студентам
Всем привет. Есть тут интересная задачка: перевести байт в вектор битов, да побыстрее.

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

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
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
 29.07.2011, 18:42
Ответы с готовыми решениями:

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

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

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

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

48
бжни
2473 / 1684 / 135
Регистрация: 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
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
29.07.2011, 23:58  [ТС] 3
Надо будет проверить на время выполнения.
0
Модератор
Эксперт PythonЭксперт JavaЭксперт CЭксперт С++
12454 / 7479 / 1752
Регистрация: 25.07.2009
Сообщений: 13,755
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
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 01:10  [ТС] 5
memcpy() использовать нельзя. од будет запускаться на ARM архитектуре и могут быть грабли с BigEndian / LittleEndian
0
174 / 170 / 19
Регистрация: 31.08.2010
Сообщений: 573
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
21279 / 8301 / 637
Регистрация: 30.03.2009
Сообщений: 22,659
Записей в блоге: 30
30.07.2011, 16:08 8
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Я реализовал это дело через таблицу. Кто знает способ лучше ?
Что ты подразумеваешь под "лучше"?

Вариант со статической инициализацией векторов и дальнейшего использования нужного вектора - это максимально быстрый способ, очевидным минусом котрого является расход памяти. Точно так 30 лет назад в игрушках строились таблицы синусов и косинусов, чтобы на медленных процессорах не терять время на вычисление.
0
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 20:56  [ТС] 9
Под "лучше" я подразумеваю "быстрее". Время выполнения кода очень критично.
0
бжни
2473 / 1684 / 135
Регистрация: 14.05.2009
Сообщений: 7,162
30.07.2011, 21:56 10
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Время выполнения кода очень критично.
и при этом используются стлные контейнеры?
0
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
30.07.2011, 22:24  [ТС] 11
Да. В программе нужны операции над битами (битстаффинг, скремблинг). Для хранения битов используются вектора байтов.
0
Evg
Эксперт CАвтор FAQ
21279 / 8301 / 637
Регистрация: 30.03.2009
Сообщений: 22,659
Записей в блоге: 30
30.07.2011, 23:23 12
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Время выполнения кода очень критично.
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Да. В программе нужны операции над битами (битстаффинг, скремблинг). Для хранения битов используются вектора байтов.
Если критично, мне кажется это лучше на си или на ассемблере писать. Для битовых операций типа срамбла на некоторых процессорах есть операции, хз как на Arm'е
0
2848 / 1997 / 986
Регистрация: 21.12.2010
Сообщений: 3,705
Записей в блоге: 10
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
21279 / 8301 / 637
Регистрация: 30.03.2009
Сообщений: 22,659
Записей в блоге: 30
30.07.2011, 23:40 14
Цитата Сообщение от igorrr37 Посмотреть сообщение
вот так получилось быстрее таблицы
У него просто таблица коряво реализована. В таблице должно быть просто копирование подготовленного значения без каких-либо дополнительный вычислений
0
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
31.07.2011, 01:24  [ТС] 15
А почему коряво? Заносим в вектор значение по заданному индексу из массива. push_back() уже вычисленное значение.
0
Делаю внезапно и красиво
Эксперт С++
1313 / 1228 / 72
Регистрация: 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;
Разумеется, тестировать нужно в релизе со включенными оптимизациями. Выражение в скобочках вычисляется во время компиляции.
0
Эксперт С++
1069 / 848 / 60
Регистрация: 30.04.2011
Сообщений: 1,659
31.07.2011, 10:00 17
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Под "лучше" я подразумеваю "быстрее". Время выполнения кода очень критично.
Тогда не вектор, а массив.
Через таблицу - самое быстрое.
Хотя можно не массив из 8 элементов, а константы-строки "00000001", "00000010"... И.т.д.
Меньше памяти.
0
Evg
Эксперт CАвтор FAQ
21279 / 8301 / 637
Регистрация: 30.03.2009
Сообщений: 22,659
Записей в блоге: 30
31.07.2011, 10:46 18
Цитата Сообщение от snayperAlfa Посмотреть сообщение
А почему коряво? Заносим в вектор значение по заданному индексу из массива. push_back() уже вычисленное значение.
В таблице у тебя должны быть не байты, а уже готовые вектора, которые нужно просто скопировать. А ещё лучше - взять ссылку на готовый вектор (read-only, естественно), тогда это будет сравнимо по скорости с индексацией одного элемента скалярного массива
0
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
31.07.2011, 17:51  [ТС] 19
Цитата Сообщение от Evg Посмотреть сообщение
В таблице у тебя должны быть не байты, а уже готовые вектора, которые нужно просто скопировать. А ещё лучше - взять ссылку на готовый вектор (read-only, естественно), тогда это будет сравнимо по скорости с индексацией одного элемента скалярного массива
Хм. То-есть, каждый раз при вызове этой функции будет создаваться 256 векторов, в каждый из них будут push_back() соответствующие биты, потом эти вектора заноситься в массив, а потом уже возвращаться в качестве преобразованного значения?
0
Evg
Эксперт CАвтор FAQ
21279 / 8301 / 637
Регистрация: 30.03.2009
Сообщений: 22,659
Записей в блоге: 30
31.07.2011, 18:30 20
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Хм. То-есть, каждый раз при вызове этой функции будет создаваться 256 векторов, в каждый из них будут push_back() соответствующие биты, потом эти вектора заноситься в массив, а потом уже возвращаться в качестве преобразованного значения?
Нет. В самом начале программы у тебя будет инициализация таблицы. Ты делаешь 256 раз по 8 push_back'ов. А в том месте, где тебе нужно сконвертировать байт в вектор, ты просто копируешь соотвествующий вектор из таблицы
0
31.07.2011, 18:30
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
 31.07.2011, 18:30
Помогаю со студенческими работами здесь

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

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

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

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


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

Или воспользуйтесь поиском по форуму:
20
Ответ Создать тему
1 из 3 1 23 »
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Поддержать - Реклама - Обратная связь
Powered by vBulletin
Copyright ©2000 - 2024, CyberForum.ru