C 8位按位表示64位整数

我想实现64位整数的逐位循环移位

ROT（a，b）

将位置

i

处的位移动到位置

i+b

。（a是64位整数）

然而，我的avr处理器是一个8位处理器。因此，要表达

a

，我必须使用

unit8\u t x[8]

• x[0]

  是

  a

  的8个最高有效位

• x[7]

  是

  a

  的8个最低有效位

在数组

x

方面，有谁能帮助实现

ROT（a，b）

谢谢

我想x（I）是8位。 向左旋转n次 X（i，j）中的每一位，其中i是索引数组X（0）->X（7） j是元素中的位位置

那么这一点将在 Y（（i+n）/8，（i+n）和7） 这将处理多达63次的旋转 任何大于63的数字，你只需修改它。

我认为x（I）是8位。 向左旋转n次 X（i，j）中的每一位，其中i是索引数组X（0）->X（7） j是元素中的位位置

那么这一点将在 Y（（i+n）/8，（i+n）和7） 这将处理多达63次的旋转 任何大于63的数字，您只需对其进行修改。

如果基础处理器是64位、8位或1位，则在功能上没有区别。如果编译器是兼容的，那么您就可以开始了。使用

uint64\u t

。代码不“必须使用unit8\t”，因为处理器是8位的

uint64_t RPT(uint64_t a, unsigned b) {
  return (a << (b & 63))  |  (a >> ((64 - b) & 63));
}

---

@vlad_tepesch提出了一种强调AVR 8位特性的解决方案。这是一次未经测试的尝试

void ROT(uint8_t *a, uint8_t b) {
  uint8_t dest[8];
  b &= 63;  // Could be eliminated as following code only uses the 6 LSBits.

  // byte shift
  uint8_t byte_shift = b / 8u;
  for (uint8_t i = 0; i < 8u; i++) {
    dest[i] = a[(i + byte_shift) & 7u];
  }

  b &= 7u; // b %= 8u;  form bit shift;
  uint16_t acc = dest[0] << b;
  for (unsigned i = 8u; i-- > 0;) {
    acc >>= 8u;
    acc |= (uint8_t) dest[i] << b;
    a[i] = (uint8_t) acc;
  }
}

void ROT（uint8\u t*a，uint8\u t b）{
uint8_t dest[8]；
b&=63；//可能被消除，因为以下代码仅使用6个LSBits。
//字节移位
uint8字节移位=b/8u；
对于（uint8_t i=0；i<8u；i++）{
dest[i]=a[（i+字节移位）&7u]；
}
b&=7u；//b%=8u；形成位移位；
uint16\u t acc=dest[0]0；）{
acc>>=8u；
acc |=（uint8_t）dest[i]如果底层处理器是64位、8位或1位，则在功能上没有区别。如果编译器兼容，则可以使用。使用
uint64_t
。代码“不必使用
unit8_t
”，因为处理器是8位的

uint64_t RPT(uint64_t a, unsigned b) {
  return (a << (b & 63))  |  (a >> ((64 - b) & 63));
}


@vlad_tepesch提出了一个强调AVR 8位特性的解决方案。这是一个未经测试的尝试

void ROT(uint8_t *a, uint8_t b) {
  uint8_t dest[8];
  b &= 63;  // Could be eliminated as following code only uses the 6 LSBits.

  // byte shift
  uint8_t byte_shift = b / 8u;
  for (uint8_t i = 0; i < 8u; i++) {
    dest[i] = a[(i + byte_shift) & 7u];
  }

  b &= 7u; // b %= 8u;  form bit shift;
  uint16_t acc = dest[0] << b;
  for (unsigned i = 8u; i-- > 0;) {
    acc >>= 8u;
    acc |= (uint8_t) dest[i] << b;
    a[i] = (uint8_t) acc;
  }
}

void ROT（uint8\u t*a，uint8\u t b）{
uint8_t dest[8]；
b&=63；//可能被消除，因为以下代码仅使用6个LSBits。
//字节移位
uint8字节移位=b/8u；
对于（uint8_t i=0；i<8u；i++）{
dest[i]=a[（i+字节移位）&7u]；
}
b&=7u；//b%=8u；形成位移位；
uint16\u t acc=dest[0]0；）{
acc>>=8u；
acc |=（uint8_t）dest[i]为什么不把工作留给编译器，只实现一个函数呢

uint64_t rotL(uint64_t v, uint8_t r){
  return  (v>>(64-r)) | (v<<r)
}

uint64\u t rotL（uint64\u t v，uint8\u t r）{
return（v>>（64-r））|（v为什么不把工作留给编译器，只实现一个函数呢

uint64_t rotL(uint64_t v, uint8_t r){
  return  (v>>(64-r)) | (v<<r)
}

uint64\u t rotL（uint64\u t v，uint8\u t r）{
return（v>>>（64-r））|（您是否尝试过任何东西？是否有特定的编程语言需要答案？也可以是x[0]有a的8个最高有效位，对吗？基本上，你可以分块来做，或者你可以看看编译器是否会帮你做。只是为了好玩，我让avr gcc在
uint64_t
上做了一些操作，它没有抱怨——尽管我要提醒你，我还没有实际测试结果。（我想你们仍然需要合成轮换。）谢谢大家，我想用C来做。实际上，这是一个需要我转换代码的练习的一部分：D。我试过了，但结果不正确。“ROT（a，b）中的
I
将把位置I的位移动到位置I+b。（a是64位整数）？你不需要（a，i，b）
？你有没有尝试过什么？你有没有想要答案的特定编程语言？还有x[0]有a的8个最高有效位，对吗？基本上，你可以分块来做，或者你可以看看编译器是否会帮你做。只是为了好玩，我让avr gcc在
uint64_t
上做了一些操作，它没有抱怨——尽管我要提醒你，我还没有实际测试结果。（我想你们仍然需要合成轮换。）谢谢大家，我想用C来做。实际上，这是一个需要我转换代码的练习的一部分：D。我试过了，但结果不正确。“ROT（a，b）中的
I
将把位置I的位移动到位置I+b。（a是64位整数）你不需要
ROT（a，i，b）
？纠正Y（（i+n）/8，（i+n）和7应该是Y（（i+n）/8，（j+n）和7）嗨，我真的不明白你的答案，你能详细说明一下吗？你的Y（a，b）是什么？谢谢如果我理解正确，你的Y（a，b）是X（i，j）的每一位的新位置？但是，如果n=4，那么X（0,0）变成Y（0,4）哪一个是不正确的，或者X（2,0）变成了Y（0,4）？如果我错了，请帮我纠正。你从一个8位值的数组开始，结果将是一个8位的新数组Y。首先将Y数组归零，然后循环通过每个X（在我的示例中，X（0）是最低有效字节），对于每个X循环通过每个位。无效旋转（无符号字符*x，无符号字符*y，int n）{unsigned char[8]={1,2,4,8,16,32,64,128}；n&=63；for（int i=0；i<7；i++）y（i）=0；for（int i=0；i<7；i++{for int（j=0；j<7；j++）{if（x（i）&位（j））{y[（i+n）/8]}=位[（j+n）&7]；}应该是Y（（i+n）/8，（j+n）和7）嗨，我真的不明白你的答案，你能详细解释一下吗？你的Y（a，b）是什么？谢谢你如果我理解正确，你的Y（a，b）是X（i，j）的每一位的新位置？但是，如果n=4，那么X（0，0）变成Y（0，4），这是不正确的，或者X（2，0）变成Y（0，