c++依赖注入：对象生命周期？

Question

我来自 C#，并尝试将我的一些实践转换为 C++。我在整个代码的各个地方使用原始指针使用了依赖注入。然后我决定用 std::shared_ptr 替换原始指针。作为该过程的一部分，建议我考虑使用堆栈分配的自动变量，而不是动态分配它们（请参阅 这个问题虽然这个问题是在 unique_ptr 的上下文中，所以也许是不同的）。

我相信下面的例子展示了自动变量的使用。

class MyClass
{ 
public:
   MyClass(ApplicationService& app): appService_(app)
   {
   }

   ~MyClass()
   {
        appService_.Destroy(something);

   }
private:   
   ApplicationService& appService_;
}

class ConsumerClass
{
    DoSomething()
    {
        CustomApplicationService customAppService;
        MyClass myclass(customAppService);
        myclass...
    }
}

在上面的示例中，当 customAppservice 和 myclass 超出范围时，我如何知道哪个将首先被销毁？如果 customAppService 首先被销毁，则 MyClass 析构函数将失败。在这种情况下，这是使用shared_ptr的好理由吗？还是有一个干净的方法可以解决这个问题？

更新

ApplicationService 是一个类，它是与我的代码使用的第三方库交互所需的全局函数的包装器。我有这个类，因为我相信它是支持单元测试和独立函数的存根/模拟的标准方法。该类只是将调用委托给相应的全局函数。调用 appService_.Destroy(something);实际上是销毁 MyClass 的每个特定实例使用的对象，而不是销毁与 Application 类本身有关的任何内容。

Answer 1

答案是：你不需要知道，因为无论如何你的设计已经被破坏了。

首先，Destroy 听起来像是一个坏主意，而且如果在一个不负责销毁另一个对象的对象中调用的话。 Destroy 方法中的代码属于 ApplicationService 的析构函数（希望是虚拟的，尽管在本例中实际上不需要），这与 C# 不同在完全确定的时间点被调用。

完成此操作后，您将（希望）意识到，销毁 appService_ 不是 MyClass 的责任，因为它不拥有它。这是 ConsumerClass（或者更确切地说是 DoSomething 方法）的责任，它真正管理实际的服务，并且在您移动后会自动销毁它将的代码销毁到析构函数中。 RAII 让一切以干净、自动的方式发生，这不是很好吗？

class MyClass
{ 
public:
   MyClass(ApplicationService& app): appService_(app)
   {
   }

private:   
   ApplicationService& appService_;
}

class ConsumerClass
{
    DoSomething()
    {
        CustomApplicationService customAppService;
        MyClass myclass(customAppService);
        myclass...
    }
}

class ApplicationService
{
public:
    virtual ~ApplicationService()
    {
        //code from former Destroy method
    }
}

class CustomApplicationService
{
public:
    virtual ~CustomApplicationService()
    {
        //code from former Destroy method
    }
}

恕我直言，这是围绕它的完美干净的 C++ 方法，并且该问题绝对不是垃圾邮件 shared_ptr 的原因。即使您确实需要专用的 Destroy 方法并且无法将代码移动到析构函数中（我将其视为过度思考设计的动机），那么您仍然会调用 Destroy > 再次来自 DoSomething，MyClass 不负责销毁 appService_。

编辑：根据你的更新（以及我对something论点的愚蠢忽视），你的设计似乎确实相当正确（至少如果你不能乱改变ApplicationService），抱歉。

尽管类成员应该以与构造相反的顺序被销毁，但我不确定这也适用于本地自动变量。为了确保按定义的顺序调用析构函数，您可以做的是使用简单的块引入嵌套作用域：

void DoSomething()
{
    CustomApplicationService customAppService;
    {
        MyClass myclass(customAppService);
        myclass...
    }       // myclass destroyed
}       // customAppService destroyed

当然，仍然完全不需要使用动态分配，更不用说 shared_ptr 了。尽管嵌套块对代码造成了一些影响，但这并不能阻止以非动态方式且毫无理由地应用动态分配的丑陋，而且它至少“在语义上看起来不错” customAppService块顶部的声明；）

Answer 2

在 C++ 中，通常，对象的销毁顺序与其创建顺序完全相反。

根据您的示例，MyClass 将在 CustomApplicationService 之前销毁

显式调用析构函数时例外。但是，我认为您现阶段不应该担心此异常。

另一个微妙之处称为 静态初始化顺序失败 。但是，这不适用于自动（堆栈）变量。

编辑：
来自 C++2003 - 寻找“反向顺序”

6.6.0.2

On exit from a scope (however accomplished), destructors (12.4) are called for all 
constructed objects with automatic storage duration (3.7.2) (named objects or 
temporaries) that are declared in that scope, in the reverse order of their
declaration. ... [Note: However, the program can be terminated (by calling exit()
or abort()(18.3), for example) without destroying class objects with automatic
storage duration. ]