Re: smart pointer patterns
On Jul 12, 12:00 am, coropho...@gmail.com wrote:
Some people I interact with, especially those with a c background,
have an aversion to scoped_ptrs because they see a new(), but they
don't see a corresponding delete(), and they get very scared
How often do you want a new and a delete in the same scope
anyway? In my experience, the case is rare.
e.g. usage
Class Bar
{
int m_data;
};
void Foo()
{
scoped_ptr<Bar> bar( new Bar() );
process( bar );
}
The usual way to write Foo in C++ would be:
void
Foo()
{
Bar bar ;
process( bar ) ;
}
About the only time you'll use new for a local variable is when
polymorphism is involved, and the real type actually varies at
runtime. E.g.:
void
Foo()
{
Base * p = someCondition
? static_cast< Base* >( new Derived1 )
: static_cast< Base* >( new Derived2 ) ;
// ...
}
In such cases, I would definitely use a scoped_ptr if I needed
to call the destructor, or if I wasn't using the Boehm collector
for some reason. Not doing so is just looking for trouble.
In the default constructor case, we can make a wrapper around
scoped_ptr like:
template <typename T>
class ScopedWrapper
{
public:
ScopedWrapper<T>
: m_ptr( new T() )
{
}
private:
scoped_ptr<T> m_ptr;
};
then, for the previous function, we can equivalenty write:
void Foo()
{
ScopedWrapper<Bar> bar;
process( bar );}
Now, people don't have to see the new call, and it's a bit easier for
them to read,
You mean more confusing, since they don't see that the object is
allocated dynamically. And again, the only reason to allocate
dynamically here is if the dynamic type varies. Something your
wrapper won't handle.
Now, let's say Bar has some arbitrary constructor with signature like:
Bar::Bar(int, double, std::string );
That's easy. Just a set of template constructors for your
ScopedWrapper. Try handling my example above, however. Or
something like:
scoped_ptr< Base > p = factoryMap[ someArg ]->create() ;
(where factoryMap is an std::map< ArgType, AbstractFactory
const* >). Cases where you really would use a pointer for an
object whose lifetime corresponds to a scope.
IMHO, you have two problems which need solving:
-- your use of dynamic allocation is not appropriate, and
-- your collegues need to be educated---it's perfectly normal
to see a new and the delete to be elsewhere. (I'd guess
that for well over half of the objects I allocate
dynamically, the delete is in a member function.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34