Тип производного класса

#include <iostream>
#include <type_traits>
 
struct A {};
struct B : A {};
 
int main()
{
    A* pa = new B();
    static_assert(std::is_same<B, decltype(*pa)>::value, "*pa must be B type");
}

#include <iostream>
#include <memory>
 
template <typename T>
class ValuePtr
{
    T* p_;
    template <typename U> friend class ValuePtr;
 
public:
    explicit ValuePtr(T* p = nullptr) : p_(p) {}
    ~ValuePtr() { delete p_; }
    T& operator * () const { return *p_; }
    T* operator -> () const { return p_; }
 
    void swap(ValuePtr& other) noexcept { std::swap(p_, other.p_); }
 
    ValuePtr(const ValuePtr& other)
            : p_(other.p_ ? new T(*other.p_) : nullptr) {}
 
    ValuePtr& operator = (const ValuePtr& other)
    {
        ValuePtr temp(other);
        swap(temp);
        return *this;
    }
 
    template <typename U>
    ValuePtr(const ValuePtr<U>& other)
            : p_(other.p_ ? new T(*other.p_) : nullptr) {}
 
    template <typename U>
    ValuePtr& operator = (const ValuePtr<U>& other)
    {
        ValuePtr temp(other);
        swap(temp);
        return *this;
    }
};
 
struct A
{
    std::string aname{"A"};
    virtual void print() const { puts(aname.c_str()); }
};
struct B : A
{
    std::string bname{"B"};
    void print() const override { puts(bname.c_str()); }
};
 
int main()
{
    ValuePtr<A> a1(new B);
    a1->print(); // B
 
    ValuePtr<A> a2(a1);
    a2->print(); // A
 
    std::shared_ptr<A> a3(new B);
    a3->print(); // B
 
    std::shared_ptr<A> a4(a3);
    a4->print(); // B
}

    ValuePtr(const ValuePtr& other)
            : p_(other.p_ ? new T(*other.p_) : nullptr) {}

template <typename T>
class ValuePtr
{
    template <typename U> friend class ValuePtr;
 
    struct base_holder
    {
        virtual ~base_holder() {}
        virtual const std::type_info& type_info() const = 0;
        virtual T* get_pointer() const = 0;
    };
 
    //template <typename TE>
    struct holder : base_holder
    {
        T* t_;
        holder(T* t) : t_(t) {}
 
        const std::type_info &type_info() const override
        {
            return typeid(t_);
        }
 
        ~holder() { delete t_; }
 
        T* get_pointer() const override { return t_;}
    };
 
    base_holder* held_;
 
public:
    template <typename U>
    explicit ValuePtr(U* p = nullptr) : held_(new holder(p)) {}
    
 
    template <typename U>
    ValuePtr(const ValuePtr<U>& other) :  held_(new holder(new HowGetDerivedType(*other))) {}
 
    ~ValuePtr() { delete held_; }
 
    T& operator * () const { return *held_->get_pointer(); }
    T* operator -> () const { return held_->get_pointer(); }
 
};
 
 
struct A
{
    std::string aname{"A"};
    virtual void print() const { puts(aname.c_str()); }
};
 
struct B : A
{
    std::string bname{"B"};
    void print() const override { puts(bname.c_str()); }
};
 
int main()
{
    ValuePtr<A> a1(new B);
    a1->print();
 
    ValuePtr<A> a2(a1);
    a2->print();
}