The C++ shared_ptr is a pointer to an allocated instance that ensures the instance is deleted after the last shared_ptr to the object goes out of scope (or is explicitly deleted). It's a great mechanism for doing some behind-the-scenes automated memory management. You can point multiple shared_ptr's to the same object and not have too much difficulty in managing the memory of the object that it's pointing at.
The shared_ptr first appeared in the boost library. Once upon a time we would write:
#include <boost/shared_ptr.hpp>
boost::shared_ptr<T> ptr;
Later, a committee found shared_ptr so cool, they said “we want that too” and incorporated it into the C++ library. The shared_ptr became part of the TR1 extension (first Technical Report), and we would write:
#include <tr1/memory>
std::tr1::shared_ptr<T> ptr;
For about a decade, work on the next C++ standard continued under the name C++0x. At some point, the gcc team at GNU recognized that TR1 would soon become part of the next C++ standard. So they already incorporated TR1 into the std namespace, but you would have to invoke the compiler with a special flag because it wasn't quite standard yet:
#include <memory>
std::shared_ptr<T> ptr;
g++ -std=c++0x
Not that long ago, the new standard arrived as ‘C++11’. The compilers and library were updated. There was more to C++11, and it was a new standard after all, so GNU added a new flag:
#include <memory>
std::shared_ptr<T> ptr;
g++ -std=c++11
At this very moment, things should have been good now since we have C++11. In practice however, we're in bad luck. Every platform ships their own ‘current’ version of the compiler, and it works differently every time. Older compilers choke on C++11, and newer compilers that prefer C++11 choke on the TR1 stuff. In order to write C++ code that actually compiles across multiple platforms, you have to:
- use autoconf (yuck)
- use ugly ifdefs to get the correct includes
- use typedefs, or hack the std namespace, or import entire namespaces
- use the correct compiler flags, and mind which flag to use for what version of g++
We can only hope that time passes quickly and that TR1 will soon be out of the picture, only a vague memory of an obscurity in the distant past. Until then, ...
