Szablony covariant w C++

Question

Mam wrażenie, że wcześniej ktoś o to pytał, ale nie mogę go znaleźć na SO, ani nie mogę znaleźć niczego przydatnego w Google. Może "kowariancja" nie jest słowem, którego szukam, ale ta koncepcja jest bardzo podobna do kowariantnych typów zwrotów funkcji, więc myślę, że to prawdopodobnie jest poprawne. Oto, co chcę zrobić i to daje mi błąd kompilatora:

class Base; 
class Derived : public Base; 

SmartPtr<Derived> d = new Derived; 
SmartPtr<Base> b = d; // compiler error 

Przyjmijmy te zajęcia są w pełni uregulowana ... Myślę, że masz pomysł. Nie można przekonwertować wartości SmartPtr<Derived> na SmartPtr<Base> z jakiegoś niejasnego powodu. Pamiętam, że jest to normalne w C++ i wielu innych językach, choć w tej chwili nie pamiętam dlaczego.

Moje główne pytanie brzmi: jaki jest najlepszy sposób wykonania tej operacji przypisania? Obecnie wyciągam wskaźnik z SmartPtr, wyraźnie upcasting go do typu podstawowego, a następnie owijając go w nowy SmartPtr odpowiedniego typu (należy pamiętać, że nie jest to przeciekające zasoby, ponieważ nasza rodzima klasa SmartPtr używa nachalnych odniesień rachunkowość). To długo i niechlujnie, zwłaszcza, gdy muszę następnie owinąć SmartPtr w jeszcze jeden obiekt ... dowolne skróty?

Answer 1

Zarówno konstruktor kopiowania, jak i operator przypisania, powinni mieć możliwość pobrania SmartPtr innego typu i próby skopiowania wskaźnika z jednego do drugiego. Jeśli typy nie są kompatybilne, kompilator będzie narzekał, a jeśli są one zgodne, to rozwiązałeś swój problem. Coś takiego:

template<class Type> class SmartPtr 
{ 
    .... 
    template<class OtherType> SmartPtr(const SmartPtr<OtherType> &blah) // same logic as the SmartPtr<Type> copy constructor 

    template<class OtherType> SmartPtr<Type> &operator=(const SmartPtr<OtherType> &blah) // same logic as the SmartPtr<Type> assignment operator 
}; 

Answer 2

Zależy od klasy SmartPtr. Jeśli ma konstruktora kopiowania (lub w twoim przypadku operatora przypisania), który zajmuje SmartPtr<T>, gdzie T jest typem, z którym został zbudowany, to nie zadziała, ponieważ SmartPtr<T1> nie ma związku z SmartPtr<T2>, nawet jeśli T1 i T2 są powiązane z dziedziczeniem.

Jeśli jednak SmartPtr ma templatized operatora kopii konstruktor/przydziału, z parametrem szablonu TOther, który przyjmuje SmartPtr<TOther>, to powinien działać.

Answer 3

Zakładając, że mamy kontrolę nad klasie SmartPtr, rozwiązaniem jest zapewnienie szablonie konstruktora:

template <class T> 
class SmartPtr 
{ 
    T *ptr; 
public: 

    // Note that this IS NOT a copy constructor, just another constructor that takes 
    // a similar looking class. 
    template <class O> 
    SmartPtr(const SmartPtr<O> &src) 
    { 
     ptr = src.GetPtr(); 
    } 
    // And likewise with assignment operator. 
}; 

Jeśli typy T i O są zgodne, to będzie działać, jeśli nie dostaniesz błędu kompilacji.

Answer 4

SmartPtr<Base> i SmartPtr<Derived> są dwiema różnymi instancjami szablonu SmartPtr. Te nowe klasy nie współdzielą dziedziczenia, które robią: Base i Derived. Stąd twój problem.

what is the best way to perform this assignment operation?

SmartPtr<Base> b = d; 

Nie wywoływać operator przypisania. To wywołuje copy-konstruktor (kopia jest pomijana w większości przypadków) i jest dokładnie tak, jak gdybyś napisał:

SmartPtr<Base> b(d); 

Zapewnić kopiowaniem ctor że trwa SmartPtr<OtherType> i wdrożyć go. To samo dotyczy operatora przypisania. Będziesz musiał napisać copy-ctor i op = pamiętając o semantykach SmartPtr.

Answer 5

Szablony nie są kowariantne i to dobrze; sobie wyobrazić, co by się stało w następującym przypadku:

vector<Apple*> va; 
va.push_back(new Apple); 

// Now, if templates were covariants, a vector<Apple*> could be 
// cast to a vector<Fruit*> 
vector<Fruit*> & vf = va; 
vf.push_back(new Orange); // Bam, we just added an Orange among the Apples! 

Aby osiągnąć to, co staramy się robić, klasa sprytny wskaźnik musi mieć templatized konstruktora, że ​​trwa albo inny sprytny wskaźnik lub wskaźnik innego typu. Możesz rzucić okiem na boost :: shared_ptr, co robi dokładnie to.

template <typename T> 
class SmartPointer { 

    T * ptr; 

    public: 
    SmartPointer(T * p) : ptr(p) {} 
    SmartPointer(const SmartPointer & sp) : ptr(sp.ptr) {} 

    template <typename U> 
    SmartPointer(U * p) : ptr(p) {} 

    template <typename U> 
    SmartPointer(const SmartPointer<U> & sp) : ptr(sp.ptr) {} 

    // Do the same for operator= (even though it's not used in your example) 
}; 

Answer 6

Myślę, że najłatwiej jest zapewnienie automatycznej konwersji do innego SmartPtr zgodnie z poniższym:

template <class T> 
class SmartPtr 
{ 
public: 
    SmartPtr(T *ptr) { t = ptr; } 
    operator T *() const { return t; } 
    template <class Q> operator SmartPtr<Q>() const 
    { return SmartPtr<Q>(static_cast<Q *>(static_cast<T *>(* this))); } 
private: 
    T *t; 
}; 

pamiętać, że ta realizacja jest mocny w tym sensie, że szablon operator konwersji nie musi znać semantykę inteligentnego wskaźnika, więc liczenie odwołań nie musi być replikowane itp.