CODEWITHSUNDEEP
c++pointersc++11shared-ptrsmart-pointers
maxpayne
maxpayne

Reputation: 1111

Should I use smart pointers for my application and library?

There are so much literature about smart pointers, I have read as much as I could. I just want a simple answer.

I have used raw pointer for my 3D renderer engines, and now I have to share some widgets between renderers, so here smart pointer comes. Please guide me should I update my entire software/library with smart pointer (std::shared_ptr)? What will be the cons in that case? I know the pros, just wanna know are there any cons? and what things are important that I should consider during the transformation from raw pointers to smart pointers? please be specific? Thanks.

Upvotes: 0

Views: 562

Answers (2)

nv3
nv3

Reputation: 396

Much is to say about the pros of smart pointers and as other have already said I would recommend using them, where appropriate, in your applications.

When it comes to the API of libraries, I would say: It depends. If you are distributing your library in source form, then yes, you might use smart pointers in your API and your users might benefit from them. If you however want to distribute your library as DLL, smart pointers are not the right tool. That's because they are defined as templates and template classes are not distributable as DLLs. The users of your library would be forced to use the exact same compiler and template library as you did for the production of the DLL -- and that might be not what you want. Hence, for APIs of DLLs I would think twice before using smart pointers.

Upvotes: 1

Daniel Frey
Daniel Frey

Reputation: 56863

Generally, they are a useful tool but not all tasks are suitable for a single tool. That said, here's a few things you should consider:

  • Learning about smart pointers is a valuable skill. Knowing them is the base for applying them when appropriate and ignoring them in the few cases they are not.
  • Smart pointers are more than just std::shared_ptr. There is also std::unique_ptr, also look into std::make_shared, std::make_unique (C++14) and std::enable_shared_from_this as a minimum.
  • When passing std::shared_ptr as parameters, make sure you don't add synchronized, superfluous reference count manipulations, e.g., use const std::shared_ptr<...>&.
  • Even when the standardized smart pointers are not the right tool, know how they work and create your own RAII wrappers - still better than full-blown, error-prone raw pointers.
  • When interfacing existing C-style APIs, you can still often use smart pointers and only hand down the raw pointer to those APIs where needed, using .get() on the smart pointer.

Upvotes: 4

Related Questions