Is make_shared really more efficient than new?

by

As infrastructure I was using llvm/clang 3.0 along with the llvm std c++ library within XCode4.

Well that appears to be your problem. The C++11 standard states the following requirements for make_shared<T> (and allocate_shared<T>), in section 20.7.2.2.6:

Requires: The expression ::new (pv) T(std::forward(args)…), where pv has type void* and points to storage suitable to hold an object of type T, shall be well formed. A shall be an allocator (17.6.3.5). The copy constructor and destructor of A shall not throw exceptions.

T is not required to be copy-constructable. Indeed, T isn’t even required to be non-placement-new constructable. It is only required to be constructable in-place. This means that the only thing that make_shared<T> can do with T is new it in-place.

So the results you get are not consistent with the standard. LLVM’s libc++ is broken in this regard. File a bug report.

For reference, here’s what happened when I took your code into VC2010:

Create smart_ptr using make_shared...
Constructor make_shared
Create smart_ptr using make_shared: done.
Create smart_ptr using new...
Constructor new
Create smart_ptr using new: done.
Destructor
Destructor

I also ported it to Boost’s original shared_ptr and make_shared, and I got the same thing as VC2010.

I’d suggest filing a bug report, as libc++’s behavior is broken.

More Related Contents:

  1. Why can’t clang with libc++ in c++0x mode link this boost::program_options example?
  2. How to compile/link Boost with clang++/libc++?
  3. Using libstdc++ compiled libraries with clang++ -stdlib=libc++
  4. weak_ptr, make_shared and memory deallocation
  5. What are the mechanics of short string optimization in libc++?
  6. constexpr and initialization of a static const void pointer with reinterpret cast, which compiler is right?
  7. std::shared_ptr thread safety
  8. Can I use C++11 with Xcode?
  9. Constexpr pointer value
  10. What are the differences between -std=c++11 and -std=gnu++11?
  11. Why does Clang optimize away x * 1.0 but NOT x + 0.0?
  12. Preventing compiler optimizations while benchmarking
  13. std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]
  14. In CMake, how can I test if the compiler is Clang?
  15. How is the std::tr1::shared_ptr implemented?
  16. Where is shared_ptr?
  17. Detach a pointer from a shared_ptr? [duplicate]
  18. How to deal with global-constructor warning in clang?
  19. How can I use C++ 11 features in Clang?
  20. Why is processing an unsorted array the same speed as processing a sorted array with modern x86-64 clang?
  21. Should I pass a shared_ptr by reference? [duplicate]
  22. What is the difference between an empty and a null std::shared_ptr in C++?
  23. shared_from_this causing bad_weak_ptr
  24. gcc can compile a variadic template while clang cannot
  25. Missing C++ header after updating OSX Command Line Tools 6.3
  26. Using shared_ptr in dll-interfaces
  27. const auto std::initializer_list difference between Clang and GCC
  28. Is substitution performed on a variadic parameter pack type if the pack is empty?
  29. Problems using member function as custom deleter with std::shared_ptr
  30. Using OpenMP with clang

Leave a Comment