Re: std iostreams design question, why not like java stream wrappers?

* Joshua Maurice:


It depends. If one hierarchy is just very similar to another then you have a
smell. If one hierarchy is wrapping another hierarchy then you have a wrapper.

And there is this thing with wrapping an existing class hierarchy of concrete
classes that if you want C++ RAII and type safety, that everything's Ready To
Use after successful construction, then using two parallel hierarchies for the
wrapping is a practical technique, and then you have *three* parallel
hierarchies (the original and the two used for wrapping).

For example, off the cuff,

    struct OriginalBase { OriginalBase() {} };
    struct OriginalDerived { OriginalDerived( int ) {} };

    class WrapperBase
    {
    private:
        OriginalBase* myOriginal;
    protected:
        OriginalBase& original() { return *myOriginal; }

        struct Factory
        {
            virtual ~Factory() {}
            virtual OriginalBase* newOriginal() const
            {
                return new OriginalBase();
            }
        }

        WrapperBase( Factory const& factory )
            : myOriginal( factory.newOriginal() )
        {}
    public:
        WrapperBase()
            : myOriginal( Factory().newOriginal() )
        {}
    };

    class WrapperDerived
        : public WrapperBase
    {
        typedef WrapperBase Base;
    protected:
        OriginalDerived& original()
        {
            return static_cast<OriginalDerived&>( Base::original() );
        }

        struct Factory: Base::Factory
        {
            int myInt;
            Factory( int const anInt ): myInt( anInt ) {}
            virtual OriginalDerived* newOriginal() const
            {
                return new OriginalDerived( myInt );
            }
        };

        WrapperDerived( Factory const& aFactory )
            : Base( aFactory )
        {}

     public:
         WrapperDerived( int const anInt )
             : Base( Factory( anInt ) )
         {}
    };

It's somewhere in the FAQ (title like, "what your mother never told you" :-) ),
but when I asked Marshall to put it there it was in the context of supporting
derived class specific initialization actions for base class construction, which
it also does, e.g., renaming a little bit, when the most derived class is
WrapperButton the Factory above might produce an OriginalButton for the top base
class WrapperWidget, which is fully constructed by any of its constructors.

Cheers & hth.,

- Alf