C++ mẫu covariant

Question

Tôi cảm thấy như thế này đã được yêu cầu trước đó, nhưng tôi không thể tìm thấy nó trên SO, cũng không phải tôi có thể tìm thấy bất cứ điều gì hữu ích trên Google. Có lẽ "covariant" không phải là từ tôi đang tìm kiếm, nhưng khái niệm này rất giống với các kiểu trả về biến đổi trên các hàm, vì vậy tôi nghĩ nó có lẽ đúng. Dưới đây là những gì tôi muốn làm và nó mang lại cho tôi một lỗi trình biên dịch:

class Base; 
class Derived : public Base; 

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

Giả sử các lớp đó hoàn toàn có thịt ... Tôi nghĩ bạn sẽ có ý tưởng. Nó không thể chuyển đổi một số SmartPtr<Derived> thành một số SmartPtr<Base> vì một số lý do không rõ ràng. Tôi nhớ rằng điều này là bình thường trong C++ và nhiều ngôn ngữ khác, mặc dù tại thời điểm này tôi không thể nhớ tại sao.

Câu hỏi gốc của tôi là: cách tốt nhất để thực hiện thao tác gán này là gì? Hiện tại, tôi đang kéo con trỏ ra khỏi số SmartPtr, đưa nó lên loại cơ sở, sau đó gói nó vào một loại mới SmartPtr của loại thích hợp (lưu ý rằng đây không phải là tài nguyên bị rò rỉ vì lớp học SmartPtr được trồng tại nhà của chúng tôi sử dụng tham chiếu xâm nhập đếm). Đó là dài và lộn xộn, đặc biệt là khi tôi sau đó cần phải bọc SmartPtr trong một đối tượng khác ... bất kỳ phím tắt?

Answer 1

Cả trình tạo bản sao và toán tử gán đều có thể lấy SmartPtr của một loại khác và cố gắng sao chép con trỏ từ cái này sang cái khác. Nếu các loại không tương thích, trình biên dịch sẽ phàn nàn và nếu chúng tương thích, bạn đã giải quyết được vấn đề của mình. Một cái gì đó như thế này:

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

Phụ thuộc vào lớp học SmartPtr. Nếu nó có một hàm tạo bản sao (hoặc trong trường hợp của bạn, toán tử gán) mất SmartPtr<T>, trong đó T là kiểu được xây dựng, thì nó sẽ không hoạt động, vì SmartPtr<T1> không liên quan đến SmartPtr<T2> ngay cả khi T1 và T2 là liên quan đến thừa kế.

Tuy nhiên, nếu SmartPtr có templatized nhà xây dựng/nhà điều hành bản sao gán, với thông số mẫu TOther, chấp nhận SmartPtr<TOther>, thì nó sẽ hoạt động.

Answer 3

Giả sử bạn có quyền kiểm soát của lớp SmartPtr, giải pháp là để cung cấp một constructor templated:

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. 
}; 

Nếu các loại T và O tương thích, nó sẽ làm việc, nếu họ không phải là bạn sẽ nhận được một lỗi biên dịch.

Answer 4

SmartPtr<Base> và SmartPtr<Derived> là hai bản sao riêng biệt của mẫu SmartPtr. Các lớp mới này không chia sẻ thừa kế mà Base và Derived làm. Do đó, vấn đề của bạn.

what is the best way to perform this assignment operation?

SmartPtr<Base> b = d; 

Không gọi toán tử gán. Đây gọi là bản sao-ctor (bản sao được elided trong hầu hết các trường hợp) và là chính xác, nếu như bạn đã viết:

SmartPtr<Base> b(d); 

Cung cấp cho một bản sao-ctor mà phải mất một SmartPtr<OtherType> và thực hiện nó. Tương tự như vậy đối với toán tử gán. Bạn sẽ phải viết ra bản sao-ctor và op = ghi nhớ ngữ nghĩa của SmartPtr.

Answer 5

Mẫu không phải là biến thể và điều đó tốt; tưởng tượng điều gì sẽ xảy ra trong trường hợp sau đây:

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! 

Để đạt được những gì bạn đang cố gắng để làm, lớp SmartPointer phải có một constructor templatized, mà sẽ đưa một trong hai khác SmartPointer hoặc một con trỏ kiểu khác. Bạn có thể có một cái nhìn tại boost :: shared_ptr, mà thực hiện chính xác điều đó.

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

Tôi nghĩ điều đơn giản nhất là để cung cấp chuyển đổi tự động khác SmartPtr theo như sau:

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; 
}; 

Lưu ý rằng việc thực hiện này là mạnh mẽ theo nghĩa là mẫu nhà điều hành chuyển đổi không cần phải biết về ngữ nghĩa của con trỏ thông minh, vì vậy việc đếm tham chiếu không cần sao chép, vv