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

Question

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

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

转换后，该变量包含： 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

问题不在于转变，而在于从位图中获取数据的方式。

由于右移会将位从bitmap [0]移到bitmap [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）； //交换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

您可以有效地使用联合：

#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