Форум программистов, компьютерный форум, киберфорум
C++: Сети
Войти
Регистрация
Восстановить пароль
 
Рейтинг 4.67/6: Рейтинг темы: голосов - 6, средняя оценка - 4.67
2 / 2 / 0
Регистрация: 09.09.2015
Сообщений: 7
1

C\C++ Битстаффинг (Bitstuffing)

30.09.2015, 14:30. Просмотров 1060. Ответов 5
Метки нет (Все метки)

Добрый день, уважаемые господа и дамы. Стоит задача реализовать битстаффинг, забитстаффить инфу на одном компе, передать на другой, разбитстаффить. Битстаффинг с флагом начала "0111 1110" (то есть после каждой пятой единички надо вставить ноль). Реализация передачи сообщений уже есть. Под сообщением имеется в виду структура : IPsrc, IPdst, Data(String). Знаю, как найти эти пять единичек. Не могу понять, как можно структуру преобразовать в последовательность битов, вставить туда нули, где нужно, а потом, после удаления нулей преобразовать обратно.

Я думаю так : Берем структуру, добавляем туда дополнительные байты, чтобы было, куда смещаться структуре после добавления ноликов в данные, а как дальше с ней работать не знаю.

Уважаемые профессиналы, очень расчитываю на вашу помощь. Задание - лаба в универе.
Заранее спасибо за любую помощь. Было бы просто супер хотя бы понять, как работать с структурой, как последовательностью байтов.
0
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
30.09.2015, 14:30
Ответы с готовыми решениями:

Битстаффинг
Всем привет. Есть такой термин - Битстаффинг. Это бит-ориетированная процедура по вставке "0" после...

Verilog. Битстаффинг и дестаффинг
Попытался я сымитировать битстаффинг (предупреждение появления последовательностей из 5 нулей или...


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

Или воспользуйтесь поиском по форуму:
5
Модератор
3309 / 2099 / 334
Регистрация: 13.01.2012
Сообщений: 8,160
30.09.2015, 14:48 2
пример ф-ий для "работы" с битами. если есть структура - берем ее адрес и приводим к unsigned char * - вот у нас и структура как последовательность байт/бит удобном для работе виде
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
//------------------------------------------------------------------------------
/*
ф-ии для работы с битами
bit_shift - смещение относительно младшего бита
    bit_shift = 0 .. 15
*/
//------------------------------------------------------------------------------
bool get_bit(const unsigned bits, const unsigned bit_shift);
unsigned set_bit
(
    const unsigned bits, const unsigned bit_shift, const bool bit
);
//------------------------------------------------------------------------------
/*
чтение и запись битов
прямой порядок битов в байте:
    бит 0
    бит 1
    ..
    бит countof_bits - 1
*/
//------------------------------------------------------------------------------
bool f_read_bit
(
    const unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift //смещение относительно младшего бита
);
void f_write_bit
(
    unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift, //смещение относительно младшего бита
    const bool bit
);
 
unsigned f_read_bits
(
    const unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift, //смещение относительно младшего бита
    const unsigned countof_bits //countof_bits = 0 .. 16
);
void f_write_bits
(
    unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift, //смещение относительно младшего бита
    const unsigned countof_bits, //countof_bits = 0 .. 16
    const unsigned bits
);
//------------------------------------------------------------------------------
/*
чтение и запись битов
обратный порядок битов в байте:
    бит countof_bits - 1
    ..
    бит 1
    бит 0
*/
//------------------------------------------------------------------------------
bool i_read_bit
(
    const unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift //смещение относительно старшего бита
);
void i_write_bit
(
    unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift, //смещение относительно старшего бита
    const bool bit
);
 
unsigned i_read_bits
(
    const unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift, //смещение относительно старшего бита
    const unsigned countof_bits //countof_bits = 0 .. 16
);
void i_write_bits
(
    unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift, //смещение относительно старшего бита
    const unsigned countof_bits, //countof_bits = 0 .. 16
    const unsigned bits
);
//==============================================================================
bool get_bit(const unsigned bits, const unsigned bit_shift)
{
    return bits & (1U << bit_shift);
}
//------------------------------------------------------------------------------
unsigned set_bit
(
    const unsigned bits, const unsigned bit_shift, const bool bit
)
{
    if (bit) return bits | (1U << bit_shift);
    return bits & ~(1U << bit_shift);
}
//==============================================================================
bool f_read_bit
(
    const unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift
)
{
    bool res = get_bit
    (
        *(buffer + *byte_shift),
        *bit_shift
    );
 
    (*bit_shift)++;
 
    if (*bit_shift > 7)
    {
        *bit_shift = 0;
        (*byte_shift)++;
    }
 
    return res;
}
//------------------------------------------------------------------------------
void f_write_bit
(
    unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift,
    const bool bit
)
{
    *(buffer + *byte_shift) = set_bit
    (
        *(buffer + *byte_shift),
        *bit_shift,
        bit
    );
 
    (*bit_shift)++;
 
    if (*bit_shift > 7)
    {
        *bit_shift = 0;
        (*byte_shift)++;
    }
}
//------------------------------------------------------------------------------
unsigned f_read_bits
(
    const unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift,
    const unsigned countof_bits
)
{
    unsigned res = 0;
 
    for (unsigned bit_index = 0; bit_index < countof_bits; bit_index++)
        res = set_bit
        (
            res,
            bit_index,
            f_read_bit(buffer, byte_shift, bit_shift)
        );
 
    return res;
}
//------------------------------------------------------------------------------
void f_write_bits
(
    unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift,
    const unsigned countof_bits,
    const unsigned bits
)
{
    for (unsigned bit_index = 0; bit_index < countof_bits; bit_index++)
        f_write_bit
        (
            buffer, byte_shift, bit_shift,
            get_bit(bits, bit_index)
        );
}
//==============================================================================
bool i_read_bit
(
    const unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift
)
{
    bool res = get_bit
    (
        *(buffer + *byte_shift),
        7 - *bit_shift
    );
 
    (*bit_shift)++;
 
    if (*bit_shift > 7)
    {
        *bit_shift = 0;
        (*byte_shift)++;
    }
 
    return res;
}
//------------------------------------------------------------------------------
void i_write_bit
(
    unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift,
    const bool bit
)
{
    *(buffer + *byte_shift) = set_bit
    (
        *(buffer + *byte_shift),
        7 - *bit_shift,
        bit
    );
 
    (*bit_shift)++;
 
    if (*bit_shift > 7)
    {
        *bit_shift = 0;
        (*byte_shift)++;
    }
}
//------------------------------------------------------------------------------
unsigned i_read_bits
(
    const unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift,
    const unsigned countof_bits
)
{
    unsigned res = 0;
 
    for (unsigned bit_index = 0; bit_index < countof_bits; bit_index++)
        res = set_bit
        (
            res,
            (countof_bits - 1) - bit_index,
            i_read_bit(buffer, byte_shift, bit_shift)
        );
 
    return res;
}
//------------------------------------------------------------------------------
void i_write_bits
(
    unsigned char *buffer,
    unsigned long * const byte_shift,
    unsigned * const bit_shift,
    const unsigned countof_bits,
    const unsigned bits
)
{
    for (unsigned bit_index = 0; bit_index < countof_bits; bit_index++)
        i_write_bit
        (
            buffer, byte_shift, bit_shift,
            get_bit(bits, (countof_bits - 1) - bit_index)
        );
}
1
653 / 574 / 164
Регистрация: 13.12.2012
Сообщений: 2,124
01.10.2015, 09:56 3
Цитата Сообщение от Ligvest Посмотреть сообщение
Я думаю так : Берем структуру, добавляем туда дополнительные байты, чтобы было, куда смещаться структуре после добавления ноликов в данные, а как дальше с ней работать не знаю.
C++
1
2
3
4
5
6
7
8
9
struct A
{
int a;
int b;
int c;
};
 
A obj;
unsigned char * ptr = &obj;
дальше работаем как с последовательностью байт размером sizeof(A)
сделали стаффинг, передали, приняли
сделали дестаффинг
получили последовательность байт
т.е что то вроде
C++
1
2
3
4
5
6
unsigned char * result;
A * ptr = (A*) result
A obj;
obj.a = ptr->a
obj.b = ptr->b
obj.c = ptr->c
1
2 / 2 / 0
Регистрация: 09.09.2015
Сообщений: 7
02.10.2015, 11:49  [ТС] 4
Спасибо, друзья. Очень помогли. Решение еще окончательно не сформировал, но уже подчерпнул некоторые идеи из ваших решений.
0
2 / 2 / 0
Регистрация: 09.09.2015
Сообщений: 7
03.10.2015, 13:49  [ТС] 5
Опираясь на ваш код, сделал свои функции, которые мне будут более подходящи и проще. Привожу листинг Битстаффинга. Думаю, что структуры будет очень легко преобразовать в беззнаковый символьный массив, с которым и работает моя программа. Спасибо большое за советы и помощь.

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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
#include <stdio.h>
#include <conio.h>
#include <iostream>
 
using namespace std;
 
typedef unsigned char UCHAR;
 
bool GetBit(UCHAR ucBuffer, int nBitShift);
void SetBit(UCHAR &ucBuffer, int nBitShift, bool bSetTo);
void ShowBits(const UCHAR ucBuffer);
UCHAR* BitStuff(const UCHAR* pucBuffer);
UCHAR* DeBitStuff(const UCHAR* pucBuffer);
 
 
int main()
{
    UCHAR *pucBitStuf;
    UCHAR *pucDeBitStuf;
    UCHAR pucBuffer[5];
    memset(pucBuffer,'\0',sizeof(pucBuffer));
 
    pucBuffer[0] = 31;
    pucBuffer[1] = 255; 
 
    //##### BitStuffing
    cout<<"*** Bitstaffing ***"<<endl;
 
    pucBitStuf = BitStuff(pucBuffer);   
    
    for(int i = 0; i < sizeof(pucBitStuf); i++)
    {   
        cout<<"Buffer     : ";ShowBits(pucBuffer[i]);
        cout<<"BitStuffed : ";ShowBits(pucBitStuf[i]);      
    }
 
    //##### DeBitStuffing
    cout<<"\n*** Unbitstaffing ***"<<endl;
    
    pucDeBitStuf = DeBitStuff(pucBitStuf);  
    
    for(int i = 0; i < sizeof(pucBitStuf); i++)
    {   
        cout<<"BUFFER      : ";ShowBits(pucBuffer[i]);
        cout<<"DEBITSTUFFED: ";ShowBits(pucDeBitStuf[i]);       
    }
 
 
    free(pucBitStuf);
    free(pucDeBitStuf);
    _getch();
    return 0;
}
 
UCHAR* BitStuff(const UCHAR* pucBuffer)
{
    int nLenght = sizeof(pucBuffer); // Lenght of an array
    UCHAR* pucResult = (UCHAR*) malloc(sizeof(pucBuffer)); //Allocate memory for new Bitstaffed array
    memset(pucResult,'\0',sizeof(pucBuffer));
 
    int nUnits = 0; //Counter of units  
    int nBitCounterBuf = 0; // Bit counter for buffer
    int nBitCounterRes = 0; // Bit counter for result
    int nElementBuf = 0; // Element counter for buffer array
    int nElementRes = 0; // Element counter for result array
    
    while(nElementBuf < nLenght-1)
    {
        
 
        // Set bit in result to bit from buffer
        SetBit(pucResult[nElementRes],(nBitCounterRes), GetBit(pucBuffer[nElementBuf], nBitCounterBuf));
                    
        // If bit is '1', then increment counter of units
        if( GetBit(pucResult[nElementRes], nBitCounterRes) )
        {nUnits++;  }
        else
        {nUnits = 0;}
 
        // If counter of units counts 5 units, then let's add '0' after them
        if(nUnits == 5)
        {
            // If here's not last bit in this element of array, then add '0' to a next bit
            if(nBitCounterRes < 7)
            {nBitCounterRes++; SetBit(pucResult[nElementRes],nBitCounterRes,0);}
            else if(nBitCounterRes == 7) // If here's last bit, then add '0' to a next element of array
            {
                nBitCounterRes = 0; 
                nElementRes++; 
 
                SetBit(pucResult[nElementRes],nBitCounterRes,0);
            }
 
            // After adding '0' set units counter to 0
            nUnits = 0;
        }
 
        if(nBitCounterBuf == 7) // Counter for bits in buffer
        {nElementBuf++; nBitCounterBuf = 0;} // Element in buffer array
        else
        nBitCounterBuf++; // Increment our bit counter for buffer
 
        if(nBitCounterRes == 7) // Counter for bits in result array
        {nElementRes++; nBitCounterRes = 0;} // Element in result array
        else        
        nBitCounterRes++; // Increment our bit counter for result
    }
 
    return pucResult;
}
 
UCHAR* DeBitStuff(const UCHAR* pucBuffer)
{
    int nLenght = sizeof(pucBuffer); // Lenght of an array
    UCHAR* pucResult = (UCHAR*) malloc(sizeof(pucBuffer)); //Allocate memory for new Bitstaffed array
    memset(pucResult,'\0',sizeof(pucBuffer));
 
    int nUnits = 0; //Counter of units  
    int nBitCounterBuf = 0; // Bit counter for buffer
    int nBitCounterRes = 0; // Bit counter for result
    int nElementBuf = 0; // Element counter for buffer array
    int nElementRes = 0; // Element counter for result array
    
    while(nElementBuf < nLenght-1)
    {
        
 
        // Set bit in result to bit from buffer
        SetBit(pucResult[nElementRes],(nBitCounterRes), GetBit(pucBuffer[nElementBuf], nBitCounterBuf));
                    
        // If bit is '1', then increment counter of units
        if( GetBit(pucResult[nElementRes], nBitCounterRes) )
        {nUnits++;  }
        else
        {nUnits = 0;}
 
        // If counter of units counts 5 units, then let's add '0' after them
        if(nUnits == 5)
        {
            // If here's not last bit in this element of buffer array, then skip to a next bit
            if(nBitCounterBuf < 7)
            {nBitCounterBuf++; }
            else if(nBitCounterBuf == 7) // If here's last bit, then skip to a next element of array
            {
                nBitCounterBuf = 0; 
                nElementBuf++; 
            }
 
            // After skippng '0' set units counter to 0
            nUnits = 0;
        }
 
        if(nBitCounterBuf == 7) // Counter for bits in buffer
        {nElementBuf++; nBitCounterBuf = 0;} // Element in buffer array
        else
        nBitCounterBuf++; // Increment our bit counter for buffer
 
        if(nBitCounterRes == 7) // Counter for bits in result array
        {nElementRes++; nBitCounterRes = 0;} // Element in result array
        else        
        nBitCounterRes++; // Increment our bit counter for result
    }
 
    return pucResult;
}
 
bool GetBit(UCHAR cBuffer, int nBitShift)
{
    return cBuffer & (1U << nBitShift);
}
 
void SetBit(UCHAR &cBuffer, int nBitShift, bool bSetTo)
{
    if(bSetTo)
    { cBuffer = cBuffer | (1U << nBitShift); }
    else
    { cBuffer = cBuffer & ~(1U << nBitShift); }
}
 
void ShowBits(const UCHAR ucBuffer)
{
    for(int i = 0; i < 8; i++)
    cout<<GetBit(ucBuffer,(7-i));
 
    cout<<endl;
}
1
2 / 2 / 0
Регистрация: 09.09.2015
Сообщений: 7
05.10.2015, 15:24  [ТС] 6
В предыдущем сообщении оказалась ошибка в коде. Не заметил ее сразу, потому что не протестировал нормально. Немного изменил функции Дестаффинга и Битстаффинга. В этой версии все работает хорошо пока.

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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
#include <stdio.h>
#include <conio.h>
#include <iostream>
#include <string>
 
using namespace std;
 
typedef unsigned char UCHAR;
 
bool GetBit(UCHAR ucBuffer, int nBitShift);
void SetBit(UCHAR &ucBuffer, int nBitShift, bool bSetTo);
void ShowBits(const UCHAR ucBuffer);
UCHAR* BitStuff(const UCHAR* pucBuffer, const size_t nSize);
UCHAR* DeBitStuff(const UCHAR* pucBuffer, const size_t nSize);
 
 
int main()
{
    UCHAR *pucBitStuf;
    UCHAR *pucDeBitStuf;
    UCHAR pucBuffer[20];
    memset(pucBuffer,'\0',sizeof(UCHAR)*20);
        
    
    //##### BitStuffing
    cout<<"*** Bitstaffing ***"<<endl;
 
    pucBitStuf = BitStuff(pucBuffer,sizeof(pucBuffer)); 
    
    for(int i = 0; i < sizeof(pucBitStuf); i++)
    {   
        cout<<"Buffer     : ";ShowBits(pucBuffer[i]);
        cout<<"BitStuffed : ";ShowBits(pucBitStuf[i]);      
    }
 
    //##### DeBitStuffing
    cout<<"\n*** Unbitstaffing ***"<<endl;
    
    pucDeBitStuf = DeBitStuff(pucBitStuf, sizeof(pucBuffer));   
    
    for(int i = 0; i < sizeof(pucBitStuf); i++)
    {   
        cout<<"BUFFER      : ";ShowBits(pucBuffer[i]);
        cout<<"DEBITSTUFFED: ";ShowBits(pucDeBitStuf[i]);       
    }
 
 
    free(pucBitStuf);
    free(pucDeBitStuf);
 
    _getch();
    return 0;
}
 
UCHAR* BitStuff(const UCHAR* pucBuffer, const size_t nSize)
{
    size_t nLenght = nSize/sizeof(*pucBuffer); // Lenght of an array
    UCHAR* pucResult = (UCHAR*) malloc(nSize); //Allocate memory for new Bitstaffed array
    memset(pucResult,'\0',nSize);
    
    
    int nUnits = 0; //Counter of units  
    int nBitCounterBuf = 0; // Bit counter for buffer
    int nBitCounterRes = 0; // Bit counter for result
    int nElementBuf = 0; // Element counter for buffer array
    int nElementRes = 0; // Element counter for result array
    
    while(nElementBuf < nLenght)
    {
        
 
        // Set bit in result to bit from buffer
        SetBit(pucResult[nElementRes],(nBitCounterRes), GetBit(pucBuffer[nElementBuf], nBitCounterBuf));
                    
        // If bit is '1', then increment counter of units
        if( GetBit(pucResult[nElementRes], nBitCounterRes) )
        {nUnits++;  }
        else
        {nUnits = 0;}
 
        // If counter of units counts 5 units, then let's add '0' after them
        if(nUnits == 5)
        {
            // If here's not last bit in this element of array, then add '0' to a next bit
            if(nBitCounterRes < 7)
            {nBitCounterRes++; SetBit(pucResult[nElementRes],nBitCounterRes,0);}
            else if(nBitCounterRes == 7) // If here's last bit, then add '0' to a next element of array
            {
                nBitCounterRes = 0; 
                nElementRes++; 
 
                SetBit(pucResult[nElementRes],nBitCounterRes,0);
            }
 
            // After adding '0' set units counter to 0
            nUnits = 0;
        }
 
        if(nBitCounterBuf == 7) // Counter for bits in buffer
        {nElementBuf++; nBitCounterBuf = 0;} // Element in buffer array
        else
        nBitCounterBuf++; // Increment our bit counter for buffer
 
        if(nBitCounterRes == 7) // Counter for bits in result array
        {nElementRes++; nBitCounterRes = 0;} // Element in result array
        else        
        nBitCounterRes++; // Increment our bit counter for result
    }
 
    return pucResult;
}
 
UCHAR* DeBitStuff(const UCHAR* pucBuffer, const size_t nSize)
{
    size_t nLenght = nSize/sizeof(*pucBuffer); // Lenght of an array
    UCHAR* pucResult = (UCHAR*) malloc(nSize); //Allocate memory for new Debitstaffed array
    memset(pucResult,'\0',nSize);
 
    int nUnits = 0; //Counter of units  
    int nBitCounterBuf = 0; // Bit counter for buffer
    int nBitCounterRes = 0; // Bit counter for result
    int nElementBuf = 0; // Element counter for buffer array
    int nElementRes = 0; // Element counter for result array
    
    while(nElementBuf < nLenght)
    {
        
 
        // Set bit in result to bit from buffer
        SetBit(pucResult[nElementRes],(nBitCounterRes), GetBit(pucBuffer[nElementBuf], nBitCounterBuf));
                    
        // If bit is '1', then increment counter of units
        if( GetBit(pucResult[nElementRes], nBitCounterRes) )
        {nUnits++;  }
        else
        {nUnits = 0;}
 
        // If counter of units counts 5 units, then let's add '0' after them
        if(nUnits == 5)
        {
            // If here's not last bit in this element of buffer array, then skip to a next bit
            if(nBitCounterBuf < 7)
            {nBitCounterBuf++; }
            else if(nBitCounterBuf == 7) // If here's last bit, then skip to a next element of array
            {
                nBitCounterBuf = 0; 
                nElementBuf++; 
            }
 
            // After skippng '0' set units counter to 0
            nUnits = 0;
        }
 
        if(nBitCounterBuf == 7) // Counter for bits in buffer
        {nElementBuf++; nBitCounterBuf = 0;} // Element in buffer array
        else
        nBitCounterBuf++; // Increment our bit counter for buffer
 
        if(nBitCounterRes == 7) // Counter for bits in result array
        {nElementRes++; nBitCounterRes = 0;} // Element in result array
        else        
        nBitCounterRes++; // Increment our bit counter for result
    }
 
    return pucResult;
}
 
bool GetBit(UCHAR cBuffer, int nBitShift)
{
    return cBuffer & (1U << nBitShift);
}
 
void SetBit(UCHAR &cBuffer, int nBitShift, bool bSetTo)
{
    if(bSetTo)
    { cBuffer = cBuffer | (1U << nBitShift); }
    else
    { cBuffer = cBuffer & ~(1U << nBitShift); }
}
 
void ShowBits(const UCHAR ucBuffer)
{
    for(int i = 0; i < 8; i++)
    cout<<GetBit(ucBuffer,(7-i));
 
    cout<<endl;
}
1
Ответ Создать тему
Опции темы

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