1

我有一堂课Keywords：

#include <boost/lambda/lambda.hpp>
class Keywords
{
    public:
        ///Constructor
        Keywords(const char*,vector<shared_ptr<RegularExpression>>,vector<string>);
        Keywords(const Keywords& other);
    private:
        const char * xmlFile;
        vector<shared_ptr<RegularExpression>> vreg;
        vector<string> sw;
}

我想为const char*和构建一个副本构造函数vector<shared_ptr<RegularExpression>>

我编码正确吗？

Keywords::Keywords(const Keywords& other):xmlFile(new char[100]),vreg(other.vreg.size())
{
    strcpy((char*)xmlFile, (char*)other.xmlFile);
    for (std::size_t i = 0; i < other.vreg.size(); ++i)
        vreg[i] = shared_ptr<RegularExpression>(new RegularExpression(*other.vreg[i]));
}

据我了解，我复制了 Const char* 和 shared_ptr 的向量。

谢谢你。

*所以在删除 const char * 我会有*

class Keywords
{
    public:
        ///Constructor
        Keywords(string,vector<shared_ptr<RegularExpression>>,vector<string>);
        Keywords(const Keywords& other);
    private:
        string xmlFile;
        vector<shared_ptr<RegularExpression>> vreg;
        vector<string> sw;
}

并且复制构造函数将是：

Keywords::Keywords(const Keywords& other):vreg(other.vreg.size()),sw(other.sw)
{
    for (std::size_t i = 0; i < other.vreg.size(); ++i)
        vreg[i] = shared_ptr<RegularExpression>(new RegularExpression(*other.vreg[i]));
}

解说员：

Keywords::~Keywords()
{
    sw.clear();
    vreg.erase(vreg.begin());
}
4

1 回答 1

0

您在这里有两个选择。您可能想要使用的是编译器提供的默认复制构造函数：

class Keywords {
    std::string xmlFile;
    std::vector<std::shared_ptr<RegularExpression>> vreg;
    std::vector<std::string> sw;

public:
    Keywords(const char *xmlFile,
             const std::vector<std::shared_ptr<RegularExpression>>& vreg,
             const std::vector<std::string>& sw)
      : xmlFile(xmlFile), vreg(vreg), sw(sw) {}

    // Look, Ma, no special member functions!
};

在这种情况下，默认的复制构造函数将完全按照您（很可能）想要的方式执行：它将复制vreg向量，这意味着复制向量的shared_ptr元素——但不会深度复制正则表达式对象本身！您（很可能）不想深度复制这些对象，因为它们的复制成本很高，而且我猜想使用原件和使用副本一样合适。通常你不得不担心内存管理——既然两个不同Keywords的对象声称拥有它们，那么释放原件是谁的工作呢？- 但在这种情况下，这是 100% 解决的，因为这两个Keywords对象将共享所有权。就是shared_ptr 这样。

这是所谓的零规则的一个很好的例子。熟悉的三规则（或五，或者可能是六）说，如果你定义一个特殊的成员函数，你应该定义它们。零规则说你不应该定义任何特殊的成员函数，除非你正在做一些非常棘手的事情。

如果你想在这里变得狡猾，并编写一个自定义复制构造函数来对RegularExpression元素进行深度复制，

...嗯，你应该问自己为什么你不只是std::vector<RegularExpression> vreg首先使用 - 然后你仍然可以使用零规则，因为默认的复制构造函数会按照你显然想要的方式为你制作深层副本。

但如果你对做棘手的事情的愿望坚定不移，你会这样做：

class Keywords {
    std::string xmlFile;
    std::vector<std::shared_ptr<RegularExpression>> vreg;
    std::vector<std::string> sw;

public:
    Keywords(const char *xmlFile,
             const std::vector<std::shared_ptr<RegularExpression>>& vreg,
             const std::vector<std::string>& sw)
      : xmlFile(xmlFile), vreg(vreg), sw(sw) {}

    Keywords(const Keywords& rhs)
      : xmlFile(rhs.xmlFile), sw(rhs.sw)
    {
        vreg.reserve(rhs.vreg.size());
        for (auto&& sptr : rhs.vreg) {
            vreg.emplace_back(std::make_shared<RegularExpression>(*sptr));
        }
    }

    // Don't forget to implement copy-assignment too!
    // I'm just going to delete it here to keep anyone from using it.
    //
    Keywords& operator= (const Keywords&) = delete;
};

此实现可能仍然无法满足您的要求；例如，如果在我们进行复制操作之前rhs.vreg[0] == rhs.vreg[1]，我们的构造函数将悄悄地复制该单个RegularExpression对象的两个副本，并为我们提供一个新Keywords对象*this，例如this->vreg[0] != this->vreg[1]. 这只是一般原则的具体应用，即很难复制任意指针图。

你注意到这行代码有多长了吗？

    vreg.emplace_back(std::make_shared<RegularExpression>(*sptr));

这是普通 C++11 代码中的一个危险信号。在普通代码中，我们不必编写像RegularExpression;这样的显式类型。编译器只能推断类型。如果我想复制sptr，我可以写vreg.emplace_back(sptr)——没有明确的类型！但在这里我不得不写出来std::make_shared<RegularExpression>(...)。这很尴尬......因为我做错了。取 a ，取消引用它，复制构造指向的东西，然后用不同的所有权重新包装它是不正常的。这是一个复杂而奇怪的操作，因此在 C++11 中执行此操作的语法复杂而奇怪是有道理的。shared_ptrshared_ptrshared_ptr

在这种情况下，我建议不要狡猾。:)

于 2014-12-30T23:49:33.470 回答