Inheritance 返回接口的共享\u ptr

因此，我正在黑客攻击我的代码，试图使用GCC4.5将其转换成一些半正常的C++0x代码

shared_ptr<IEngineLayer*> createEngineLayer(void)
{
    try
    {
        CEngineLayer* engine = new CEngineLayer;
        IEngineLayer* interface = dynamic_cast<IEngineLayer*>(engine);

        return shared_ptr<IEngineLayer*>(interface);
    }
    catch(std::bad_alloc&)
    {
        // Unable to allocate enough memory for the engine layer.
        return shared_ptr<IEngineLayer*>();
    }
}

shared\ptr createEngineLayer（无效）
{
尝试
{
CEngineLayer*引擎=新的CEngineLayer；
IEngineLayer*接口=动态投影（引擎）；
返回共享ptr（接口）；
}
捕获（标准：：错误分配&）
{
//无法为引擎层分配足够的内存。
返回共享_ptr（）；
}
}

我明白了

shared_ptr_base.h:545:65:错误：无法在初始化中将“DEngine:：IEngineLayer*”转换为“DEngine:：IEngineLayer**”

我怎样才能解决这个问题

（另外，作为旁注，当没有人再使用它时，共享\u ptr是否会破坏接口和CEngineLayer？

返回一个

共享\u ptr

也不需要演员阵容：

shared_ptr<IEngineLayer> createEngineLayer()
{
    try
    {
        CEngineLayer* engine = new CEngineLayer;

        return shared_ptr<IEngineLayer>(engine);
    }
    catch(std::bad_alloc&)
    {
        // Unable to allocate enough memory for the engine layer.
        return shared_ptr<IEngineLayer>();
    }
}

shared_ptr createEngineLayer（）
{
尝试
{
CEngineLayer*引擎=新的CEngineLayer；
返回共享的ptr（引擎）；
}
捕获（标准：：错误分配&）
{
//无法为引擎层分配足够的内存。
返回共享_ptr（）；
}
}

A

shared\u ptr

为指向

T

的指针建模，A

shared\u ptr

为指向

T

的指针建模

假设

CEngineLayer

是

IEngineLayer

，您可以将代码更改为：

shared_ptr<IEngineLayer> createEngineLayer()
{
    try
    {
        return shared_ptr<IEngineLayer>(new CEngineLayer);
    }
    catch(const std::bad_alloc&)
    {
        // Unable to allocate enough memory for the engine layer.
        return shared_ptr<IEngineLayer>();
    }
}

shared_ptr createEngineLayer（）
{
尝试
{
返回共享ptr（新层）；
}
捕获（const std:：bad_alloc&）
{
//无法为引擎层分配足够的内存。
返回共享_ptr（）；
}
}

还请注意，“派生到基本”转换不需要显式强制转换：如果

CEngineLayer

公开继承自

IEngineLayer

，则指向

CEngineLayer

的指针可以隐式转换为指向

IEngineLayer

的指针

另外，作为旁注，将共享 销毁接口和 当没有人使用它时，请使用它 还有吗

---

有一个类型为

CEngineLayer

的对象，如果

IEngineLayer

中的析构函数是虚拟的（并且应该是虚拟的），那么当引用计数达到0时，该对象将被正确销毁。

您也可以使用make_shared，从性能角度来看，这是更好的：

std::shared_ptr<IEngineLayer> createEngineLayer(void)
{
    return std::make_shared<CEngineLayer>();
}

std:：shared_ptr createEngineLayer（无效）
{
返回std:：make_shared（）；
}

以下代码也可能导致内存泄漏：

std::shared_ptr<IEngineLayer> createEngineLayer(void)
{
    IEngineLayer* pInterface = new CEngineLayer;

    return std::shared_ptr<IEngineLayer>(pInterface);
}

std:：shared_ptr createEngineLayer（无效）
{
IEngineLayer*pInterface=新的CEngineLayer；
返回std:：shared_ptr（pInterface）；
}

---

在这种情况下，shared_ptr会删除一个IEngineLayer而不是CEngineLayer

谢谢，我遵循了其他STD容器（如vector）的思路，而不是记住它是一个指针。感谢您提供的单一对象信息。