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

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

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

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

29.07.2011, 18:42. Просмотров 4161. Ответов 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
Deviaphan
Делаю внезапно и красиво
Эксперт С++
1306 / 1221 / 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;
Разумеется, тестировать нужно в релизе со включенными оптимизациями. Выражение в скобочках вычисляется во время компиляции.
0
ValeryLaptev
Эксперт С++
1048 / 827 / 48
Регистрация: 30.04.2011
Сообщений: 1,659
31.07.2011, 10:00 #17
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Под "лучше" я подразумеваю "быстрее". Время выполнения кода очень критично.
Тогда не вектор, а массив.
Через таблицу - самое быстрое.
Хотя можно не массив из 8 элементов, а константы-строки "00000001", "00000010"... И.т.д.
Меньше памяти.
0
Evg
Эксперт CАвтор FAQ
18915 / 6874 / 503
Регистрация: 30.03.2009
Сообщений: 19,358
Записей в блоге: 30
31.07.2011, 10:46 #18
Цитата Сообщение от snayperAlfa Посмотреть сообщение
А почему коряво? Заносим в вектор значение по заданному индексу из массива. push_back() уже вычисленное значение.
В таблице у тебя должны быть не байты, а уже готовые вектора, которые нужно просто скопировать. А ещё лучше - взять ссылку на готовый вектор (read-only, естественно), тогда это будет сравнимо по скорости с индексацией одного элемента скалярного массива
0
snayperAlfa
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
31.07.2011, 17:51  [ТС] #19
Цитата Сообщение от Evg Посмотреть сообщение
В таблице у тебя должны быть не байты, а уже готовые вектора, которые нужно просто скопировать. А ещё лучше - взять ссылку на готовый вектор (read-only, естественно), тогда это будет сравнимо по скорости с индексацией одного элемента скалярного массива
Хм. То-есть, каждый раз при вызове этой функции будет создаваться 256 векторов, в каждый из них будут push_back() соответствующие биты, потом эти вектора заноситься в массив, а потом уже возвращаться в качестве преобразованного значения?
0
Evg
Эксперт CАвтор FAQ
18915 / 6874 / 503
Регистрация: 30.03.2009
Сообщений: 19,358
Записей в блоге: 30
31.07.2011, 18:30 #20
Цитата Сообщение от snayperAlfa Посмотреть сообщение
Хм. То-есть, каждый раз при вызове этой функции будет создаваться 256 векторов, в каждый из них будут push_back() соответствующие биты, потом эти вектора заноситься в массив, а потом уже возвращаться в качестве преобразованного значения?
Нет. В самом начале программы у тебя будет инициализация таблицы. Ты делаешь 256 раз по 8 push_back'ов. А в том месте, где тебе нужно сконвертировать байт в вектор, ты просто копируешь соотвествующий вектор из таблицы
0
easybudda
Модератор
Эксперт CЭксперт С++
10020 / 5943 / 1004
Регистрация: 25.07.2009
Сообщений: 11,230
31.07.2011, 18:54 #21
Я бы при таком подходе вообще как-то так сделал:
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
#include <stdio.h>
 
unsigned long long uchar2ll(unsigned char uc){
    static unsigned long long tbl[256] = 
    {   0x0ull, 0x1ull, 0x100ull, 0x101ull, 0x10000ull, 0x10001ull, 0x10100ull, 0x10101ull,
        0x1000000ull, 0x1000001ull, 0x1000100ull, 0x1000101ull, 0x1010000ull, 0x1010001ull, 0x1010100ull, 0x1010101ull,
        0x100000000ull, 0x100000001ull, 0x100000100ull, 0x100000101ull, 0x100010000ull, 0x100010001ull, 0x100010100ull, 0x100010101ull
    }; // всю таблицу лень писать
    return tbl[uc];
}
 
// just for show
void dump(const unsigned char * arr){
    int i;
    for ( i = 0; i < 8; ++i )
        printf("%d", arr[i]);
    printf("\n");
}
 
int main(void){
    int val;
    unsigned long long res;
    
    while ( printf("Number from 0 to 255: ") && scanf("%d", &val) == 1 && val > -1 && val < 256 ){
        res = uchar2ll((unsigned char)val);
        dump((unsigned char*)&res);
    }
    
    return 0;
}
Только таблицу соответственно нужно сделать с учётом заморочек с bigendian/littleendian, ну и всю до конца, разумеется...
0
alex_x_x
бжни
2454 / 1660 / 84
Регистрация: 14.05.2009
Сообщений: 7,162
31.07.2011, 20:48 #22
Цитата Сообщение от easybudda Посмотреть сообщение
Только таблицу соответственно нужно сделать с учётом заморочек с bigendian/littleendian,
а как это к битам относится?
0
TheAthlete
154 / 154 / 14
Регистрация: 31.08.2010
Сообщений: 538
31.07.2011, 21:02 #23
Посмотрел bitset, действительно работает медленнее. чем даже ваше старое решение.
Я думаю, если нужно самое быстрое решение, то на ум приходят следующие варианты
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
const size_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}};
Соответственно, чтобы получить значение, например, 25, нужно вызвать CharBitsTable[25][8]
это вероятно будет самый простой и быстрый вариант.

Т.к. вам нужно использовать вектора, то можно использовать подобный вариант:

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
const vector< vector<size_t> > CharBitsTable = {
                                {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}};
Данный код будет работать только в том случае, если в компиляторе есть поддержка стандарта c++0x

Ну, и третий вариант, тоже с созданием глобальной переменной, но до этого создается функция, которая все предварительно рассчитует (в случае если нет поддержки стандарта c++0x или не планируется его использовать) значение вектора и значение этой функции возвращается в глобальный вектор
0
snayperAlfa
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
31.07.2011, 21:56  [ТС] #24
Цитата Сообщение от Evg Посмотреть сообщение
Нет. В самом начале программы у тебя будет инициализация таблицы. Ты делаешь 256 раз по 8 push_back'ов. А в том месте, где тебе нужно сконвертировать байт в вектор, ты просто копируешь соотвествующий вектор из таблицы
Хм. Я так понимаю прирост будет если многократно использовать вначале созданный массив векторов. А для единичного преобразования остальное будет быстрее? У меня сейчас в программе эта функция конвертора является статическим методом класса B. И вызывается в классе A раз 5. После чего класс A уничтожается. Вижу что есть смысл в классе A создать экземпляр класса B, проинициализировать таблицу векторов и работать с этой таблицей.

А в данном варианте программы, который приведен у меня выше, при каждом вызове статического метода этот массив заново создается ведь?

Инициализация массива в теле класса B за пределами конструктора не увенчалась успехом. Даже если использовать static const

Добавлено через 48 минут
Цитата Сообщение от TheAthlete Посмотреть сообщение
const vector< vector<size_t> > CharBitsTable
А где собственно тип данных в векторе? Или это так по стандарту c++0x можно?
0
easybudda
Модератор
Эксперт CЭксперт С++
10020 / 5943 / 1004
Регистрация: 25.07.2009
Сообщений: 11,230
31.07.2011, 22:12 #25
Цитата Сообщение от alex_x_x Посмотреть сообщение
а как это к битам относится?
А Вы вот эту мою програмку откомпилируйте, запустите (с маленькими числами она работает) и сами всё поймёте...
1
alex_x_x
бжни
2454 / 1660 / 84
Регистрация: 14.05.2009
Сообщений: 7,162
31.07.2011, 22:29 #26
easybudda, все, понял
0
easybudda
Модератор
Эксперт CЭксперт С++
10020 / 5943 / 1004
Регистрация: 25.07.2009
Сообщений: 11,230
31.07.2011, 22:50 #27
alex_x_x, весь профит от такого подхода в том, что работать с массивом чисел даже типа long long по крайней мере в программе на С было бы легче и быстрее, чем с массивом массивов (я так понимаю - там не одно число должно обрабатываться)... Сами же числа типа unsigned long long используются просто, как массив unsigned char[8]
0
Evg
Эксперт CАвтор FAQ
18915 / 6874 / 503
Регистрация: 30.03.2009
Сообщений: 19,358
Записей в блоге: 30
31.07.2011, 23:12 #28
Цитата Сообщение от snayperAlfa Посмотреть сообщение
И вызывается в классе A раз 5
Если вызывается только 5 раз, то так, конечно же, делать не надо. Я-то думал, что там много раз, коль скоро речь зашла о критичности по скорости
1
TheAthlete
154 / 154 / 14
Регистрация: 31.08.2010
Сообщений: 538
01.08.2011, 08:25 #29
Цитата Сообщение от snayperAlfa Посмотреть сообщение
А где собственно тип данных в векторе? Или это так по стандарту c++0x можно?
const vector< vector<size_t> > CharBitsTable - это двумерный вложенный вектор. По сути вектор векторов. Допустим внешний вектор содержит 256 значений, и каждый внутренний содержит соответствующий ему набор из битов.

Что-бы получить вектор, который содержит нужное значение (из 256), нужно обратиться как к массиву (используя индексацию):

C++
1
2
vector<size_t> vec;
vec = CharBitsTable[25];
Здесь мы обратились к внешнему вектору, чтобы получить соответствующий ему внутренний набор битов. А size_t - это беззнаковый целочисленный тип, можно использовать любой другой.

Насчет c++0x: данная конструкция (вложенные вектора) может работать и в старом стандарте, а вот инициализация вектора как в массиве (с помощью фигурных скобок, а не используя тучу push_back) появилась только в стандарте c++0x
0
Evg
Эксперт CАвтор FAQ
18915 / 6874 / 503
Регистрация: 30.03.2009
Сообщений: 19,358
Записей в блоге: 30
01.08.2011, 08:53 #30
Цитата Сообщение от TheAthlete Посмотреть сообщение
а вот инициализация вектора как в массиве (с помощью фигурных скобок, а не используя тучу push_back) появилась только в стандарте c++0x
Насколько я понимаю, в итоговом коде это всё равно выливается в динамическую инициализацию, а не в статическую?
0
01.08.2011, 08:53
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
01.08.2011, 08:53
Привет! Вот еще темы с ответами:

Есть квадратная матрица А порядка 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) и безопасный вектор с проверкой выхода за пределы. Безопасный...


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

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

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