А разве такое клонирование полиморфно? По-моему нет, ведь other может быть лишь того же типа T. Поправьте если не так

Да, но делегировать на "d" хлопотно. Сравним с "нулевым вариантом" (голый указатель). В принципе и там все решаемо за 5-10 минут. Ну добавил по строчке в конструктор/деструктор. С копированием правда хужее - придется считать что BaseData имеет виртуальный метод clone(). Вот когда все эти сопельки убираются "легким движением руки" - гуд. А начинать долгую писанину из-за этого непривлекательно.

К сожалению, все никак не переползу на С++ 11, но по тексту вижу - да, такое. Никак нельзя убрать (или иначе оформить) эти readable/writeable? Спасибо

 

Для QSharedPointer и более ранних С++

C++ (Qt)
#include <memory>
#include <QSharedPointer>
 
class AbstractHolder
{
public:
    typedef QSharedPointer< AbstractHolder > SharedAbstractHolder;
 
public:
    virtual ~AbstractHolder () {}
    virtual SharedAbstractHolder clone () const = 0;
};
 
template < typename _Type >
QSharedPointer< _Type > makeShared()
{
    return QSharedPointer< _Type >( new _Type );
}
 
template < typename _Type, typename _Arg0 >
QSharedPointer< _Type > makeShared( const _Arg0 & arg0 )
{
    return QSharedPointer< _Type >( new _Type( arg0 ) );
}
 
// etc ... _Arg1, _Arg2 ...
 
template < typename _Type >
class Holder
    : public AbstractHolder
{
    typedef Holder< _Type > ThisType;
    typedef AbstractHolder ParentType;
 
public:
    typedef _Type ValueType;
 
private:
    ValueType m_value;
 
public:
    Holder ()
    : m_value()
    {
    }
 
    template < typename _Arg0 >
    Holder ( const _Arg0 & arg0 )
    : m_value( arg0 )
    {
    }
 
    // etc ... _Arg1, _Arg2 ...
 
    const _Type & readable () const
    {
        return m_value;
    }
 
    _Type & writable ()
    {
        return m_value;
    }
 
    virtual SharedAbstractHolder clone () const
    {
        return makeShared< ThisType >( m_value );
    }
};
 
 
template < typename _Type >
class ImplicitWrapper
{
private:
    typedef ImplicitWrapper< _Type > ThisType;
    typedef Holder< _Type > HolderType;
    typedef QSharedPointer< AbstractHolder > SharedAbstractHolder;
 
    template < typename _OtherType >
    friend class ImplicitWrapper;
 
private:
    SharedAbstractHolder m_shared_holder;
 
private:
    ImplicitWrapper ( const SharedAbstractHolder & holder )
    : m_shared_holder( holder )
    {
    }
 
    void detach ()
    {
        // Hack!!! Qt4 protected, Qt5 private
        struct HackValue
        {
            struct Data
            {
                QBasicAtomicInt weakref;
                QBasicAtomicInt strongref;
            };
 
            AbstractHolder * m_type;
            Data * m_data;
        };
        HackValue * hack = reinterpret_cast< HackValue * >( &m_shared_holder );
 
        if ( hack->m_data->strongref > 1 )
            m_shared_holder = m_shared_holder->clone();
    }
 
public:
    ImplicitWrapper ()
    : m_shared_holder()
    {
    }
 
    template < typename _OtherType >
    ImplicitWrapper ( const ImplicitWrapper< _OtherType > & other )
    : m_shared_holder( other.m_shared_holder )
    {
        Q_ASSERT( !other.m_shared_holder
            || static_cast< _Type * >( const_cast< _OtherType * >( &other.readable() ) ) );
    }
 
    bool isNull () const
    {
        return !m_shared_holder;
    }
 
    const _Type & readable () const
    {
        return m_shared_holder.staticCast< HolderType >()->readable();
    }
 
    _Type & writable ()
    {
        detach();
        return m_shared_holder.staticCast< HolderType >()->writable();
    }
 
public:
    static ThisType make ()
    {
        return ThisType( makeShared< Holder< _Type > >() );
    }
 
    template < typename _Arg0 >
    static ThisType make ( const _Arg0 & arg0 )
    {
        return ThisType( makeShared< Holder< _Type > >( arg0 ) );
    }
 
    // etc ... _Arg1, _Arg2 ...
};
 
#include <iostream>
 
struct Test
{
    Test ()
    {
        std::cout << "Constructor of Test" << std::endl;
    }
 
    Test ( const Test & )
    {
        std::cout << "Copy of Test" << std::endl;
    }
 
    virtual ~Test ()
    {
        std::cout << "Destructor of Test" << std::endl;
    }
 
    virtual void method ()
    {
        std::cout << "Mutable method of Test" << std::endl;
    }
 
    virtual void method () const
    {
        std::cout << "Constant method of Test" << std::endl;
    }
};
 
struct DerivedTest
    : public Test
{
    DerivedTest ()
    {
        std::cout << "Constructor of DerivedTest" << std::endl;
    }
 
    DerivedTest ( const DerivedTest & other )
    : Test( other )
    {
        std::cout << "Copy of DerivedTest" << std::endl;
    }
 
    virtual ~DerivedTest ()
    {
        std::cout << "Destructor of DerivedTest" << std::endl;
    }
 
    virtual void method ()
    {
        std::cout << "Mutable method of DerivedTest" << std::endl;
    }
 
    virtual void method () const
    {
        std::cout << "Constant method of DerivedTest" << std::endl;
    }
};
 
struct OtherTest
{
    OtherTest ()
    {
        std::cout << "Constructor of OtherTest" << std::endl;
    }
 
    ~OtherTest ()
    {
        std::cout << "Destructor of OtherTest" << std::endl;
    }
 
    void method ()
    {
        std::cout << "Mutable method of OtherTest" << std::endl;
    }
 
    void method () const
    {
        std::cout << "Constant method of OtherTest" << std::endl;
    }
};
 
int main ( int, char ** )
{
    int test_number = 0;
    // OK
    {
        std::cout << "Test - " << (test_number++) << std::endl;
        ImplicitWrapper< Test > test_value = ImplicitWrapper< Test >::make();
        test_value.readable().method();
        test_value.writable().method();
    }
 
    // OK
    {
        std::cout << "Test - " << (test_number++) << std::endl;
        ImplicitWrapper< Test > test_value = ImplicitWrapper< DerivedTest >::make();
        test_value.readable().method();
        test_value.writable().method();
    }
 
    // OK
    {
        std::cout << "Test - " << (test_number++) << std::endl;
        ImplicitWrapper< const Test > test_value = ImplicitWrapper< DerivedTest >::make();
        test_value.readable().method();
        test_value.writable().method();
    }
 
    // ERROR
//    {
//    std::cout << "Test - " << (test_number++) << std::endl;
//        ImplicitWrapper< Test > test_value = ImplicitWrapper< OtherTest >::make();
//        test_value.readable().method();
//        test_value.writable().method();
//    }
 
    // OK
    {
        std::cout << "Test - " << (test_number++) << std::endl;
        ImplicitWrapper< DerivedTest > first_value = ImplicitWrapper< DerivedTest >::make();
        ImplicitWrapper< Test > second_value = first_value;
        second_value.readable().method();   // not detached
        second_value.writable().method();     // detached
    }
 
    // OK
    {
        std::cout << "Test - " << (test_number++) << std::endl;
        ImplicitWrapper< Test > second_value = ImplicitWrapper< DerivedTest >::make( DerivedTest() );
        second_value.readable().method();
        second_value.writable().method();
    }
 
    return 0;
}
 

Implicit shared обертка реализует композитную уникальную ассоциацию (composite) уникальное представление экземпляра объекта с помощью механизма "ленивых вычислений", когда вычисления производятся только при необходимости. В данном контексте к вычислениям относится необходимость копирования данных объекта при их модификации. Механизм "ленивых вычислений" в данном случае реализуют с помощью ассоциации обобщенной агрегации (shared), однако сам объект, как мы раннее выяснили, реализует композитную уникальную ассоциацию (composite) сама Implicit shared обертка представляет уникальный экземпляр объекта, как если бы была реализована ассоциация уникальной композиции (composite) .

Так как композитная ассоциация уникальное представление экземпляра объекта оберткой реализуется посредством обобщенной агрегации, то такой случай и называется неявное обобщение (Implicit shared).

Касаясь вопроса применения weak_ptr во внутренней реализации обертки, то weak_ptr не реализует агрегацию в принципе - ни композитную, ни обобщенную. weak_ptr реализует ассоциативную связь с возможностью продления времени жизни экземпляра объекта, поэтому в данном месте неприменим.

Необходимо отметить, что для экземпляров объектов под управлением Implicit shared не существует возможности сослаться любым другим способом, так как они могут быть клонированы в любой момент. Однако имеется возможность ссылки на саму Implicit shared обертку.

Да, напрямую не стоит смешивать.
Я имел всего лишь в виду, что Implicit shared обертка представляет сам объект, как уникальный экземпляр, в то время как он на самом деле обобщенный. А ассоциации здесь относятся к внутренней архитектуре самой обертки, как и весь предыдущий мой пост о возможности применения внутри weak_ptr. Поправлю помарки).

Это понятия модели ООП.
Ассоциация - это понятие означающее, что экземпляры одного класса связаны с экземплярами другого класса. Также вводится понятие связь (link), как экземпляра ассоциации, которая реализуется в виде, включающем понятие полюсов. Полюсы могут являться частью сущностей, участвующих в ассоциации. Если не вдаваться в подробности, то связи (их полюсы) реализуются всяческими указателями, ссылками или вычисляются runtime.

Ассоциации бывают бинарными, и т.д. N-нарными, в зависимости от количества участвующих сущностей. Чаще всего мы имеем дело с бинарными ассоциациями. Одним из частных случаев бинарной ассоциации является отношение типа "часть ‒ целое", такие ассоциации имеют название агрегации. В такой ассоциации целым (агрегатором) по отношению к части может быть только одна сущность (правила подобны отношению наследования). Целое может агрегировать часть индивидуально (composite) или совместно (shared). Первый случай часто называют композицией. Отношение "часть - целое" регламентирует удаление части вместе с целым (по крайне мере в композиции).

Удобно совместить контроль времени жизни экземпляра объекта с экземпляром полюса, реализующим ассоциативную связь агрегации. Другого вида ассоциативные связи, по моему, логически несовместимы с контролем времени жизни. Хорошо иллюстрирует ассоциативную связь агрегации отношение parent - child, когда child "знает", кто его parent. parent должен обеспечить уникальное владение своими child, а child ссылаться на своего parent.

weak_ptr не реализует полюс ассоциативной связи агрегации со стороны целого (так как не управляет временем жизни экземпляра) , хотя может реализовывать полюс ассоциативной связи агрегации со стороны части.
Wrapper является целым по отношению к хранимому объекту, таким образом внутреннее представление должно реализовывать полюс ассоциации со стороны целого в любом доступном виде.