@
class BaseDataType
{
const char* getter() const;
void setter(const char*);
};

class DerivedDataType
{
const char* getter_derived() const;
void setter_derived(const char*);
};

class BaseData : public QSharedData
{
public:
// the standard ctor and copy ctor go here

// my data is a pointer to a polymorphic type
BaseDataType* ptr;
};

class Base
{
public:
// the standard ctor and copy ctor go here

protected:
// subclasses use this to access the shared ptr and then static cast it
QSharedDataPointer<BaseData> real_d;
};

class Derived
{
public:
// ctor and copy ctor go here

const char* getter_derived() const
{
// const access - won't cause a detach
return d()->getter_derived();
}

void setter_derived(const char* str)
{
// non-const access - may cause a detach
d()->setter_derived(str);
}

private:
// these accessors replace the standard "d" pointer:

// the -> won't cause a detach here
const DerivedDataType* d() const {return static_cast<DerivedDataType*>(real_d->ptr);

// the -> may cause a detach here
DerivedDataType* d() {return static_cast<DerivedDataType*>(real_d->ptr);}

};
@

This only just occured to me, so somebody please let me know if I'm missing something.

Hope this helps ;)[/quote]

It doesn't. There's nothing in that article about polymorphism or dynamic casting.

I'm also interested in this question. Does anyone have a good solution?

Hope this helps ;)