1

我有一个像下面这样的智能指针类：

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


};

到目前为止一切正常，我想为 and 编写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);
}
4

1 回答 1

0

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

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

于 2013-04-17T02:41:11.620 回答