包装器接口的动态强制转换 在C++中，我希望能够做到以下几点： struct IWrapper { template<typename U> U* dynamic_cast_to() { ??? } // what to do here? }; template<typename T> struct Wrapper : IWrapper { Wrapper(T* _p) :p(_p) {} T* p; }; struct iwraper{ 模板 U*dynamic\U cast\U to（）{？？？}//在这里做什么？ }; 模板 结构包装器：IWrapper{ 包装器（T*\up）：p（\up）{} T*p； };

有了这个，我希望能够做到

SomeDerived *a = new SomeDerived;
IWrapper *x = new Wrapper<SomeDerived>(a);
SomeBase *b = x->dynamic_cast_to<SomeBase>()

SomeDerived*a=新的SomeDerived；
IWrapper*x=新包装（a）；
SomeBase*b=x->dynamic\u cast\u to（）

dynamic\u cast\u to（）

如果确实

SomeDerived

继承自

SomeBase

并且

NULL

如果不继承，则应返回指针，这与正常

dynamic\u cast

的工作方式相同

---

这是可能的吗？

给Iwraper一个虚拟析构函数，然后使用

动态\u cast

我很惊讶有人问我这个问题，如何实现

动态转换到
功能

那么，如何避免考虑标准的
动态\U cast
呢？
我不认为这可以用于任意类型的t和U。原因是
编译器必须在编译时为特定类型对生成动态转换代码，
在编译时，这两种类型都是已知的

如果可以将iwraper限制为仅适用于从具有虚拟成员函数的特定基派生的类型，那么它可以如下工作：

struct IWrapper {
    template<typename U>
    U* dynamic_cast_to() { return dynamic_cast<U*>(commonBasePtr()); }

    virtual CommonBase* commonBasePtr() = 0;
};

template<typename T>
struct Wrapper : IWrapper {
    Wrapper(T* _p) :p(_p) {}    
    T* p;

    virtual CommonBase* commonBasePtr() { return p; }
};

struct iwraper{
模板
U*dynamic_cast_to（）{返回dynamic_cast（commonBasePtr（））；}
虚拟CommonBase*commonBasePtr（）=0；
};
模板
结构包装器：IWrapper{
包装器（T*\up）：p（\up）{}
T*p；
虚拟CommonBase*commonBasePtr（）{return p；}
};
不可能这样，因为iwraper不知道关于t的任何信息，也无法访问指针。这应该起作用：

template <typename T>
struct IWrapper {
    IWrapper(T* p) : p_(p) {}
    template<typename U>
    U* dynamic_cast_to() { return dynamic_cast<U*>(p_); }
private:
    T* p_;
};

template<typename T>
struct Wrapper : IWrapper<T> {
    Wrapper(T* _p) : IWrapper<T>(_p), p(_p) {}    
    T* p;
};

struct SomeBase {
    int a;
};

struct SomeDerived : public SomeBase {
    int b;
};

int main()
{
    SomeDerived *a = new SomeDerived;
    IWrapper<SomeDerived> *x = new Wrapper<SomeDerived>(a);
    SomeBase *b = x->dynamic_cast_to<SomeBase>();
    return b->a;
}

模板
结构IWrapper{
IWrapper（T*p）：p_Up（p）{}
模板
U*dynamic_cast_to（）{返回dynamic_cast（p)}
私人：
T*p_；
};
模板
结构包装器：IWrapper{
包装器（T*\up）：Iwraper（\up），p（\up）{}
T*p；
};
结构SomeBase{
INTA；
};
struct SomeDerived:public SomeBase{
int b；
};
int main（）
{
SomeDerived*a=新的SomeDerived；
IWrapper*x=新包装（a）；
SomeBase*b=x->dynamic_cast_to（）；
返回b->a；
}
那是行不通的。能够
dynamic\u cast
SomeDerived
到
SomeBase
并不意味着你可以
dynamic\u cast
到
包装器
。这就是重点。您要求将
包装器
转换为
SomeBase
，而不是
包装器
。你是什么意思？两张反对票是什么意思？有什么需要解释的吗？他们在我看来很不合适。