Hi everyone.I got a bit (say) confused as I discovered it exists std::shared_ptr (it was released with C++11 if I understand well).What are the main differences between std::shared_ptr and boost::shared_ptr?It is right I can google, but I would like to know which one you recommend over the other? (and why?)MerciÉdouard

The one from boost is the predecessor of the one from std. You can use either of them and their behaviour and performance should be comparable.In my case, I think I will be moving towards std::shared_ptr in the long term, but since we have a lots of libraries that are compiled under different architectures and with different versions of the compiler it will take many years (if ever) to replace boost::shared_ptr,Main advantage of boost::shared_ptr<> is that it will compile with older compilers. If you are starting a new application from scratch and you don't have legacy issues then I would suggest to use std::shared_ptr instead of boost::shared_ptr, otherwise the one from boost may be the only available.Either way it won't make much difference.

Boost also has scoped_ptr, intrusive_ptr, scoped_array, shared_array and weak ptrs. (std only has shared_ptr and weak_ptr).

std also has a unique_ptr.BTW, the _array variants are not needed as unique_ptr and shared_ptr can handle arrays as well.

This really comes down to your compiler environment. If you have a clean slate, then use C++11 and std::shared_ptr. If there is a chance of any legacy compilation then just use boost::shared_ptr.

QuoteOriginally posted by: CluelessCppBTW, the _array variants are not needed [...]Unless you using raw legacy C arrays?

QuoteOriginally posted by: CuchulainnQuoteOriginally posted by: CluelessCppBTW, the _array variants are not needed [...]Unless you using raw legacy C arrays?Sorry, should have put that into the context of the std smart pointers - these are specialised for array types to call the correct delete operator for arrays, e.g. std::unique_ptr<int[]> ptr (new int[10]);works fine, in contrast to std::unique_ptr<int> ptr (new int[10]);which compiles, but would use the non-array delete operator.So there is no reason to have a std::unique_array.

QuoteOriginally posted by: CluelessCppQuoteOriginally posted by: CuchulainnQuoteOriginally posted by: CluelessCppBTW, the _array variants are not needed [...]Unless you using raw legacy C arrays?Sorry, should have put that into the context of the std smart pointers - these are specialised for array types to call the correct delete operator for arrays, e.g. std::unique_ptr<int[]> ptr (new int[10]);works fine, in contrast to std::unique_ptr<int> ptr (new int[10]);which compiles, but would use the non-array delete operator.So there is no reason to have a std::unique_array.Nice.I must say boost::scoped_ptr is good to use in code for short-lived objects (e.g. factories) and the reader can immediately see that it is not used outside the scope. shared_ptr is also fine but is a bit more relaxed.