关于智能指针和新的 C++11/14 功能，我想知道对于具有这些功能的类，最佳实践返回值和函数参数类型是什么:

1. 一个工厂函数(在类之外)，它创建对象并将它们返回给类的用户。 (例如打开一个文档并返回一个可用于访问内容的对象。)

2. 从工厂函数接受对象的实用函数，使用它们，但不取得所有权。 (例如计算文档中单词数的函数。)

3. 在对象返回后保留对对象的引用的函数(例如，获取对象拷贝以便根据需要在屏幕上绘制内容的 UI 组件。)

工厂函数的最佳返回类型是什么？

• 如果它是一个原始指针，用户将不得不指向 delete它是正确的，这是有问题的。
• 如果返回 unique_ptr<>那么用户就无法共享它。
• 如果是 shared_ptr<>那我要不要绕过shared_ptr<>到处都是类型？这就是我现在正在做的事情，它会导致问题，因为我得到循环引用，防止对象被自动销毁。

效用函数的最佳参数类型是什么？

• 我想通过引用传递将避免不必要地增加智能指针引用计数，但这有什么缺点吗？我想到的主要问题是它阻止我将派生类传递给采用基类类型参数的函数。
• 有没有什么方法可以让调用者清楚它不会复制对象？ (理想情况下，如果函数体尝试复制对象，代码将无法编译。)
• 有没有办法让它独立于使用的智能指针的类型？ (也许采用原始指针？)
• 是否有可能拥有 const参数以明确该函数不会修改对象，而不会破坏智能指针的兼容性？

保持对对象的引用的函数的最佳参数类型是什么？

• 我猜 shared_ptr<>是这里唯一的选项，这可能意味着工厂类必须返回 shared_ptr<>也是，对吧？

这里有一些代码可以编译并希望能说明要点。

#include <iostream>
#include <memory>

struct Document {
    std::string content;
};

struct UI {
    std::shared_ptr<Document> doc;

    // This function is not copying the object, but holding a
    // reference to it to make sure it doesn't get destroyed.
    void setDocument(std::shared_ptr<Document> newDoc) {
        this->doc = newDoc;
    }
    void redraw() {
        // do something with this->doc
    }
};

// This function does not need to take a copy of the Document, so it
// should access it as efficiently as possible.  At the moment it
// creates a whole new shared_ptr object which I feel is inefficient,
// but passing by reference does not work.
// It should also take a const parameter as it isn't modifying the
// object.
int charCount(std::shared_ptr<Document> doc)
{
    // I realise this should be a member function inside Document, but
    // this is for illustrative purposes.
    return doc->content.length();
}

// This function is the same as charCount() but it does modify the
// object.
void appendText(std::shared_ptr<Document> doc)
{
    doc->content.append("hello");
    return;
}

// Create a derived type that the code above does not know about.
struct TextDocument: public Document {};

std::shared_ptr<TextDocument> createTextDocument()
{
    return std::shared_ptr<TextDocument>(new TextDocument());
}

int main(void)
{
    UI display;

    // Use the factory function to create an instance.  As a user of
    // this class I don't want to have to worry about deleting the
    // instance, but I don't really care what type it is, as long as
    // it doesn't stop me from using it the way I need to.
    auto doc = createTextDocument();

    // Share the instance with the UI, which takes a copy of it for
    // later use.
    display.setDocument(doc);

    // Use a free function which modifies the object.
    appendText(doc);

    // Use a free function which doesn't modify the object.
    std::cout << "Your document has " << charCount(doc)
        << " characters.\n";

    return 0;
}

最佳答案

我会以相反的顺序回答，所以从简单的案例开始。

Utility functions that accept objects from the factory functions, use them, but do not take ownership. (For example a function that counts the number of words in the document.)

如果你调用一个工厂函数，你总是通过工厂函数的定义来获得所创建对象的所有权。我认为您的意思是某些 other 客户端首先从工厂获取一个对象，然后希望将其传递给本身不拥有所有权的实用程序函数。

在这种情况下，效用函数根本不应该关心它所操作的对象的所有权是如何管理的。它应该简单地接受一个(可能是 const )引用，或者——如果“无对象”是一个有效条件——一个非拥有的原始指针。这将最大限度地减少接口(interface)之间的耦合，并使实用程序功能最灵活。

Functions that keep a reference to the object after they return (like a UI component that takes a copy of the object so it can draw the content on the screen as needed.)

这些应该是 std::shared_ptr 按值(value)。这从函数的签名中清楚地表明，它们共享参数的所有权。

有时，拥有一个对其参数具有唯一所有权的函数也很有意义(想到的是构造函数)。那些应该采取 std::unique_ptr 按值(或按右值引用)，这也将使签名中的语义清晰。

A factory function (outside of the class) that creates objects and returns them to users of the class. (For example opening a document and returning an object that can be used to access the content.)

这是一个困难的，因为两者都有很好的论据，std::unique_ptr和 std::shared_ptr .唯一清楚的是返回一个拥有的原始指针是不好的。

返回 std::unique_ptr是轻量级的(与返回原始指针相比没有开销)并且传达了工厂函数的正确语义。调用该函数的人将获得对制造对象的独占所有权。如果需要，客户可以构造一个std::shared_ptr出std::unique_ptr以动态内存分配为代价。

另一方面，如果客户需要 std::shared_ptr无论如何，让工厂使用 std::make_shared 会更有效。以避免额外的动态内存分配。此外，在某些情况下，您只需使用 std::shared_ptr例如，如果托管对象的析构函数是非 virtual并且智能指针将被转换为指向基类的智能指针。但是一个std::shared_ptr开销大于 std::unique_ptr因此，如果后者足够，我们宁愿尽可能避免。

因此，总而言之，我会提出以下准则:

• 如果您需要自定义删除器，请返回 std::shared_ptr .
• 否则，如果您认为您的大多数客户都需要 std::shared_ptr无论如何，利用 std::make_shared 的优化潜力.
• 否则，返回 std::unique_ptr .

当然，您可以通过提供 两个 工厂函数来避免这个问题，其中一个返回 std::unique_ptr一个返回 std::shared_ptr所以每个客户都可以使用最适合其需求的东西。如果你经常需要这个，我想你可以通过一些巧妙的模板元编程来抽象大部分冗余。

关于c++ - 工厂函数的最佳智能指针返回类型是什么？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/28294620/