'Restrict' Pointers
One of the new features in the recently approved C standard C99, is the
restrict pointer qualifier. This qualifier can be applied to a data pointer to indicate that, during the scope of that pointer declaration, all data accessed through it will be accessed only through that pointer but not through any other pointer. The 'restrict' keyword thus enables the compiler to perform certain optimizations based on the premise that a given object cannot be changed through another pointer. Now you're probably asking yourself, "doesn't const already guarantee that?" No, it doesn't. The qualifier const ensures that a variable cannot be changed through a
particular pointer. However, it's still possible to change the variable through a different pointer. For example:
void f (const int* pci, int *pi;); // is *pci immutable?
{
(*pi)+=1; // not necessarily: n is incremented by 1
*pi = (*pci) + 2; // n is incremented by 2
}
int n;
f( &n, &n);
In this example, both pci and pi point to the same variable, n. You can't change n's value through pci but you can change it using pi. Therefore, the compiler isn't allowed to optimize memory access for *pci by preloading n's value. In this example, the compiler indeed shouldn't preload n because its value changes three times during the execution of f(). However, there are situations in which a variable is accessed only through a single pointer. For example:
FILE *fopen(const char * filename, const char * mode);
The name of the file and its open mode are accessed through unique pointers in fopen(). Therefore, it's possible to preload the values to which the pointers are bound. Indeed, the C99 standard revised the prototype of the function fopen() to the following:
/* new declaration of fopen() in <stdio.h> */
FILE *fopen(const char * restrict filename,
const char * restrict mode);
Similar changes were applied to the entire standard C library: printf(), strcpy() and many other functions now take restrict pointers:
int printf(const char * restrict format, ...);
char *strcpy(char * restrict s1, const char * restrict s2);
C++ doesn't support restrict yet. However, since many C++ compilers are also C compilers, it's likely that this feature will be added to most C++ compilers too.
Danny Kalev
转载： http://www.devx.com/tips/Tip/13825
简介
restrict是 c99标准引入的，它只可以用于限定和约束 指针，并表明指针是访问一个 数据对象的唯一且初始的方式.即它告诉 编译器，所有修改该指针所指向内存中内容的操作都必须通过该指针来修改,而不能通过其它途径(其它 变量或指针)来修改;这样做的好处是,能帮助编译器进行更好的优化代码,生成更有效率的汇编代码.如 int *restrict ptr, ptr 指向的内存单元只能被 ptr 访问到，任何同样指向这个内存单元的其他指针都是未定义的，直白点就是无效指针。restrict 的出现是因为 C 语言本身固有的缺陷，C 程序员应当主动地规避这个缺陷，而 编译器也会很配合地优化你的代码.
[1]
2C库例子
考虑下面的例子：
int ar[10];
int * restrict restar=(int *)malloc(10*sizeof(int));
int *par=ar;
这里说明restar是访问由malloc()分配的内存的唯一且初始的方式。par就不是了。
那么：
for(n=0;n<10;n++)
{
par[n]+=5;
restar[n]+=5;
ar[n]*=2;
par[n]+=3;
restar[n]+=3;
}
因为restar是访问分配的内存的唯一且初始的方式，那么 编译器可以将上述对restar的操作进行优化：
restar[n]+=8;
而par并不是访问 数组ar的唯一方式，因此并不能进行下面的优化：
par[n]+=8;
因为在par[n]+=3前，ar[n]*=2进行了改变。使用了 关键字restrict， 编译器就可以放心地进行优化了。
这个关键字据说来源于古老的FORTRAN。有兴趣的看看这个。
3例子
C库中有两个函数可以从一个位置把字节复制到另一个位置。在 C99标准下，它们的原型如下：
void * memcpy（void * restrict s1, const void * restrict s2, size_t n);
void * memove(void * s1, const void * s2, size_t n);
这两个函数均从s2指向的位置复制n字节数据到s1指向的位置，且均返回s1的值。两者之间的差别由 关键字restrict造成，即memcpy()可以假定两个内存区域没有重叠。memmove()函数则不做这个假定，因此，复制过程类似于首先将所有字节复制到一个临时缓冲区，然后再复制到最终目的地。如果两个区域存在重叠时使用memcpy()会怎样？其行为是不可预知的，既可以正常工作，也可能失败。在不应该使用memcpy()时，编译器不会禁止使用memcpy()。因此，使用memcpy()时，您必须确保没有重叠区域。这是程序员的任务的一部分。
[2]
关键字restrict有两个读者。一个是编译器，它告诉 编译器可以自由地做一些有关优化的假定。另一个读者是用户，他告诉用户仅使用满足restrict要求的参数。一般， 编译器无法检查您是否遵循了这一限制，如果您蔑视它也就是在让自己冒险。
