从内存c ++，移位和存储中读取位

Question

我想从内存中读取16位，在任何方向上移位n次，然后保存回相同的内存位置。

假设在内存位置0xfffaaa我有：0101111101100001，我想将它向右移一次（>>1）所以我宣布一个指向uint16_t的0xfffaaa变量。

转换后，该变量包含：0110000101011111（十进制为24417）。右移后：0011000010101111 1 - >丢失位。存储在内存中的是：1010111100110000而不是：0010111110110000 1 --->丢失位。

这是一个例子，我试图这样做..

#include <bitset>
#include <iostream>
using namespace std;
int main(){
    volatile uint8_t *bitmap = (uint8_t *)malloc(2);
    bitmap[0] = 0b01011111;
    bitmap[1] = 0b01100001;

    cout << bitset<8>(bitmap[0]);
    cout << bitset<8>(bitmap[1]) << '\n' << '\n';

    uint16_t* p16 = (uint16_t*)bitmap;
    cout << bitset<16>(p16[0]) << '\n';
    p16[0]>>=1;
    cout << bitset<16>(p16[0]) << '\n' << '\n';

    cout << bitset<8>(bitmap[0]);
    cout << bitset<8>(bitmap[1]) << '\n';
   return 0;
}

控制台输出是：

0101111101100001

0110000101011111
0011000010101111

1010111100110000

我怎么能按照我想要使用uint16_t的方式进行改变？

Answer 1

问题不在于移位，而是在于如何从位图获取数据。

由于右移会将位从位图[0]移动到位图[1]，因此您可以使用乘法将数据提取为更大的类型：

auto v16 = 256 * bitmap[0] | bitmap[1];
v16 >>= 1;
bitmap[0] = uint8_t(v16 / 256);
bitmap[1] = uint8_t(v16 & 255);

或者，仅使用班次操作：

auto v16 = (bitmap[0] << 8) + bitmap[1];
v16 >>= 1;
bitmap[0] = uint8_t(v16 >> 8);
bitmap[1] = uint8_t(v16 & 0xFF);

Answer 2

要知道它是否确实以某种方式更快，您必须运行一个分析器。

有两种方法可以解决您的问题（如果您不包括在位图中交换数据的可能性。）

1. 就像@ 1201ProgramAlarm所说： //得到那个指针uint16_t * p16 =（uint16_t *）位图; uint16_t v（* p16）; v =（v >> 8）| （v << 8）; // swap v >> = 1; * p16 =（v >> 8）| （v << 8）; //交换回保存在位图中

这可以用几种不同的方式编写，你甚至可以在交换中加入转换：

v = (v >> 9) | (v << 7);

2. 你不使用p16指针

既然你可以同时进行交换和换档，你也可以直接使用你的p8：

uint61_t v((bitmap[1] >> 9) | (bitmap[0] << 7));
bitmap[0] = v >> 8;
bitmap[1] = v; // C auto-and (i.e. (v & 0xFF) is not required)

请注意，您无法进行更多优化，因为在修改位图时，无法在修改数据后重新加载数据。注意那一个。

现在，这个在程序集中的优化会像这样优化，虽然它可能不是最快的（有时当你让C / C ++编译器进行优化工作时会有惊喜！）

mov ax, [ep]  ; get current value (16 bits)
xchg al, ah
shr ax, 1     ; shift by one unsigned
xchg al, ah
mov [ep], ax  ; save result

对于32位和64位，x86中有一个swapb指令（也是64位）。

请注意，一次读取和写入一个字节可能与读取16位和xchg-ing一样快。

Answer 3

你可以有效地使用union：

#include <bitset>
#include <iostream>
#include <algorithm>

using namespace std;

union joinbits
{
    uint16_t data;
    uint8_t  bits[2];
};

int main(){
    volatile uint8_t *bitmap = (uint8_t *)malloc(2);

    bitmap[0] = 0b01011111;
    bitmap[1] = 0b01100001;

    cout << bitset<8>(bitmap[0]);
    cout << bitset<8>(bitmap[1]) << '\n' << '\n';

    joinbits j;
    j.bits[1] =  bitmap[0];
    j.bits[0] =  bitmap[1];

    j.data >>= 1;

    bitmap[0] = j.bits[1];
    bitmap[1] = j.bits[0];

    cout << bitset<8>(bitmap[0]);
    cout << bitset<8>(bitmap[1]) << '\n';

    return 0;
}

输出是：

0101111101100001                                                                                                                                               

0010111110110000