无法动态投射到PTR

Question

I am trying to implement very basic class similar to boost::any, but there is a problem I am facing with and I cannot overpass this. Problem is with casting pointer to another using dynamic_cast with error saying:

cannot dynamic_cast 'input.Any::m_targetPtr' (of type 'class Any::StorageInterface*') to type 'int*' (target is not pointer or reference to class)

source of class is as follows:

class Any{
public:
    template <typename T>
    Any(T input): m_targetPtr(new StorageImpl<T>(input)){}
    ~Any(){delete m_targetPtr;}

    class StorageInterface{
    public:
        virtual ~StorageInterface(){}
    };

    template<typename T>
    T* cast(Any& input){
        return dynamic_cast<T*>(input.m_targetPtr); //here comes the trouble
    }

    template <typename T>
    class StorageImpl : public StorageInterface{
    public:
        StorageImpl(T& input): m_target(&input){}
        T* m_target;
    };

    StorageInterface* m_targetPtr;
};

and this is how I want to execute this:

int i=150;
Any asdf(i);
cout<< (asdf.cast<int>(asdf)) << endl;

So my understanding is. I have an int variable and to the cast template I pass pointer to this int and T in template is int, therefore in the cast source we have int as deduced parameter int* as returning value and I execute dynamic_cast<int*> with argument m_target of type StorageInterface* . Why then I am getting an error, that my target is not a pointer?

Answer 1

I see the following problems in the following code.

template<typename T>
T* cast(Any input){
    return dynamic_cast<T*>(input.m_targetPtr); //here comes the trouble
}

1. You need to cast to StorageImpl<T>* , not T* .

2. StorageImpl doesn't expose its member, m_target .

Expose the m_target member, by making it public or providing a function that returns the value.

Change the cast function to:

template<typename T>
T* cast(Any input){
    return dynamic_cast<StorageImpl<T>*>(input.m_targetPtr)->m_target;
}

Suggestion for improvement:

You don't need the input argument in cast . It can be:

template<typename T>
T* cast(){
    return dynamic_cast<StorageImpl<T>*>(m_targetPtr)->m_target;
}

Then, your call can also be simplified to:

cout<< (asdf.cast<int>()) << endl;
                  //  ^^^ No need to use asdf again in the call.

Suggestions for further improvement

The StorageImpl in your posted code stores a pointer to an object that can easily become invalid. I would recommend storing an object instead. Then, Any::cast() can return a reference instead of a pointer.

class Any {
   public:
      template <typename T>
         Any(T input): m_targetPtr(new StorageImpl<T>(input)){}
      ~Any(){delete m_targetPtr;}

      class StorageInterface {
         public:
            virtual ~StorageInterface(){}
      };

      template<typename T>
         T const& cast() const {
            return dynamic_cast<StorageImpl<T>*>(m_targetPtr)->m_target;
         }

      template<typename T>
         T& cast() {
            return dynamic_cast<StorageImpl<T>*>(m_targetPtr)->m_target;
         }

      template <typename T>
         class StorageImpl : public StorageInterface {
            public:
               StorageImpl(T const& input): m_target(input){}
               T m_target;
         };

      StorageInterface* m_targetPtr;
};

Answer 2

The issue is that dynamic_cast<T>(X) cannot convert type X to type T if X doesn't belong in the same class hierarchy as T . Dynamic cast is meant for polymorphism, for down-casting Animal* to Dog* , for example, where class Dog inherits from class Animal and class Animal contains a virtual function. The problem is that int is not a class type, so dynamic_cast can conclude early that int and StorageInterface don't share a class heirarchy.

The error message is not saying that your target is not a pointer, it's saying that your target is not a pointer to a class object (and isn't a reference to a class object either).

R Sahu makes the point that you meant to cast to StorageImpl<T>* , which makes a lot more sense.

Answer 3

dynamic_cast<T> is intended to use to convert a pointer to a polymorphic struct to another polymorphic struct in the same hierarchy. A polymorphic struct is a struct with at least one virtual function or virtual inheritance. Clearly, int* is not a struct and is not polymorphic.

You probably meant to make this cast instead:

template<typename T>
T* cast(Any input){
    return dynamic_cast<StorageImpl<T>*>(input.m_targetPtr)->m_target; // better?
}

And why sending a copy of the object to itself? I would be less error-prone to limit the function to the instance itself:

template<typename T>    
T* cast(){
    return dynamic_cast<StorageImpl<T>*>(m_targetPtr)->m_target; // even better
}

You can use it like this now:

asdf.cast<int>();

Finally, to make your code even cleaner and less error prone, one last thing could be done. Did you see the potential undefined behaviour? You have a double deletion in you code:

template<typename T>
T* cast(Any input){
    return dynamic_cast<T*>(input.m_targetPtr); //here comes the trouble
    // input is deleted here, so asdf will have a dangling pointer and double delete the m_targetPtr!
}

And in your constructor, you save the address of a temporary:

// input is a reference to a variable from the 'Any' class constructor, it will be deleted
StorageImpl(T& input): m_target(&input){}

Passing by value (and move) could fix this.

Any code using this class is subject to these error. Using a std::unique_ptr and value semantics will do the trick:

struct Any {
    template <typename T>
    Any(T input): m_targetPtr(new StorageImpl<T>(std::move(input))){}
    /* ~Any(){delete m_targetPtr;} */
    // no destructor needed here, you can safely remove the line above.

    // you could implement a copy constructor which clone the m_targetPtr.

    class StorageInterface{
    public:
        virtual ~StorageInterface(){}
    };

    template<typename T>
    T& cast(){
        return dynamic_cast<StorageImpl<T>*>(m_targetPtr.get())->m_target;
    }


    template <typename T>
    class StorageImpl : public StorageInterface{
    public:
        StorageImpl(T input): m_target(std::move(input)){}
        T m_target;
    };

private:
    std::unique_ptr<StorageInterface> m_targetPtr;
};

This code will require T to be moveable.