虚拷贝

当传入对象时，函数有时会需要拷贝该对象并存入容器中，例如：

类定义：

class Quote {  
public:  
    Quote() = default;  
    Quote (const std::string& book, double sales_price) :  
        bookNo (book), price (sales_price) {}  
    void add_item (const Quote& sale);  
    std::string isbn() const { return bookNo; }  
    virtual double net_price (std::size_t n) const { return n* price; } //虚函数  
    virtual Quote* clone() const & {return new Quote(*this);}  
    virtual Quote* clone() && {return new Quote(std::move(*this));}  
    virtual ~Quote() = default; //动态绑定析构器  
private:  
    std::string bookNo;  
protected: //受保护类型  
    double price = 0.0;  
};  
  
class Disc_quote : public Quote { //抽象基类  
public:  
    Disc_quote() = default;  
    Disc_quote (const std::string& book, double price, std::size_t qty, double disc) :  
        Quote(book, price), quantity (qty), discount (disc) {}  
    double net_price (std::size_t) const = 0; //纯虚函数  
protected:  
        std::size_t quantity = 0;  
        double discount = 0.0;  
};  
  
class Bulk_quote final : public Disc_quote { //final限定词, 无法被继承  
public:  
    Bulk_quote() = default;  
    Bulk_quote(const std::string& book, double p, std::size_t qty, double disc) :  
        Disc_quote(book, p, qty, disc) {} //使用基类的构造器  
    double net_price(std::size_t cnt) const override;  
    virtual Bulk_quote* clone() const & {return new Bulk_quote(*this);}  
    virtual Bulk_quote* clone() && {return new Bulk_quote(std::move(*this));}  
};  

函数定义：

void add_item(const Quote& sale);   //拷贝给定的对象
void add_item(Quote&& sale);         //移动给定的对象

然而此时，add_item并不知道要分配的类型。当add_item进行内存分配时，它将拷贝sale参数，如

new Quote(sale)

然而这条表达式却可能是不正确的：new为我们请求的类型分配内存，因此它将分配一个Quote类型的对象并拷贝sale的Quote部分，然而sale实际指向的可能是Bulk_quote对象，此时add_item所拷贝的对象将失去一部分信息。

为了解决该问题，我们给Quote类添加了一个虚函数，该函数将申请一份当前对象的拷贝。

class Quote {
public:
    virtual Quote* clone() const & { return new Quote(*this); }
    virtual Quote* clone() && {return new Quote(std::move(*this)); }
};
class Bulk_quote final : public Disc_quote { 
public:
    virtual Bulk_quote* clone() const & { return new Bulk_quote(*this); }
    virtual Bulk_quote* clone() && {return new Bulk_quote(std::move(*this)); }
};

这样每个clone函数分配当前类型的一个新对象，其中，const左值引用成员将它自己拷贝给新分配的对象；右值引用成员则将自己移动到新数据中。

这样，我们可以使用clone写出新版本的add_item：

void add_item (const Quote& sale)  
    {  
        //items.insert(std::shared_ptr<Quote>(new Quote(sale))); //不会动态绑定  
        items.insert(std::shared_ptr<Quote>(sale.clone()));  
    }  
    void add_item (Quote&& sale)  
    {  
        //items.insert(std::shared_ptr<Quote>(new Quote(std::move(sale)))); //不会动态绑定  
        items.insert(std::shared_ptr<Quote>(std::move(sale).clone()));  
    }