@老虎会游泳，cppreference 说，这是 UB：

@老虎会游泳，我没能力修改 gcc，所以就认了。要么加 -fno-strict-aliasing，要么用 memcpy，来防止结果出错。

但这还会影响到性能低下问题（特别是修改了 char * 后，编译器会认为一大堆对象有可能被修改了，所以缓存失效，需要重新读取），所以我要搞懂 restrict

@无名啊，经过一番思考之后，我还是认为i = * ( long * ) &y没有问题，因为没有生成新的别名，整个表达式应该被视为一个右值。

相反，把它分开的操作反而是有问题的，这违反了严格别名规则。

long i;  long *p_i;
float y; float *p_y;

p_y = &y;
p_i = (long *) p_y;
i = *p_i;

但它应该也没有副作用，因为不涉及对*p_i的写入。

最重要的是，i = * ( long * ) &y的目标是读取y的值，它根本没有任何优化空间。&y意味着y一定得在内存，所以无论怎么优化，结果应该都是正确的。

@老虎会游泳，( long * ) &y 这个是左值吗？解引用后，类型是 long，不是字符类型，与 float 也不是兼容类型，所以应该是未定义行为。

我 C/C++ 写得不多，现在看到那篇文章，就更怕编译器没能正确实现 UB 了。。

@老虎会游泳，万一哪天，编译器改成，看到不兼容类型的指针转换，后续都不管对这个对象的任何操作了，咋办？

反正也符合标准。。

@无名啊，如果特别担心，就用联合吧。

#include <stdio.h>

float Q_rsqrt( float number ) {
  union { long l; float f; } i;
  float x2, y;
  const float threehalfs = 1.5F;

  x2 = number * 0.5F;
  y  = number;
  i.f = y;                       // evil floating point bit level hacking
  i.l  = 0x5f3759df - ( i.l >> 1 );               // what the fuck?
  y  = i.f;
  y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

  return y;
}

int main() {
  printf("%0.7f\n", Q_rsqrt(3.14));
  printf("%0.7f\n", Q_rsqrt(1024.0));
  printf("%0.7f\n", Q_rsqrt(10086.0));
  printf("%0.7f\n", Q_rsqrt(2147483647.0));

  printf("%0.14f\n", Q_rsqrt(3.14));
  printf("%0.14f\n", Q_rsqrt(1024.0));
  printf("%0.14f\n", Q_rsqrt(10086.0));
  printf("%0.14f\n", Q_rsqrt(2147483647.0));

  return 0;
}

代码实际上变简单了。

不过有趣的是，使用联合的版本给出的都是负值（虽然也是正确解，平方根有两个解），不知道符号位的处理和非联合版本有什么不同。

@老虎会游泳，比如，(long *)&y，编译器认为结果是 NULL。。。

@老虎会游泳，诶，好像只是访问时 UB 噢，转换指针类型应该没问题？

@无名啊，你说得对，( long * ) &y是左值，* ( long * ) &y是对它求值。

不过Q_rsqrt()改写成符合标准似乎很容易。

还有符号位的处理与union版本存在差异，所以确实可能涉及未定义行为。得到负数解可能才是这种内存操作应该有的结果。

@老虎会游泳，关于联合体，应该只有 C 能用，C++ 不能：

cppreference - 联合体 - 解释 说：

联合体的大小仅足以保有其最大的数据成员。其他数据成员在该最大成员的一部分相同的字节分配。分配的细节是实现定义的，且读取并非最近写入的联合体成员是未定义行为。许多编译器以非标准语言扩展实现读取联合体的不活跃成员的能力。

@无名啊，顺便一提，在安卓上long是64位，这就是符号位差异的来源

还有，memcpy看起来是最佳选择，因为它没有任何多余的操作——我们想要的就是内存复制，所以我们就应该写内存复制。改成memcpy后，代码比用联合与指针类型转换都简单。

#include <stdio.h>
#include <stdint.h>                                                                                     float Q_rsqrt( float number ) {
  int32_t i = 0;
  const float threehalfs = 1.5F;

  float x2 = number * 0.5F;
  float y  = number;
  memcpy(&i, &y, sizeof(y));                       // evil floating point bit level hacking
  i  = 0x5f3759df - ( i >> 1 );               // what the fuck?
  memcpy(&y, &i, sizeof(y));
  y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

  return y;
}

int main() {
  printf("sizeof(long):    %lu\n", sizeof(long));
  printf("sizeof(int32_t): %lu\n", sizeof(int32_t));
  printf("sizeof(float):   %lu\n", sizeof(float));

  printf("%0.7f\n", Q_rsqrt(3.14));
  printf("%0.7f\n", Q_rsqrt(1024.0));
  printf("%0.7f\n", Q_rsqrt(10086.0));
  printf("%0.7f\n", Q_rsqrt(2147483647.0));

  printf("%0.14f\n", Q_rsqrt(3.14));
  printf("%0.14f\n", Q_rsqrt(1024.0));
  printf("%0.14f\n", Q_rsqrt(10086.0));
  printf("%0.14f\n", Q_rsqrt(2147483647.0));

  return 0;
}

@老虎会游泳，另外，我这篇帖子，主要是想讨论 restrict 的（因为我已经认下严格别名了）。。

我刚才看了看你一开始的其他回复。

我认为，根据 cppreference 对 restrict 的叙述，应该是允许有其他别名的。

只要保证：通过 restrict 修饰的指针写入某个对象后，不再使用其他别名访问这个对象，即可？

@无名啊，对，restrict的作用应该是所有权的转移，规则应该和Rust类似：所有权转移给某别名之后，就不能再用其他别名访问了，但是转移之前则可以。

@老虎会游泳，我在给 SQLite 写流式解析 csv 的小插件，想只用一个缓冲区存储：数据块、某一行解析好的CSV数据。

比如，读取 4K 数据，然后边解析，边往这个缓冲区开头写入。

由于 CSV 数据解析完不会需要更多内存来存储，只会由于转义变得需要更少内存，所以不会发生写指针超出读指针问题。

所以，我在想写指针能不能加 restrict？加了有没有用？读指针需要加 restrict 吗？

@无名啊，根据以下文段，我觉得所有权的转移是在声明时发生的，而非使用时发生的。所以只要这个定义域内存在“restrict 指针 P”，就不能通过其他手段访问。

在每个声明了 restrict 指针 P 的块（典型例子是函数体的执行，其中 P 为参数）中，若某个可由 P （直接或间接）访问的对象会被任何手段修改，则该块中所有对该对象（读或写）的访问，都必须经由 P 出现，否则行为未定义。

只有一种情况可以存在其他别名：“restrict 指针 P”指向的内容不会进行任何修改。

若对象决不被修改，则它可以被别名引用，并被异于 restrict 限定的指针访问。

@老虎会游泳，“对象类型”是指非函数类型。。

另外，只是指向 char 类型的读写指针。

另外，根据严格别名说的，char * 可修改任何类型的数据。

所以，我认为给 char * 添加 restrict，可防止【写指针写入数据后，编译器认为所有指针的数据缓存都失效不能用了，需要重新读取】。

不知这个想法对不对

@老虎会游泳，只是【通过 char * restrict 修改后，不再使用其他别名】，也不行？

因为解析了一个字符，并写入后，就不再需要读取这个及之前的字符对象了

@老虎会游泳，写指针 和 读指针，都指向同一块缓冲区。只是写指针写入过后的字符对象，都绝不再读取。（因为写指针不会超出读指针，如上所述）