битовые поля

[NightEagle]

такая задача.
4 байта информации раскодировать в 2 байта. 24 первых бита раскодируются след. образом: три бита заменяются одним, в который записывается та из цифр (0 или 1), которая встречается в триаде бит по крайне мере дважды. Остальные 8 бит, просто переписываются.

сделал такую структуру:

struct BIT
{
	unsigned int t1:3;
	unsigned int t2:3;
	unsigned int t3:3;
	unsigned int t4:3;
	unsigned int t5:3;
	unsigned int t6:3;
	unsigned int t7:3;
	unsigned int t8:3;
	unsigned int s:8;
}

если не логично то подскажите как нужно

подскажите:
1) как переписать 8 битов?
2) каким образом можно проверить тройку битов на наличие 0 / 1?

результирующие 2 байта хочу сохранить в объекте типа wchar_t

[veniside]

int value;  // 32 bit value
int result = 0; // only 16 low bits are used
//
for (int i = 0; i < 8; i++) 
{
  switch (value & 7) {
    case 3:
    case 5:
    case 6:
    case 7: result |= 0x80000000;
  }
  //
  value >>= 3;
  result >>= 1;
}
//
result >>= 24;
value <<= 8;
result |= value;

типа того, мысли вслух

[Syuf]

Логично. Теперь можно попробовать сделать так:

union
{
   BIT cut_data;
   unsigned char bytes[4];
   char input1_data[4];
   // или unsigned input2_data;
};

Считать в input1_data посимвольно или числом в input2_data (в зависимости от условия задачи), 8 последних получаем в bytes[3], затем проходимся по полям вашей структуры и сравниваем с уже подсчитанными и переведенными в дес. СС константами, например:
000 = 0
001 = 1
010 = 2
100 = 4
- значит у нас 2 нуля
111 = 7
110 = 6
101 = 5
011 = 3
- значит 2 единицы
И, работая бин. сдвигом, записываем в какую нибудь переменную unsigned char, после чего выводим.

[NightEagle]

Сообщение от veniside

int value;  // 32 bit value
int result = 0; // only 16 low bits are used
//
for (int i = 0; i < 8; i++) 
{
  switch (value & 7) {
    case 3:
    case 5:
    case 6:
    case 7: result |= 0x80000000;
  }
  //
  value >>= 3;
  result >>= 1;
}
//
result >>= 24;
value <<= 8;
result |= value;

типа того, мысли вслух

насколько я понял это вариант с использованием логических операций. нужно сделать используя битовые поля, никак не могу понять как

[veniside]

> нужно сделать используя битовые поля

а, сорри, но всё-равно код будет похожий, битовые поля просто делают ненужными операции сдвига

[NightEagle]

если я правильно понял преподавателя, то когда мне нужно использовать битовые поля, нельзя использовать операции подобного рода |, &, ^
это абсурд? или такое можно реализовать?

[veniside]

> нельзя использовать операции

можно, почему. просто тут не нужно

если уж всё делать битовыми полями, надо быть последовательными до конца, результат тоже описать типа:

struct RES
{
	unsigned int r1:1;
	unsigned int r2:1;
	unsigned int r3:1;
	unsigned int r4:1;
	unsigned int r5:1;
	unsigned int r6:1;
	unsigned int r7:1;
	unsigned int r8:1;
	unsigned int rs:8;
}

и дальше 8 раз проверять одно и то же:

BIT b;
RES r;
//
switch (b.t1) {
    case 3:
    case 5:
    case 6:
    case 7: r.r1 = 1;
} // и так 8 раз, для t2/r2, t3/r3 ...

ну и завершающий аккорд:

r.rs = b.s;

[NightEagle]

> и дальше 8 раз проверять одно и то же
восемь раз писать switch?

[NightEagle]

switch (b.t1) {
    case 3:
    case 5:
    case 6:
    case 7: r.r1 = 1;
}

switch (b.t2) {
    case 3:
    case 5:
    case 6: r.r2 = 1;
    //case 7: r.r1 = 1;
}

switch (b.t3) {
    case 3:
    case 5: r.r3 = 1;
    //case 6:
    //case 7: r.r1 = 1;
}

как-то так? или же я что-то не понял?

[veniside]

> восемь раз писать switch?

угу, или вспомнить, что С — это процедурный язык, и сваять нечто:

int checkBits(unsigned int bits)
{
  switch (bits) {
    case 3:
    case 5:
    case 6:
    case 7: return 1;
  } 
  return 0;
}
//
r.r1 = checkBits(b.t1);
r.r2 = checkBits(b.t2);
r.r3 = checkBits(b.t3);
r.r4 = checkBits(b.t4);
r.r5 = checkBits(b.t5);
r.r6 = checkBits(b.t6);
r.r7 = checkBits(b.t7);
r.r8 = checkBits(b.t8);