The compiler will propagate `__declspec(restrict)`. For example, the CRT `malloc` function is decorated with `__declspec(restrict)` and therefore, pointers initialized to memory locations with `malloc` are also implied to not be aliased by previously existing memory.

For similar semantics on variables, see [__restrict](../cpp/extension-restrict.md).

For another annotation that can impact aliasing, see also [__declspec(noalias)](../cpp/noalias.md).

For information about the restrict keyword that is part of C++ AMP, see [restrict (C++ AMP)](../cpp/restrict-cpp-amp.md).

The following sample demonstrates using `__declspec(restrict)`.

Decorating functions that return pointers with `__declspec(restrict)` tells the compiler that the memory pointed to by the return value is not aliased. In this example, the pointers `mempool` and `memptr` are global so the compiler has no assurance that the memory is not subject to aliasing. However, they are used in such a way that each invocation of `ma` and `init` return memory that isn't otherwise referenced by the program, so `__decslpec(restrict)` is used to help the optimizer. This is similar to how the CRT headers decorate allocation functions such `malloc` as `restrict` to indicate that they always return memory that cannot be aliased by existing pointers.

Decorating functions with `__declspec(noalias)` tells the compiler that the function does not interfere with the global state except through the pointers in its parameter list. in the example that accesses memory

#include <stdio.h>

#include <stdlib.h>

#define M 800

#define N 600

#define P 700

float * mempool, * memptr;

__declspec(restrict) float * ma(int size)

{

float * retval;

retval = memptr;

memptr += size;

return retval;

}

__declspec(restrict) float * init(int m, int n)

{

float * a;

int i, j;

int k=1;

a = ma(m * n);

if (!a) exit(1);

for (i=0; i<m; i++)

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

a[i*n+j] = 0.1/k++;

return a;

}

void multiply(float * a, float * b, float * c)

{

int i, j, k;

for (j=0; j<P; j++)

for (i=0; i<M; i++)

for (k=0; k<N; k++)

c[i * P + j] =

a[i * N + k] *

b[k * P + j];

}

int main()

{

float * a, * b, * c;

mempool = (float *) malloc(sizeof(float) * (M*N + N*P + M*P));

if (!mempool)

{

puts("ERROR: Malloc returned null");

exit(1);

}

memptr = mempool;

a = init(M, N);

b = init(N, P);

c = init(M, P);

multiply(a, b, c);

}