C++ 中的工厂和动态分配问题

Question

我有一个工厂，可以在我的应用程序中构建生命周期最长的对象。它们有类型，比如说ClientA 和ClientB，它们依赖于Provider（具有许多可能实现的抽象类），因此两个客户端都引用了Provider 作为成员。

根据命令行参数，工厂选择Provider 的一种实现，构造它（使用“new”），并将其传递给两个客户端的构造函数。

工厂返回一个代表我的整个应用程序的对象。我的主要功能基本上是这样的：

int main(int argc, char** argv)
{
    AppFactory factory(argc, argv);
    App app = factory.buildApp();
    return app.run();
}

而buildApp的方法基本上是这样的：

App AppFactory::buildApp()
{
    Provider* provider = NULL;

    if (some condition)
    {
        provider = new ProviderX(); 
    }
    else
    {
        provider = new ProviderY();
    }

    ClientA clientA(*provider);
    ClientB clientB(*provider);

    App app(clientA, clientB);
    return app;
}

所以，当执行结束时，所有对象的析构函数都会被调用，除了提供者对象（因为它是用“new”构造的）。

如何改进此设计以确保调用提供程序的析构函数？

编辑：澄清一下，我的意图是客户端、提供者和 App 对象共享相同的生命周期。在所有答案之后，我现在认为客户端和提供者都应该在堆上分配其传递给 App 对象的引用，该对象将负责在它死时删除它们。你说什么？

Answer 1

使用共享所有权智能指针非常简单：

App AppFactory::buildApp()
{
    boost::shared_ptr<Provider> provider;

    if (some condition)
    {
        provider.reset(new ProviderX()); 
    }
    else
    {
        provider.reset(new ProviderY());
    }

    ClientA clientA(provider);
    ClientB clientB(provider);

    App app(clientA, clientB);
    return app;
}

假设 app 对象拥有客户端，并且客户端都共享一个提供者。然后让客户使用shared_ptr<Provider>，而不是Provider&。只要仍然存在拥有提供者对象的 shared_ptr 的副本，就不会释放该对象。

最好不要复制clientA和clientB，也不要通过值返回来复制app，而是将客户端移动到应用中，并将应用本身移动到返回的对象中。这将在即将推出的 C++ 版本中成为可能。但目前，要么将它们设为指针（使用 shared_ptr），要么继续复制它们。另一种选择是使用 auto_ptr，它具有伪所有权转移语义。但该模板存在一些固有问题。所以你应该避免使用它。

Answer 2

使提供者成为 AppFactory 的实例变量。然后将 provider 设为智能指针或在 AppFactory 的 dtor 中将其删除。

Answer 3

除非 App 的构造函数复制客户端，否则它们也需要进行 new() 处理 - 当前的客户端分配在堆栈上，并在应用返回时被删除。

我认为您可能需要注意正在创建哪些对象 - 例如将调试语句放在客户端的构造函数中。

你可能想要的是让 Provider 被引用计数，并且让每个 Client 只是减少引用计数，但这是很多工作。

或者让 AppFactory 拥有 Provider。

Answer 4

这里没有足够的帮助，但是你可以在不改变太多的情况下向 Provider 对象添加引用计数，当客户端被破坏时，它们会删除引用。当 Provider 对象中的引用变为 0 时，调用 delete this。

你的生命周期和范围有点粗略。为什么你要在堆栈上创建一些对象，而在堆上创建一些对象——特别是你的客户？

Answer 5

一种选择是让工厂返回一个包含工厂构造的所有组件的 AppComponents 对象。 IE。像这样：

int main(int argc, char** argv)
{
    AppFactory factory(argc, argv);
    AppComponents components = factory.buildApp();
    return components.getApp().run();
}

AppComponents 类将负责删除您的 Provider 和其他对象。

Answer 6

将provider设为AppFactory的成员变量，并在析构函数中删除：

class AppFactory
{
    public:
    AppFactory(int argc, char** argv) : provider(NULL)
    {
       //...
    }
    ~AppFactory()
    {
        if (provider != NULL)
            delete provider;
    }
    App buildApp()
    {

        if (some condition)
        {
            provider = new ProviderX(); 
        }
        else
        {
            provider = new ProviderY();
        }

        ClientA clientA(*provider);
        ClientB clientB(*provider);

        App app(clientA, clientB);
        return app;

    } 
    private:
    Provider* provider;

};

int main(int argc, char** argv)
{
    AppFactory factory(argc, argv);
    App app = factory.buildApp();
    return app.run();
}

Answer 7

您说“提供程序和 App 对象共享相同的生命周期”，但要注意在 C++ 中，以下代码片段...

App app(clientA, clientB);
return app;

... 正在返回 App 对象的 copy：因此您可能（取决于编译器，例如参见 http://msdn.microsoft.com/en-us/library/ms364057(VS.80).aspx）实际上有两个 App 对象实例（一个在 AppFactory 内） ::buildApp() 方法和 main 函数中的另一个）。

为了回答您的问题，我想我同意您的编辑：将指向提供程序的指针传递到您的 App 构造函数中，将其存储为 App 实例的成员数据，并在您销毁 App 实例时将其删除。但是，除此之外，您还可以更改代码以确保不复制 App 实例：例如，在堆上分配 App 实例，更改 AppFactory::buildApp() 方法以返回指向App，并在 main 函数结束时删除 App 实例。

Answer 8

只要打电话

delete provider;
provider = NULL;

在 ClientA 和 ClientB 的析构函数中。这也会调用提供者的析构函数。