标签: unsigned-integer

我希望or在 2 位图上执行简单的逻辑，但 Swift 认为这是错误的：

let u: UInt8 = 0b1
let i: Int = 0b10
i | u // Binary operator '|' cannot be applied to operands of type 'Int' and 'UInit8'

有什么方法可以符合类型推断并且仍然有效吗？

我总是可以这样做i | Int(u) // 3，但我认为这并不是最佳选择。

全新的汇编需要一些无符号算术的帮助。从 C 程序转换是什么意思。

使用：

Linux

国家安全管理协会

x86（32 位）

我想从用户那里读入一个数字。我希望这个数字是无符号的。当我输入一个高于有符号整数限制的数字并使用信息寄存器时，我注意到我的寄存器存储为负数，这意味着发生了溢出。（显然输入的数字低于 max unsigned int）我如何将此寄存器视为无符号，以便我可以根据结果进行比较和跳转？

在这个简单的示例中，我对使用有符号循环计数器和无符号循环计数器之间的差异感到非常惊讶：

double const* a;
__assume_aligned(a, 64);
double s = 0.0;

//for ( unsigned int i = 0; i < 1024*1024; i++ )
for ( int i = 0; i < 1024*1024; i++ )
{
    s += a[i];
}

在签名的情况下，生成了 icc 19.0.0（我显示了循环的展开部分）：

..B1.2:
    vaddpd    zmm7, zmm7, ZMMWORD PTR [rdi+rax*8]
    vaddpd    zmm6, zmm6, ZMMWORD PTR [64+rdi+rax*8]
    vaddpd    zmm5, zmm5, ZMMWORD PTR [128+rdi+rax*8]
    vaddpd    zmm4, zmm4, ZMMWORD PTR [192+rdi+rax*8]
    vaddpd    zmm3, zmm3, ZMMWORD PTR [256+rdi+rax*8]
    vaddpd    zmm2, zmm2, ZMMWORD PTR [320+rdi+rax*8]
    vaddpd    zmm1, …

C 标准怎么说：

uint32_t a = 0x11223344;
uint16_t b = a;

打印时，我得到 0x3344，这是有道理的；所以这必须是合法和正确的行为？

我见过浮点位黑客产生平方根，如此处所示快速浮点平方根，但此方法适用于浮点数。

是否有类似的方法可以在不循环 32 位无符号整数的情况下求整数平方根？我一直在网上搜索，但没有看到

（我的想法是纯二进制表示没有足够的信息来做到这一点，但由于它被限制为 32 位，我会猜测）

这是 Python 中的一个简单的线性同余生成器：

def prng(n):
    # https://en.wikipedia.org/wiki/Lehmer_random_number_generator
    while True:
        n = n * 48271 % 0x7fffffff
        yield n

g = prng(123)
for i in range(10**8):
    next(g)

assert next(g) == 1062172093

Python 2.7 比任何版本的 Python 3.x 都快。在 Linux 上生成 100M 项：

python2.7 g.py   14.60s user 0.65s system 99% cpu 15.260 total
python3.6 g.py   18.70s user 0.00s system 99% cpu 18.711 total
python3.7 g.py   18.10s user 0.04s system 99% cpu 18.193 total
python3.8 g.py   19.22s user 0.02s system 99% cpu …

我在编写一个程序试图打印 UTF-8 字符的组成字节值时遇到了这个问题。

这是我为测试各种操作而编写的程序~0：

#include <stdio.h>

int main()
{
    printf("%x\n", (char)~0); // ffffffff
    printf("%x\n", (unsigned char)~0); // ff
    printf("%d\n", sizeof(char) == sizeof(unsigned char)); // 1
    printf("%d\n", sizeof(char) == sizeof(unsigned int)); // 0
    printf("%d\n", (char)~0 == (unsigned int)~0); // 1
}

我正在努力理解为什么当char产生int- 大小的值时会unsigned char产生 -char大小的值。

0 .. v.len() - 1当向量v可能为空时，正确的循环方法是什么？

考虑以下代码，它打印向量中 2 个元素的所有选择[5, 6, 7]：

fn main() {
  let v: Vec<i32> = vec![5, 6, 7];
  for i in 0 .. v.len() - 1 {
    for j in i + 1 .. v.len() {
      println!("{} {}", v[i], v[j]);
    }
  }
}

它打印

5 6
5 7
6 7

正如预期的那样。

现在，如果我们有

let v: Vec<i32> = vec![];

那么程序就会因为溢出而出现恐慌，这也是意料之中的。

问：如何在不改变程序结构和逻辑、不涉及有符号整数的情况下修复它？

以下是我不想要的解决方法的一些示例：

• 单独处理空v（改变逻辑）。总的来说，我不想要任何v空支票，例如if v.len() == 0 { 0 } …

这是两个非常简单的程序.我希望得到相同的输出,但我没有.我无法弄清楚为什么.第一个输出251.第二个输出-5.我可以理解为什么251.但是,我不明白为什么第二个程序给了我-5.

计划1:

#include <stdio.h>

int main()
{

unsigned char  a;
unsigned char  b;
unsigned int  c;

a = 0;
b= -5;

c =  (a + b);

printf("c hex: %x\n", c);
printf("c dec: %d\n",c);

}

输出:

c hex: fb
c dec: 251

计划2:

#include <stdio.h>

int main()
{

unsigned char  a;
unsigned char  b;
unsigned int  c;

a = 0;
b=  5;

c =  (a - b);

printf("c hex: %x\n", c);
printf("c dec: %d\n",c);

}

输出:

c hex: fffffffb
c dec: …

以下证据表明:

inline
constexpr std::size_t prev(std::size_t i) {
    --i;
    return i;
}

int main() {
    static const std::size_t i = 0;
    static_assert(prev(i) == std::size_t(-1), "Decrementing should give     std::size_t(-1)");    
    return 0;
}

那个快乐地汇编着-std=c++14.

我遇到了这个,因为我有一个循环索引,std::vector并想要向后循环,所以我把它改为

for (std::size_t i = std::min(idx, v.size() - 1); i != std::size_t(-1); --i) { ... }

现在,我意识到我可以使用std::vector::reverse_iterator,但我现在的真正问题是,我期待定义的行为是什么？