复制构造函数const char *和Shared_ptr

Question

I have a class 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;
}

And I want to construct a copy Constructor for const char* and vector<shared_ptr<RegularExpression>>

Am I coding it correctly?

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]));
}

From What i understand I make a copy The Const char* and the vector of shared_ptr.

Thank you.

* So After the removal of const char * i'll have*

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;
}

and the copy constructor would be:

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]));
}

Destcrutor:

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

Answer 1

You have two options here. The one you probably want to use is the compiler-provided default copy constructor:

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!
};

In this context, the default copy constructor will do exactly what you (most likely) want: it will make a copy of the vreg vector, which means copying the shared_ptr elements of the vector — but not deep-copying the RegularExpression objects themselves! You (most likely) don't want to deep-copy those objects, because they're expensive to copy, and I would guess that it's just as appropriate to use the originals as to use copies. Normally you'd have to worry about memory management — whose job is it to free the originals now that two different Keywords objects claim to own them? — but in this case that's 100% solved, because the two Keywords objects will share ownership. That's what shared_ptr does .

This is a great example of what's known as The Rule of Zero . The familiar Rule of Three (or Five, or maybe Six) says that if you define one special member function, you should define them all. The Rule of Zero says that you shouldn't define any special member functions unless you're doing something really tricksy.

---

If you want to be tricksy here, and write a custom copy-constructor that does do deep copies of the RegularExpression elements,

...well, you should ask yourself why you're not just using std::vector<RegularExpression> vreg in the first place — then you could still use the Rule of Zero, because the default copy-constructor would make deep copies for you just as you apparently want.

But if you are unshakeable in your desire to do tricksy things, you'd do it like this:

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;
};

This implementation might still not do what you want; for example, if before the copy operation we have rhs.vreg[0] == rhs.vreg[1] , our constructor will quietly make two copies of that single RegularExpression object, and give us a new Keywords object *this such that this->vreg[0] != this->vreg[1] . This is merely a specific application of the general principle that it's hard to make a copy of an arbitrary pointer graph.

Did you notice how long this line of code is?

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

That's a red flag in normal C++11 code. In normal code, we don't have to write explicit types like RegularExpression ; the compiler can just infer the types. If I wanted to copy sptr , I could just write vreg.emplace_back(sptr) — no explicit types! But here I had to write out std::make_shared<RegularExpression>(...) . This is awkward... because I'm Doing It Wrong . It's not normal to take a shared_ptr , dereference it, copy-construct the thing pointed to by the shared_ptr , and then re-wrap that in a new shared_ptr with different ownership. That's a complicated and bizarre operation, and so it kind of makes sense that the syntax to do it in C++11 is complicated and bizarre.

I recommend not being tricksy, in this instance. :)