Question

我有一个类似下面的智能指针类：

template <class T>
class Sptr {
    template<typename U> friend class Sptr;

    template <typename T1, typename T2>
    friend bool operator==(const Sptr<T1> &a, const Sptr<T2> &b);
private:
    T* obj;//pointer to current obj
    RC* ref; //reference counter
    std::function<void()> destroyData;
    bool ok_;

public:
    Sptr();
    ~Sptr();

    template <typename U> 
    Sptr(U *);

    Sptr(const Sptr &);

    template <typename U> 
    Sptr(const Sptr<U> &);

    template <typename U> 
    Sptr<T> &operator=(const Sptr<U> &);

    Sptr<T> &operator=(const Sptr<T> &);

    void reset();

    T* operator->() const
    {return obj;};

    T& operator*() const
    {return *obj;};

    T* get() const
    {return obj;};

    explicit operator bool() const {
          return ok_;
    }


};

到目前为止，一切正常，我想为static_pointer_cast和dynamic_pointer_cast编写函数。我不知道如何继续前进。有谁能指导我正确的方向。下面是一个示例测试代码，我打算通过它来测试它。（c ++ 11件好事）

// Test static_pointer_cast.
{
    Sptr<Derived> sp(new Derived);
    Sptr<Base1> sp2(sp);

    Sptr<Derived> sp3(static_pointer_cast<Derived>(sp2));
}

// Test dynamic_pointer_cast.
{
    Sptr<Derived_polymorphic> sp(new Derived_polymorphic);
    Sptr<Base_polymorphic> sp2(sp);

    Sptr<Derived_polymorphic> sp3(dynamic_pointer_cast<Derived_polymorphic>(sp2));
    Sptr<Derived_polymorphic> sp4(static_pointer_cast<Derived_polymorphic>(sp2));
    Sptr<Derived2_polymorphic> sp5(dynamic_pointer_cast<Derived2_polymorphic>(sp2));
    assert(!sp5);
}

Answer 1

两个强制转换都是模板（可能是朋友），它们创建一个新的Sptr不同的类型，使用强制转换为基础指针初始化，并根据需要增加引用计数。主要的复杂性是你需要将不同类型的多个指针连接到同一个完整对象，并且当最后一个（无论哪种类型）超出范围时，你需要管理使用正确指针调用删除器。

一种可能的方法是将删除器和原始指针存储在引用计数对象中（顺便说一下，删除器应该一直在那里，你只需要一个副本！）。每个Sptr都有一个不同类型的原始指针，但当它消失时，它会使用删除器中存储在引用计数中的指针。

如何重载static和dynamic_pointer_cast

1 个答案: