Effective C++ 笔记 —— Item 12: Copy all parts of an object.

本文主要是介绍Effective C++ 笔记 —— Item 12: Copy all parts of an object.，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Consider:

class Date { }; // for dates in time
class Customer {
public:
    //... // as before
private:
    std::string name;
    Date lastTransaction;
};

class PriorityCustomer : public Customer { // a derived class
public:
    //...
    PriorityCustomer(const PriorityCustomer& rhs);
    PriorityCustomer& operator=(const PriorityCustomer& rhs);
    //...
private:
    int priority;
};

PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs)
    : priority(rhs.priority)
{
    logCall("PriorityCustomer copy constructor");
}
PriorityCustomer&
PriorityCustomer::operator=(const PriorityCustomer& rhs)
{
    logCall("PriorityCustomer copy assignment operator");
    priority = rhs.priority;
    return *this;
}

PriorityCustomer’s copy constructor specifies no arguments to be passed to its base class constructor (i.e., it makes no mention of Customer on its member initialization list), so the Customer part of the PriorityCustomer object will be initialized by the Customer constructor taking no arguments — by the default constructor.

Any time you take it upon yourself to write copying functions for a derived class, you must take care to also copy the base class parts. Those parts are typically private, of course, so you can’t access them directly. Instead, derived class copying functions must invoke their corresponding base class functions:

PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs)
    : Customer(rhs), // invoke base class copy ctor
    priority(rhs.priority)
{
    logCall("PriorityCustomer copy constructor");
}
PriorityCustomer&
PriorityCustomer::operator=(const PriorityCustomer& rhs)
{
    logCall("PriorityCustomer copy assignment operator");
    Customer::operator=(rhs); // assign base class parts
    priority = rhs.priority;
    return *this;
}

It makes no sense to have the copy assignment operator call the copy constructor, because you’d be trying to construct an object that already exists. 

Having the copy constructor call the copy assignment operator — is equally nonsensical. A constructor initializes new objects, but an assignment operator applies only to objects that have already been initialized. Performing an assignment on an object under construction would mean doing something to a not-yet-initialized object that makes sense only for an initialized object.

If you find that your copy constructor and copy assignment operator have similar code bodies, eliminate the duplication by creating a third member function that both call. Such a function is typically private and is often named init. This strategy is a safe, proven way to eliminate code duplication in copy constructors and copy assignment operators.

Things to Remember:

• Copying functions should be sure to copy all of an object’s data members and all of its base class parts.
• Don’t try to implement one of the copying functions in terms of the other. Instead, put common functionality in a third function that both call.

这篇关于Effective C++ 笔记 —— Item 12: Copy all parts of an object.的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！