Let's say I have a class that is just a thin wrapper over a pointer and the only thing the class does is call delete in the destructor like an auto pointer.However, it also has an operator that automatically dereferences, so I can pass it around in functions that take const references and then I make as much as my functions as possible to take in const references.I have 3 questions about this scenario:

1.Is it certain that the compiler(MSVC in release mode with all possible optimizations enabled) will inline every wrapper method and allow the pointer to have the same performance as a raw pointer?(It's hard to benchmark pointers since I get a lot of memory fragmentation when I test different types, so I'm not sure how to test them, but I've seen 100% identical performance between my array container and raw arrays, so I assume this should happen to the pointer wrapper too with exception to the part where it gets deleted when it goes out of scope)

2.Will the compiler optimize away the useless dereferencing from the wrapper's opereator if/when it realizes they're passed by references(which are basically pointers again)

3.Will passing everything around as const references improve performance?A lot of sources, like this for instance ftp://ftp.sgi.com/sgi/audio/audio.apps/dev/aliasing.html talk about how you can make the compiler's job easier by pretty much restricting and/or constifying inputs everywhere.(maybe I'm not getting it right).

Also it's extremely convenient not to have to manually delete every member in the destructor when you use the auto pointer for class members.I'm just worried about the performance impact.

1.Is it certain that the compiler(MSVC in release mode with all possible optimizations enabled) will inline every wrapper method and allow the pointer to have the same performance as a raw pointer?(It's hard to benchmark pointers since I get a lot of memory fragmentation when I test different types, so I'm not sure how to test them, but I've seen 100% identical performance between my array container and raw arrays, so I assume this should happen to the pointer wrapper too with exception to the part where it gets deleted when it goes out of scope)

Inlining is never certain.
But there is a very high probability, as long as you have implemented them in the header file.

2.Will the compiler optimize away the useless dereferencing from the wrapper's opereator if/when it realizes they're passed by references(which are basically pointers again)

References and pointers are the same thing to the compiler, however a built-in reference has restrictions, and restrictions typically allow potential optimizations, particularly related to aliasing in this case. It’s only guesswork as to which compilers will decide to optimize anything, when, and where, if at all, though.

3.Will passing everything around as const references improve performance?A lot of sources, like this for instance ftp://ftp.sgi.com/sgi/audio/audio.apps/dev/aliasing.html talk about how you can make the compiler's job easier by pretty much restricting and/or constifying inputs everywhere.(maybe I'm not getting it right).

Having only “const” references is stupid. const exists to indicate something as read-only. Using const in a non-const situation just because you only return const references is just abusing the language and will gain you nothing. The compiler still has to view it as non-const if it allows modifying it.
“const” tends only to help in terms of performance when aliasing is concerned, in that the compiler can be assured (under assumptions of a competent coder) to incoming pointers of the same type, one const and one not, will not reference the same memory (even though they might).


L. Spiro

OK I made some tests and the results were surprising:
1.I tested raw pointer to some struct versus the pointer wrapper by passing their values to the methods of some other class.In case 1 I pass the raw pointer and the method takes a raw pointer as an argument.In case 2 the method takes a const reference of the struct as an argument and the pointer wrapper class automatically passes it as a reference when I write it in the argument.
Strangely, the wrapper class outperformed the raw pointer EVERY TIME.

2.I tested setting and getting members with the -> operator.Raw pointer wins here by a huge amount.It seems the overloaded -> operator doesn't get inlined no matter what?!

I was running in release mode with every possible optimization enabled, not sure how to explain what happens.I'm no good at reading assembly listing so I'm not sure how to explain that.

OK I made some tests and the results were surprising:
1.I tested raw pointer to some struct versus the pointer wrapper by passing their values to the methods of some other class.In case 1 I pass the raw pointer and the method takes a raw pointer as an argument.In case 2 the method takes a const reference of the struct as an argument and the pointer wrapper class automatically passes it as a reference when I write it in the argument.
Strangely, the wrapper class outperformed the raw pointer EVERY TIME.

2.I tested setting and getting members with the -> operator.Raw pointer wins here by a huge amount.It seems the overloaded -> operator doesn't get inlined no matter what?!

I was running in release mode with every possible optimization enabled, not sure how to explain what happens.I'm no good at reading assembly listing so I'm not sure how to explain that.

When doing performance tests, be sure to do tests that create a side-affect and then use that side-affect in a debug message.
If the compiler sees no side-affects in a section of code it will often eliminate it entirely.


L. Spiro