Can __restrict__ be applied to shared_ptr<T>?

Question

Smart pointers are pointers underneath, so is there any way of defining a shared_ptr parameter to a function as not aliasing another shared_ptr, or another pointer of any sort?

Or is this, for some reason, unnecessary?

I'm concerned with the gcc >=4.2 and llvm-clang >=2.0 compilers (answers for other compilers would also be interesting).

Answer 1

Just extract the pointers with .get() and mark them as __restrict__. Remember, putting __restrict__ into the function parameters is the same as putting __restrict__ on local variables. In particular, the compiler doesn't attempt to stop you from calling the function with two pointers that obviously point to the same object; e.g. foo(i,i).

If you want to make a promise to the compiler that certain pointers don't reference each other, allowing the compiler to do more optimizations, then use this code below and do your operations through xp and yp instead of x and y.

#include<iostream>
#include<memory>
using namespace std;

void foo(shared_ptr<int> x, shared_ptr<int> y) {
        int * __restrict__ xp = x.get();
        int * __restrict__ yp = y.get();
}

int main() {
        shared_ptr<int> i = make_shared<int>(3);
        shared_ptr<int> j = make_sharet<int>(4);
        foo(i,j);
}