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數(shù)組的變量。
那么，上面的程序，因為restar是唯一反問數(shù)據(jù)塊的指針，所以編譯器可以對它優(yōu)化為一條語句，
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 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:
  

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.

  
所以，在沒有restrict的時候，編譯器需要考慮上面的出錯情況，而無法優(yōu)化程序。

restrict也可以用在函數(shù)的指針參數(shù)前面，它表示在函數(shù)里沒有其他標(biāo)識符會修改指針?biāo)傅臄?shù)據(jù)塊，編譯器可以優(yōu)化函數(shù)。

restrict是C99版新增加的關(guān)鍵字！   如下：

      由    restrict    修飾的指針主要用于函數(shù)形參，或指向由    malloc()   分配的內(nèi)存空間。restrict   數(shù)據(jù)類型不改變程序的語義。   編譯器能通過作出    restrict   修飾的指針是存取對象的唯一方法的假設(shè)，更好地優(yōu)化某些類型的例程。

      [典型例子]    memcpy()    在    C99    中，restrict    可明確用于    memcpy()    的原型，而在    C89    中必須進(jìn)行解釋。    void    *memcpy (void    *restrict    str1,    const    void    *restrict    str2,    size_t    size);    /*   通過使用    restrict    修飾    str1    和    str2    來保證它們指向不重疊的對象    */   

void fcpy(float *restrict a, float *restrict b,
      float *restrict aa, float *restrict bb, int n)
{
int i;
for(i = 0; i < n; i++) ...{
      aa[i]=a[i];
      bb[i]=b[i];
}
}

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:
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->

  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);//增加restrict關(guān)鍵字是因為這里會出問題,
//如果對兩個參數(shù)都使用了restrict關(guān)鍵字，那么這里編譯時會報錯，因為一
//個地址可以通過兩個指針訪問了
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->

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);
<!--[if !supportLineBreakNewLine]-->
<!--[endif]-->

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.

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);

pci和pi指向的都是n，雖然pci被const修飾，但pci指向的內(nèi)容卻在函數(shù)中被改變了，當(dāng)用restrict修飾符之后 void f ( const int * restrict pci , int * restrict pi )，問題解決了：一旦我們再有如：f ( &n , &n ) 的調(diào)用，編譯器將給出錯誤提示，這是由于一個地址可以通過兩個指針來訪問。

If you specify type qualifiers such as void foo(int * restrict a);, the C compiler expresses it with array syntax void foo(int a[restrict]); which is essentially the same as declaring a restricted pointer.

但要注意：restrict是C99中新增的關(guān)鍵字，在C89和C++中都不支持，在gcc中可以通過—std=c99來得到對它的支持。