關鍵字 -- restrict

restrict是C99新增的一個關鍵字，其主要目的是用來優化用的。它只能修飾指針。該關鍵字告訴編譯器，哪些指針引用是可以優化的，

其方法是指明指針指向的對象，在函數中只通過該指針進行訪問。

它的英文定義是: It can be applied only to pointers, and it indicates that a pointer is the sole initial means of accessing a data object.

以我通俗的理解，它就是說被具有restrict修飾的指針的數據對象，只能被該指針修改，從而編譯器可以進行一些優化措施。

int ar[10];

int * restrict restar = (int *) malloc(10 * sizeof(int));

int * par = ar;

for (n = 0; n < 10; n++)

{

      par[n] += 5;

      restar[n] += 5;

      ar[n] *= 2;

      par[n] += 3;

      restar[n] += 3;

}

restar指針是restrict類型，par指針就不是，因爲par即沒有初始化也不是唯一訪問ar數組的變量。
那麼，上面的程序，因爲restar是唯一反問數據塊的指針，所以編譯器可以對它優化爲一條語句，
restar[n] += 8;     /* ok replacement */
而par就不可以，
par[n] += 8;      / * gives wrong answer */

One of the new features in the recently approved C standard C99, is therestrict 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.

http://www.cnblogs.com/hustcat/articles/1510736.html