In the C programming language, restrict is a type qualifier that can be applied to a pointer to hint to the compiler that for the lifetime of that pointer, no other pointer will be used to access the same pointed-to object. This limits the effects of pointer aliasing, which can allow the compiler to make optimizations (such as vectorization) that would not otherwise be possible. Undefined behaviour results if the declaration of intent is not followed and the object is accessed by an independent pointer.

The restrict keyword was introduced by the C99 standard. Despite C++ supporting most features of C, restrict is not included in standard C++.

If the compiler knows that there is only one pointer to a memory block, it can produce better optimized code. For instance, in a function which adds a value to both its arguments:

In the above code, the pointers ptrA, ptrB, and val might refer to the same memory location, so the compiler may generate less optimal code:

However, if the restrict keyword is used and the above function is declared as

then the compiler is allowed to assume that ptrA, ptrB, and val point to different locations and updating the memory location referenced by one pointer will not affect the memory locations referenced by the other pointers. The programmer, not the compiler, is responsible for ensuring that the pointers do not point to identical locations. The compiler can e.g. rearrange the code, first loading all memory locations, then performing the operations before committing the results back to memory.

The above assembly code is shorter because val is loaded only once. Without val being restricted, its possible for ptrA to alias with it. This would result in val changing on the first addition, when ptrA is updated, and thus needing to be reloaded. The above assembly code is also faster, since the compiler can rearrange the code more freely. In the second version of the above example, the store operations are all taking place after the load operations, ensuring that the processor won't have to block in the middle of the code to wait until the store operations are complete. This reordering is enabled because pointers ptrA and ptrB were marked with restrict, which ensures that the user won't call the function with these pointers aliased, expecting val to be added twice to the integer they both refer to.

Note that the real generated code may have different behaviors, depending on how the compiler uses the additional information. The benefit with the above mini-example may be small, and in real-life cases large loops doing heavy memory access tends to be what is really helped by restrict.