介绍

除此之外，C99 添加了 limit 关键字，作为程序员指定指针是 only 指向作用域中给定对象的指针的一种方式，从而给编译器一个“提示” ”，当通过该指针访问对象时，它可能会执行额外的优化。

问题

为了说明限制要解决的问题，请考虑如下函数：

void update_ptrs( int *p, int *q, int const *v ) {
  *p  = *v;
  *q  = *v;
}

编译器将生成 x86-64 代码，例如：

mov eax, [rdx]  ; tmp = *v   // 1
add [rdi], eax  ; *p  = tmp
mov eax, [rdx]  ; tmp = *v   // 3
add [rsi], eax  ; *q  = tmp

你可能想知道为什么它会生成第 3 行，因为它看起来与第 1 行是多余的。问题是编译器不知道你没有做这样的事情：

int x = 1, v = 2;
update_ptrs( &v, &x, &v );   // x = 5, v = 4

在update_ptrs()中，p和v将alias相同 int，因此编译器必须谨慎行事并假设*v的值可以在读取之间改变，因此需要额外的 mov 指令。

一般来说，C 中的指针会混淆优化，因为编译器无法知道两个指针是否彼此别名。 在性能关键的代码中，消除内存读取

可能是一个巨大的胜利如果编译器可以安全地做到这一点。

解决方案

为了解决上述问题，C 中添加了restrict，以允许指定给定指针是

only 指向该指针作用域中的对象的指针，即同一作用域别名中没有其他指针它。

要使用限制，请将其插入

声明中的*和指针名称之间。 重写为使用限制的 update_ptrs() 将是：

void update_ptrs_v2( int *限制 p, int *限制 q, int const *限制 v ) { *p = *v； *q = *v； }

void update_ptrs_v2( int *restrict p, int *restrict q,
                     int const *restrict v ) {
  *p  = *v;
  *q  = *v;
}

（从右到左读取，例如 v 是指向常量 int 的受限指针；或使用 cdecl。）

通过添加限制，编译器现在可以生成如下代码：

mov eax, [rdx] ; tmp = *v 添加[rdi]，eax； *p = tmp 添加[rsi]，eax； *q = tmp

void update_ptrs_v2( int *restrict p, int *restrict q,
                     int const *restrict v ) {
  *p  = *v;
  *q  = *v;
}

现在，编译器能够删除附加 mov 指令的前第 3 行。

也许使用restrict的最著名的例子是标准库函数memcpy()。 这是复制内存块的最快方法

如果源地址和目标地址不重叠。当地址 do 重叠时，存在稍慢的 memmove() 函数。

陷阱

滥用限制会导致未定义的行为，例如，将

do 彼此别名的指针传递给 update_ptrs_v2() 或 memcpy()。 在某些情况下，编译器可以警告您，但并非在所有情况下，因此不要依赖编译器来捕获误用。

请注意，restrict 是针对给定范围的。 将一个受限指针分配给同一范围内的另一个

会导致未定义的行为：

void f( int *限制 d, int *限制 s ) { int *限制 p = s; // 未定义的行为

void update_ptrs_v2( int *restrict p, int *restrict q,
                     int const *restrict v ) {
  *p  = *v;
  *q  = *v;
}

但是，您可以将受限制的指针分配给不受限制的指针：

void f( int *限制 d, int *限制 s ) { int *p = s; // 好的

void update_ptrs_v2( int *restrict p, int *restrict q,
                     int const *restrict v ) {
  *p  = *v;
  *q  = *v;
}

即使 p 不受限制，编译器仍然可以执行相同的优化。

将内部作用域中的受限指针分配给外部作用域中的另一个受限指针也是可以的（但反之则不然）：

void f( int *限制 d, int *限制 s ) { { // 内部作用域 int *限制 p = s; // 好的 // ... s = p; // 未定义的行为 } }

void update_ptrs_v2( int *restrict p, int *restrict q,
                     int const *restrict v ) {
  *p  = *v;
  *q  = *v;
}

何时（以及何时不）使用限制

首先，您绝对应该分析您的代码（甚至可能查看生成的汇编代码），看看使用限制是否确实会

显着性能改进，以证明冒潜在陷阱的风险是合理的。 诊断由于滥用限制而导致的错误非常很难做到。

其次，如果restrict的使用仅限于实现一个函数，其中通过受限指针访问的内存是由

you分配的，那么它会更安全。 例如，给定：

无效更安全（无符号n）{ n = n % 2 != 0; // 通过向上舍入使偶数 int *const array = malloc( n * sizeof(unsigned) ); 无符号 *restrict half_1st = 数组； 无符号 *restrict half_2nd = 数组 n/2; // ... 自由（数组）； }

void update_ptrs_v2( int *restrict p, int *restrict q,
                     int const *restrict v ) {
  *p  = *v;
  *q  = *v;
}

代码可以安全地对数组的前半部分和后半部分进行操作，因为它们不重叠（假设您从未访问 half_1st[n/2] 或更多）。

第三，如果在函数的参数中使用restrict，那么它可能

不太安全。 例如，将 Safer() 与 update_ptrs_v2() 进行对比，其中 调用者 控制指针。 你知道，调用者得到了错误的并传递了别名的指针。

各种各样的

只有指向对象（或void）的指针可以用restrict:限定

限制 int x; // 错误：无法限制对象 int 限制 *p; // 错误：指向限制对象的指针 int (*限制 f)(); // 错误：函数指针

void update_ptrs_v2( int *restrict p, int *restrict q,
                     int const *restrict v ) {
  *p  = *v;
  *q  = *v;
}

可以对结构体成员使用restrict，例如：

结构节点{ void *限制数据； 结构节点*限制左； 结构节点*限制权限； };

void update_ptrs_v2( int *restrict p, int *restrict q,
                     int const *restrict v ) {
  *p  = *v;
  *q  = *v;
}

表示 data 将是指向该数据的唯一指针，并且 left 和 right 永远不会指向同一个节点。 然而，对结构成员使用限制是非常不常见的。

最后，C

没有有限制。 为什么不呢？ 答案很长，但 TL;DR 版本是：

它可能是 C 委员会不想从 C 导入的难以发现的错误的来源。
C 增加了对指针的使用，例如，这使得安全地使用限制变得更加困难。

然而，许多编译器都有 __restrict__ 作为扩展。

结论

在有限的情况下，使用限制可以提高性能，但也存在一些重大缺陷。 如果您正在考虑使用限制，请首先分析您的代码。

明智地使用。