Introduction

In C, restrict is a promise about pointer aliasing. When you put it on a pointer parameter, you are telling the compiler that, for the relevant lifetime, the pointed-to memory will be accessed through that pointer and not through another unrelated pointer.

Why the compiler cares

Without aliasing guarantees, the compiler must be conservative. If two pointers might refer to overlapping memory, then a write through one pointer could change what a later read through the other pointer sees. That uncertainty can block vectorization, reordering, and other optimizations.

restrict removes some of that uncertainty. It gives the compiler permission to assume the pointers do not overlap in the forbidden way.

A common example

This pattern appears often in numeric code:

1void saxpy(int n,
2           float *restrict dst,
3           const float *restrict x,
4           const float *restrict y,
5           float a) {
6    for (int i = 0; i < n; ++i) {
7        dst[i] = a * x[i] + y[i];
8    }
9}

Here, restrict says dst, x, and y refer to separate regions for the purpose of this function call. That lets the compiler optimize the loop more aggressively because it does not need to assume that writing dst[i] might change a later read from x[i] or y[i].

What happens if the promise is false

If you violate the restrict contract, the behavior is undefined. That is the crucial part. restrict is not a runtime check or a hint that the compiler may ignore safely. It is a semantic promise from you to the compiler.

For example, passing the same array as both dst and x in the function above can invalidate the assumptions that justified the optimization. Once that happens, the generated code is allowed to behave unpredictably.

What restrict does not mean

It does not automatically make code faster. It only enables optimizations that were previously blocked by possible aliasing. If the compiler already knows the pointers cannot overlap, or if the loop is too small to matter, you may see little difference.

It also does not apply to the data forever. The promise is about how those restricted pointers are used during the relevant scope, not about some permanent property of the allocation.

Where restrict is useful

It is most helpful in low-level performance-sensitive code such as:

• vector and matrix operations
• image and signal processing loops
• memory transforms over large arrays
• hot paths that compilers can auto-vectorize

In those areas, aliasing assumptions often dominate how much optimization the compiler can apply.

Common Pitfalls

• Treating restrict as a vague optimization hint instead of a real semantic promise.
• Applying restrict to pointers that may legally overlap at call sites.
• Expecting restrict to help when the function does not actually have aliasing pressure.
• Forgetting that violating the promise leads to undefined behavior, not just slower code.
• Using restrict without understanding how derived pointers inside the function relate to the original restricted pointer.

Summary

• 'restrict tells the compiler that a pointer is the unique access path for the relevant object during the restricted lifetime.'
• Its purpose is to reduce aliasing assumptions so the compiler can optimize more aggressively.
• It is especially useful in array-heavy numeric code.
• If the pointers do overlap in a forbidden way, the program has undefined behavior.
• Use restrict only when you can genuinely guarantee the non-aliasing contract.