As for the error you posted, that is a legitimate bug in my implementation. I have added an addendum to the main post which provides a fix for this.

You will have to modify the method of passing the argument to the base class accordingly since the direct parent of Derived_ will now be AbstractCloneableParent<Base> instead of Base itself, but the same principle still applies.

AbstractCloneable(const AbstractCloneable& copy) : T(copy) {}

and

Cloneable(const Cloneable& copy) : AbstractCloneable(copy) {}

are not needed (at least not in my example). Is there a particular reason why you provide these copy constructors?

Also, I am having still trouble understanding why the compiler complains about pure functions in my example:

cloneable2.cc:68: error: cannot allocate an object of abstract type ‘derived_’
cloneable2.cc:41: note: because the following virtual functions are pure within ‘derived_’:
cloneable2.cc:12: note: abstract_cloneable* abstract_cloneable::clone() const [with T = base_]

Do you have any ideas on that issue?

Derived_::Derived_(int i)
  : Base(Base::construct(i))
{}

What this does is use the Base_ constructor (aliased by Base::construct) to create a temporary Base_ object with the given parameter. Then, that object is passed to the copy constructor of Base (aka AbstractCloneable<Base_>) which in turn passes it on to the copy constructor of the Base_ class within the Derived_ object.

This requires creating a temporary object, so that’s something to look out for if your classes allocate a lot of memory or consume other resources, or if they have unusual copy semantics, but this should work for most cases.

The only case in which this definitely will not work is if Base_ contains pure virtual functions and cannot be directly instantiated. If this is case, you are probably stuck with using a factory pattern. However, a situation in which Base_ would both accept a constructor parameter and also be an abstract class would seem uncommon.

template <typename T>
class abstract_cloneable : public T
{
public:
    typedef T construct;

    abstract_cloneable() { }
    //abstract_cloneable(const abstract_cloneable<T>& copy) : T(copy) { }
    abstract_cloneable(const T& copy) : T(copy) {}
    virtual ~abstract_cloneable() { }

    virtual abstract_cloneable<T>* clone() const = 0;
};

template <typename T>
class cloneable : virtual public abstract_cloneable<T>
{
public:
    cloneable() { }
    //cloneable(const cloneable<T>& copy) : abstract_cloneable<T>(copy) { };
    cloneable(const T& copy) : abstract_cloneable<T>(copy) { };
    virtual ~cloneable() { }

    virtual cloneable<T>* clone() const
    {
        return new cloneable<T>(static_cast<const T&>(*this));
    }
};

class base_
{
protected:
    base_(int i) { }
    base_(const base_& copy) { }
};

typedef abstract_cloneable<base_> base;

class derived_ : public base
{
public:
    // Does not work, T (base_) is not a direct base of derived_.
    derived_() : base::construct(0) { }
    derived_(int i) : base::construct(i) { }

protected:
    derived_(const derived_& copy) : base(copy) { }
};

typedef cloneable<derived_> derived;

class derived2_ : public derived
{
public:
    derived2_() : derived() { }

protected:
    derived2_(const derived2_& copy) : derived(copy) { }
};

typedef cloneable<derived2_> derived2;

int main()
{
    derived d = derived::construct();
    derived e = derived::construct(42);

    return 0;
}

This is the compiler error message (tested with g++ 4.3 and 4.5):

cloneable2.cc: In constructor 'derived_::derived_()':
cloneable2.cc:44: error: type 'base_' is not a direct base of 'derived_'
cloneable2.cc: In constructor 'derived_::derived_(int)':
cloneable2.cc:46: error: type 'base_' is not a direct base of 'derived_'
cloneable2.cc: In function 'int main()':
cloneable2.cc:68: error: cannot allocate an object of abstract type 'derived_'
cloneable2.cc:41: note:   because the following virtual functions are pure within 'derived_':
cloneable2.cc:12: note: 	abstract_cloneable* abstract_cloneable::clone() const [with T = base_]
cloneable2.cc:69: error: cannot allocate an object of abstract type 'derived_'
cloneable2.cc:41: note:   since type 'derived_' has pure virtual functions
cloneable2.cc:68: warning: unused variable 'd'
cloneable2.cc:69: warning: unused variable 'e'
cloneable2.cc: In constructor 'abstract_cloneable::abstract_cloneable() [with T = base_]':
cloneable2.cc:44:   instantiated from here
cloneable2.cc:7: error: no matching function for call to 'base_::base_()'
cloneable2.cc:35: note: candidates are: base_::base_(const base_&)
cloneable2.cc:34: note:                 base_::base_(int)