Блог

У меня есть абстрактный класс Handle<T>, который содержит ссылки на объекты типа T. Я хочу, чтобы этот класс мог быть преобразован в Handle<U> , где U — суперкласс T. Я бы использовал наследование, но здесь это не работает. Как бы я это сделал? Какие есть хорошие альтернативы?

Пример псевдокода:

 template<class T>
class Handle {
public:
    virtual ~Handle () {}
    virtual T amp; operator* () const = 0;
    virtual T * operator-> () const = 0;
    virtual template<class U> operator Handle<U>* () const = 0; // being lazy with dumb pointer
};

template<class T>
class ConcreteHandle : public Handle<T> {
public:
    explicit template<class U> ConcreteHandle (U * obj) : obj(obj) {}
    virtual ~ConcreteHandle () {}
    virtual T amp; operator* () const {
        return *obj;
    }
    virtual T * operator-> () const {
        return obj;
    }
    virtual template<class U> operator Handle<U>* () {
        return new ConcreteHandle<U>(obj);
    }
private:
    T * obj;
};
  

Как и было запрошено, это то, что я делаю

 class GcPool {
public:
    virtual void gc () = 0;
    virtual Handle<GcObject> * construct (GcClass clazz) = 0;
};

class CompactingPool : public GcPool {
public:
    virtual void gc () { ... }
    virtual Handle<GcObject> * construct (GcClass clazz) { ... }
private:
    Handle<GcList<Handle<GcObject> > > rootSet; // this will grow in the CompactingPool's own pool
    Handle<GcList<Handle<GcObject> > > knownHandles; // this will grow in the CompactingPool's own pool.
};
  

knownHandles должен быть совместим с Handle, чтобы он мог находиться в корневом наборе CompatingPool. То же самое касается rootSet. Я загружу эти специальные дескрипторы, чтобы не возникло проблемы с курицей и яйцом.

 virtual template<class U> operator Handle<U>* () const  =0;
  

Виртуальная функция шаблона не разрешена спецификацией языка.

Рассмотрите этот код в ideone, а затем увидите ошибку компиляции:

ошибка: шаблоны могут быть не ‘виртуальными’

Что теперь вы можете сделать? Одно из решений заключается в следующем:

 template<class T>
class Handle {
public:

    typedef typename T::super super; //U = super, which is a superclass of T.

    virtual ~Handle () {}
    virtual T amp; operator* () const = 0;
    virtual T * operator-> () const = 0;

    //not a template now, but still virtual
    virtual super operator Handle<super> () const = 0;  
};
  

То есть определите typedef базовый класс в производном классе и используйте его в Handle . Что-то вроде этого:

 struct Base {//...};

struct Derived : Base { typedef Base super; //...};

Handle<Derived>  handle; 
  

Или вы можете определить признаки, как:

 struct Base {//... };

struct Derived : Base { //... };

template<typename T> struct super_traits;

struct super_traits<Derived>
{
   typedef Base super;
};

template<class T>
class Handle {
public:

    typedef typename super_traits<T>::super super; //note this now!

    virtual ~Handle () {}
    virtual T amp; operator* () const = 0;
    virtual T * operator-> () const = 0;

    //not a template now, but still virtual
    virtual super operator Handle<super> () const = 0; 
};
  

На мой взгляд, super_traits это превосходное решение, поскольку вы определяете свойства производных классов без их редактирования. Кроме того, вы можете определить столько определений типов, сколько захотите; допустим, ваш производный класс имеет более одной базы, вы можете захотеть определить много определений типов или, предпочтительно, список типов.