[floquation]

If I have the following snippet in the constructor of my class:

Foam::foo::foo(
    const dictionary& dictName
    (...)
)
{
    (...)
    // copy the input dictionary to ensure its existence
    // that is, it may go out-of-scope elsewhere and therefore seize to exist inside this class --> segmentation fault
    dict_ = autoPtr<dictionary>(new dictionary(dictName));
    (...)
}

where dict_ is defined in the header file as:

(...)
autoPtr<dictionary> dict_;
(...)

Just to make sure that my understanding is correct:
Is there a memory leak if this class gets disposed of?

Hypothesis:
When this class is disposed of, the destructor of all its entities are automatically called (right?). This includes the entity "dict_".
"dict_", being an autoPtr, should automatically take care of the data pointed at by the pointer it owns. It owns the pointer, because it was declared with the "new" statement inside its constructor argument.

[floquation]

Solved: Above hypothesis was correct.
I designed a way to test this, by writing a small new class:

#include "dictionary.H"

namespace Foam
{

class kvadictionary
:
    public dictionary
{

public:

    kvadictionary(const dictionary& dict)
    :
    dictionary(dict)
    {
        Info << "kvadictionary constructor" << endl;
    }

    ~kvadictionary(){
        Info << "kvadictionary destructor" << endl;
    }

};

}

And changing the autoPtr constructor call to:

dict_ = autoPtr<dictionary>(new kvadictionary(dictName));

The result is a message when the dictionary (i.e. the object owned by the autoPtr) is disposed of:

foo destructor called
kvadictionary destructor