智能指针和dynamic_cast

Question

如果这个答案已经被我回头看了，并且找不到答案，我会提前道歉。

注意：这IS一个家庭作业的任务，所以如果你觉得不舒服回答，我完全理解。

我有以下几点：

ptr.h：

template<typename T> 
class Ptr { 
    T* address; 
    size_t* counter; 
    Ptr(T* address) : address(address), counter(new size_t(1)) { } 
    Ptr(const Ptr& other) : address(other.address), counter(other.counter) 
    { 
     ++(*counter); 
    } 
    virtual ~Ptr() { 
     if (0 == --(*counter)) { delete address; delete counter; } 
    } 
    Ptr& operator=(const Ptr& right) { 
     if (address != right.address) { 
      if (0 == --(*counter)) { delete address; delete counter; } 
      address = right.address; 
      counter = right.counter; 
      ++(*counter); 
     } 
     return *this; 
    } 
    T& operator*() const { TRACE(address); return *address; } 
    T* operator->() const { TRACE(address); return address; } 
    T* raw()  const { TRACE(addr); return addr; } 
}; 

main.cc：现在

#include <iostream> 
#include "ptr.h" 

using std::cout; 
using std::endl; 


class Base { 
public: 
    Base() { std::cout << "Base()" << std::endl; } 
    virtual ~Base() { std::cout << "~Base()" << std::endl; } 
    virtual std::string str() { return "In Base::str()"; } 
}; 

class Derived: public Base { 
public: 
    Derived() { std::cout << "Derived()" << std::endl; } 
    ~Derived() { std::cout << "~Derived()" << std::endl; } 
    std::string str() { return "In Derived::str()"; } 
}; 



int main() { 
Ptr<Base> base(new Base()); 
Ptr<Derived> derived(new Derived()); 

Ptr<Base> pbase(0); 
Ptr<Derived> pderived(0); 

    // upcasting can be done like this, but is it the best way? 
    pbase = *((Ptr<Base>*)(&derived)); 
    cout << pbase->str() << endl; // outputs: "In Derived::str()" 

    /* 
    * downcasting should be done using dynamic_casts 
    * but how can I downcast here? 
    * what do I know so far: 
    * 1. just because Derived is a subclass of Base does not mean Ptr<Derived> is a 
    * subclass of Ptr<Base> so there is no hierarchy between the two so I cannot 
    * really use dynamic_casts here 
    * 2. The dynamic_cast I do use is sort of useless no? since pbase is a Ptr<Base> 
    */ 
    pderived = *((Ptr<Derived>*)(dynamic_cast<Ptr<Base>*>(&pbase))); 
    cout << pderived->str() << endl; 


return 0; 
} 

，我们的目标是使用dynamic_cast的去来回，和虽然我发现很多关于智能指针的有趣花絮没有真正解释这是如何实现的。

我试图刚开地址字段PBASE，然后初始化pderived到一个新的PTR与地址，但当然，我的引用计数得到了所有搞砸了。

我试图创建一个新的PTR那举行的pderived计数器的参考，但随后我无法设置的pderived所以我被困有太多的地址字段。

我告诉你们这个信息，因为：1。 我想提出一个观点，我一直在做这个很长一段时间，询问在线帮助和 2之前，我想让你知道我是什么已经尝试过了。

我真的可以在这里使用一些建议。只是如何得到：

pderived = <SOMETHINGSOMETHING>pbase<SOMETHINGSOMETHING> 

谢谢！

Answer 1

典型地，智能指针类会暴露一个动态铸造包装，与下面的智能指针对象正确的交易。例如，C++ 0x具有dynamic_pointer_cast函数。请注意，您的*((Ptr<Derived>*)(dynamic_cast<Ptr<Base>*>(&pbase)));可能并将会中断，特别是如果您有多重继承，因为它不会将address的内部指针调整到子类中的右侧偏移量以获取所需的任何超类。

在实现级别，一个引用计数智能指针类通常会携带在每个智能指针两个指针;直接一个点的对象（正确地浇铸到任何类型的指针是），以及一个点到包含一个引用计数，一个指针到原始对象，和指向例程缺失的结构。这允许指针的任何铸造变体正确取回原始对象并调用其析构函数。目前，您直接指向size_t，这不会提供此信息。在任何情况下，一旦你对析构函数有这样的间接性，当它投出这些智能指针的时候，那么，你只能指向外部的指针;只有当销毁时间流逝时才会留下内部参考计数结构。

其实转向到所有这些代码，当然，就留给读者做练习:)