Форум программистов, компьютерный форум, киберфорум
Наши страницы
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
 
Рейтинг 4.83/23: Рейтинг темы: голосов - 23, средняя оценка - 4.83
snayperAlfa
2 / 2 / 1
Регистрация: 13.08.2008
Сообщений: 84
#1

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

29.07.2011, 18:42. Просмотров 4232. Ответов 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
Ответы с готовыми решениями:

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

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

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

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

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

48
easybudda
Модератор
Эксперт CЭксперт С++
10055 / 5975 / 1493
Регистрация: 25.07.2009
Сообщений: 11,323
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
бжни
2455 / 1661 / 134
Регистрация: 14.05.2009
Сообщений: 7,162
31.07.2011, 20:48 #22
Цитата Сообщение от easybudda Посмотреть сообщение
Только таблицу соответственно нужно сделать с учётом заморочек с bigendian/littleendian,
а как это к битам относится?
0
TheAthlete
154 / 154 / 16
Регистрация: 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Эксперт С++
10055 / 5975 / 1493
Регистрация: 25.07.2009
Сообщений: 11,323
31.07.2011, 22:12 #25
Цитата Сообщение от alex_x_x Посмотреть сообщение
а как это к битам относится?
А Вы вот эту мою програмку откомпилируйте, запустите (с маленькими числами она работает) и сами всё поймёте...
1
alex_x_x
бжни
2455 / 1661 / 134
Регистрация: 14.05.2009
Сообщений: 7,162
31.07.2011, 22:29 #26
easybudda, все, понял
0
easybudda
Модератор
Эксперт CЭксперт С++
10055 / 5975 / 1493
Регистрация: 25.07.2009
Сообщений: 11,323
31.07.2011, 22:50 #27
alex_x_x, весь профит от такого подхода в том, что работать с массивом чисел даже типа long long по крайней мере в программе на С было бы легче и быстрее, чем с массивом массивов (я так понимаю - там не одно число должно обрабатываться)... Сами же числа типа unsigned long long используются просто, как массив unsigned char[8]
0
Evg
Эксперт CАвтор FAQ
19282 / 7139 / 528
Регистрация: 30.03.2009
Сообщений: 19,986
Записей в блоге: 30
31.07.2011, 23:12 #28
Цитата Сообщение от snayperAlfa Посмотреть сообщение
И вызывается в классе A раз 5
Если вызывается только 5 раз, то так, конечно же, делать не надо. Я-то думал, что там много раз, коль скоро речь зашла о критичности по скорости
1
TheAthlete
154 / 154 / 16
Регистрация: 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
19282 / 7139 / 528
Регистрация: 30.03.2009
Сообщений: 19,986
Записей в блоге: 30
01.08.2011, 08:53 #30
Цитата Сообщение от TheAthlete Посмотреть сообщение
а вот инициализация вектора как в массиве (с помощью фигурных скобок, а не используя тучу push_back) появилась только в стандарте c++0x
Насколько я понимаю, в итоговом коде это всё равно выливается в динамическую инициализацию, а не в статическую?
0
TheAthlete
154 / 154 / 16
Регистрация: 31.08.2010
Сообщений: 538
01.08.2011, 11:32 #31
Цитата Сообщение от Evg Посмотреть сообщение
Насколько я понимаю, в итоговом коде это всё равно выливается в динамическую инициализацию, а не в статическую?
но если критична скорость, то лучше статическую, т.е. как я уже писал, создать глобальную переменную и уже в коде ее использовать. (не до конца понял, что выливается в динамическую инициализацию). Если создавать с помощью функции-члена класса или функции, то динамически будет создаваться, т.е. при каждом запуске функции будет генериться заново код
0
Evg
Эксперт CАвтор FAQ
19282 / 7139 / 528
Регистрация: 30.03.2009
Сообщений: 19,986
Записей в блоге: 30
01.08.2011, 14:36 #32
Цитата Сообщение от TheAthlete Посмотреть сообщение
не до конца понял, что выливается в динамическую инициализацию
Выливается то, что я процитировал. Т.е. в исходнике ты пишешь как буд-то это статическая инициализация (т.е. память под вектора раписывается на этапе компиляции), но компилятор реально сгенерирует динамическую инициализацию (т.е. неведомо для пользователя сгенерируется код с push_back'ами, который вызовется перед main'ом). Это так или не так?
0
Deviaphan
Делаю внезапно и красиво
Эксперт С++
1306 / 1221 / 72
Регистрация: 22.03.2011
Сообщений: 3,744
01.08.2011, 15:06 #33
Цитата Сообщение от Evg Посмотреть сообщение
Это так или не так?
Если это не прописано в стандарте, то может быть всё что угодно.
Если рассуждать логически, то есть два варианта:
1. неявные пушбэки
2. неявный инсерт

При статической инициализации деструктор вектора не правильно отработает, так что это не реально. Или в него добавлять флажок о его "статичности".
0
Evg
Эксперт CАвтор FAQ
19282 / 7139 / 528
Регистрация: 30.03.2009
Сообщений: 19,986
Записей в блоге: 30
01.08.2011, 15:14 #34
Цитата Сообщение от Deviaphan Посмотреть сообщение
Если это не прописано в стандарте, то может быть всё что угодно.
Если рассуждать логически, то есть два варианта:
1. неявные пушбэки
2. неявный инсерт
Поскольку я не знаю стадарта, никогда не работал с указнной версией Си++, имею недостаточный опыт работы на Си++, чтобы понять, как вообще возможно сделать статическую инициализацию вектора, потому и задал вопрос. И у меня было дикое подозрение, что укзанная конструкция, которая появилась в стандарте c++0x - это всего лишь более удобная форма записи, которая на самом деле приведёт к тому же самому коду. Т.е. выигрыша в скорости оно не даст

Цитата Сообщение от Deviaphan Посмотреть сообщение
При статической инициализации деструктор вектора не правильно отработает, так что это не реально. Или в него добавлять флажок о его "статичности"
Разработчики Си++ всё-таки народ ушлый и могли добавить в язык очередные нанорасширения, правда всё равно не представляю, как это можно было бы сделать на уровне статической инициаизации
0
Deviaphan
Делаю внезапно и красиво
Эксперт С++
1306 / 1221 / 72
Регистрация: 22.03.2011
Сообщений: 3,744
01.08.2011, 15:25 #35
Цитата Сообщение от Evg Посмотреть сообщение
никогда не работал с указнной версией Си++
Та же печалька. Ещё лет 3-5 можно сильно по этому поводу не напрягаться. Пока всё утрясётся, пока поддержка во всех компиляторах появится...

Цитата Сообщение от Evg Посмотреть сообщение
правда всё равно не представляю, как это можно было бы сделать на уровне статической инициаизации
Типо такого:
C++
1
2
3
4
5
6
7
8
// вот такую запись
const std::Vector<int> staticVector = {1,2,3,4,5,6,7,8,9,10};
//преобразует вот в такую
const int staticArray[10] = {..};
const int std::vector<int> staticVector( staticArray, &staticArray[10]);
//или
staticVector.reserve(10);
memcpy( &staticVector[0], sizeof(int)*10, staticArray );
Это предельно просто по сравнению с некоторыми другими извращениями, которые уже реализованы.
0
asics
Freelance
Эксперт С++
2854 / 1789 / 355
Регистрация: 09.09.2010
Сообщений: 3,841
01.08.2011, 15:39 #36
Цитата Сообщение от Deviaphan Посмотреть сообщение
C++
1
2
3
4
5
// вот такую запись
const std::Vector<int> staticVector = {1,2,3,4,5,6,7,8,9,10};
//преобразует вот в такую
const int staticArray[10] = {..};
const int std::vector<int> staticVector( staticArray, &staticArray[10]);
Ничего там не будет преобразововаться, просто вызовется такой конструктор:
C++
1
2
3
4
5
6
7
vector(initializer_list<value_type> __l,
         const allocator_type& __a = allocator_type())
      : _Base(__a)
      {
    _M_range_initialize(__l.begin(), __l.end(),
                random_access_iterator_tag());
      }
mingw 4.6.0
0
Deviaphan
Делаю внезапно и красиво
Эксперт С++
1306 / 1221 / 72
Регистрация: 22.03.2011
Сообщений: 3,744
01.08.2011, 15:47 #37
Цитата Сообщение от asics Посмотреть сообщение
Ничего там не будет преобразововаться
Найди два отличия.)))
Цитата Сообщение от asics Посмотреть сообщение
staticVector( staticArray, &staticArray[10]);
и
Цитата Сообщение от asics Посмотреть сообщение
_M_range_initialize(__l.begin(), __l.end(), random_access_iterator_tag());
По сути одно и то же.
Но мы же говорим не о списке инициализации, а о Статической инициализации, а это две большие разницы.

Добавлено через 18 секунд
Цитата Сообщение от Deviaphan Посмотреть сообщение
Найди два отличия.)))
В смысле десять...
0
asics
Freelance
Эксперт С++
2854 / 1789 / 355
Регистрация: 09.09.2010
Сообщений: 3,841
01.08.2011, 15:50 #38
Deviaphan, Просто я подумал, что этим
Цитата Сообщение от Deviaphan Посмотреть сообщение
//преобразует вот в такую
ты хотел сказать, что вызоветься именно конструктор для этой записи

Цитата Сообщение от Deviaphan Посмотреть сообщение
C++
1
2
const int staticArray[10] = {..};
const int std::vector<int> staticVector( staticArray, &staticArray[10]);
, а не для этой

Цитата Сообщение от Deviaphan Посмотреть сообщение
C++
1
const std::Vector<int> staticVector = {1,2,3,4,5,6,7,8,9,10};
0
TheAthlete
154 / 154 / 16
Регистрация: 31.08.2010
Сообщений: 538
01.08.2011, 16:39 #39
Цитата Сообщение от asics Посмотреть сообщение
vector(initializer_list<value_type> __l,
const allocator_type& __a = allocator_type())
: _Base(__a)
{
_M_range_initialize(__l.begin(), __l.end(),
random_access_iterator_tag());
}
хотя если развернуть еще дальше, т.е. посмотреть, что делает функция _M_range_initialize, то получим push_back:

C++
1
2
3
4
5
// Called by the second initialize_dispatch above
      template<typename _InputIterator>
      void _M_range_initialize(_InputIterator __first, _InputIterator __last, std::input_iterator_tag) {
        for (; __first != __last; ++__first)
          push_back(*__first);
что и требовалось доказать
0
Evg
Эксперт CАвтор FAQ
19282 / 7139 / 528
Регистрация: 30.03.2009
Сообщений: 19,986
Записей в блоге: 30
01.08.2011, 16:44 #40
Цитата Сообщение от Deviaphan Посмотреть сообщение
Типо такого:
C++
1
2
3
4
5
6
7
8
// вот такую запись
const std::Vector<int> staticVector = {1,2,3,4,5,6,7,8,9,10};
//преобразует вот в такую
const int staticArray[10] = {..};
const int std::vector<int> staticVector( staticArray, &staticArray[10]);
//или
staticVector.reserve(10);
memcpy( &staticVector[0], sizeof(int)*10, staticArray );
Это предельно просто по сравнению с некоторыми другими извращениями, которые уже реализованы.
Ни то, ни другое, ни ниже приведённые примеры - это НЕ статическая инициализация, потому что она выполняется НЕ compile-time, а run-time. Я потом и говорил, что не понимаю, как это можно сделать статически.
0
01.08.2011, 16:44
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
01.08.2011, 16:44

Операции с побитовыми операторами (число 8 битов и число 9 битов)
Доброго времени суток всем ! Прошу ответа на несложный вопрос (...по крайней...

Класс "вектор" с конструкторами, позволяющими создать нулевой вектор и вектор с произвольным числом элементов
Привет! Задача следующая. Нужно реализовать класс &quot;вектор&quot; с...

Создать иерархию классов вектор и безопасный вектор с проверкой выхода за пределы
Создать иерархию классов вектор и безопасный вектор с проверкой выхода за...


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

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

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