15.30 Basket类实现

最新推荐文章于 2023-07-26 18:29:40 发布

原创最新推荐文章于 2023-07-26 18:29:40 发布 · 437 阅读

0 ·

CC 4.0 BY-SA版权

C++ Primer 专栏收录该内容

57 篇文章

订阅专栏

本文介绍了一种基于不同图书数量和特定条件的复杂折扣策略实现，包括Basket类用于管理购物车中的图书，Quote类作为基本的报价类，以及Bulk_quote、Limited_quote等派生类提供不同的折扣计算方式。

Basket class:
Basket.h

#pragma once
#include <iostream>
#include <memory>
#include <set>
#include "Quote.h"

class Basket {
public:
    void add_item(const Quote &);
    void add_item(Quote &&);
    double total_receipt(std::ostream &os) const;
private:
    static bool compare(const std::shared_ptr<Quote> &lhs, const std::shared_ptr<Quote> &rhs) {
        return lhs->isbn() < rhs->isbn();
    }
    std::multiset<std::shared_ptr<Quote>, decltype(compare)*> item{compare};
};

Basket.cpp

#include "Basket.h"
#include <algorithm>

void Basket::add_item(const Quote &q) {
    std::shared_ptr<Quote> ptr(q.clone());
    item.insert(ptr);
}

void Basket::add_item(Quote &&q) {
    std::shared_ptr<Quote> ptr(std::move(q).clone());
    item.insert(ptr);
}

double Basket::total_receipt(std::ostream &os) const {
    double sum = 0;
    for (auto itr = item.cbegin();
         itr != item.cend();
         itr = item.upper_bound(*itr)) {
             sum += print_total(os, **itr, item.count(*itr));
         }
    os << "Total sale: " << sum << std::endl;
    return sum;
}

Quote class:
Quote.h

#pragma once
#include <iostream>
#include <string>

class Quote {
public:
    Quote() = default;
    Quote(const std::string &bookNo, double book_price);
    Quote(const Quote &);
    Quote &operator=(const Quote &);
    Quote(Quote &&);
    Quote &operator=(Quote &&);
    std::string isbn() const;
    virtual double net_price(size_t n) const;
    virtual void debug() const;
    virtual ~Quote();

    virtual Quote *clone() const &;
    virtual Quote *clone() &&;

    friend double print_total(std::ostream &out, Quote &item, size_t n);

protected:
    std::string bookNo;
    double price;
};

Quote.cpp

#pragma once
#include <iostream>
#include <string>

class Quote {
public:
    Quote() = default;
    Quote(const std::string &bookNo, double book_price);
    Quote(const Quote &);
    Quote &operator=(const Quote &);
    Quote(Quote &&);
    Quote &operator=(Quote &&);
    std::string isbn() const;
    virtual double net_price(size_t n) const;
    virtual void debug() const;
    virtual ~Quote();

    virtual Quote *clone() const &;
    virtual Quote *clone() &&;

    friend double print_total(std::ostream &out, Quote &item, size_t n);

protected:
    std::string bookNo;
    double price;
};

Bulk_quote class:
Bulk_quote.h

#pragma once
#include "Disc_quote.h"

class Bulk_quote : public Disc_quote {
public:
    Bulk_quote() = default;
    Bulk_quote(const std::string &bookNo, double book_price, size_t min_qty, double discount);
    Bulk_quote(const Bulk_quote &);
    Bulk_quote &operator=(const Bulk_quote &);
    Bulk_quote(Bulk_quote &&);
    Bulk_quote &operator=(Bulk_quote &&);
    virtual double net_price(size_t n) const;
    virtual void debug() const;
    virtual ~Bulk_quote();
    virtual Bulk_quote *clone() const &;
    virtual Bulk_quote *clone() &&;
};

Bulk_quote.cpp

#include "Bulk_quote.h"

Bulk_quote::Bulk_quote(const std::string &bookNo, double book_price, size_t min_qty, double discount)
    : Disc_quote(bookNo, book_price, min_qty, discount) {}

Bulk_quote::Bulk_quote(const Bulk_quote &b)
    : Disc_quote(b) {
    std::cout << "Bulk_quote copy constructor" << std::endl;
}

Bulk_quote &Bulk_quote::operator=(const Bulk_quote &rhs) {
    std::cout << "Bulk_quote copy assignment" << std::endl;
    bookNo = rhs.bookNo;
    price = rhs.price;
    min_qty = rhs.min_qty;
    discount = rhs.discount;
    return *this;
}

Bulk_quote::Bulk_quote(Bulk_quote &&b)
    : Disc_quote(b) {
    std::cout << "Bulk_quote move constructor" << std::endl;
}

Bulk_quote &Bulk_quote::operator=(Bulk_quote &&rhs) {
    std::cout << "Bulk_quote move assignment" << std::endl;
    bookNo = std::move(rhs.bookNo);
    price = std::move(rhs.price);
    min_qty = std::move(rhs.min_qty);
    discount = std::move(rhs.discount);
    return *this;
}

double Bulk_quote::net_price(size_t n) const {
    if (n >= min_qty) {
        return n * (1 - discount) * price;
    } else {
        return n * price;
    }
}

void Bulk_quote::debug() const {
    std::cout << "===This is a Bulk_quote object call" << std::endl;
    Disc_quote::debug();
    std::cout << "The min number of books is: " 
              << min_qty << " and the discount is: " 
              << discount << std::endl;
}

Bulk_quote::~Bulk_quote() {}

Bulk_quote *Bulk_quote::clone() const & {
    return new Bulk_quote(*this);
}

Bulk_quote *Bulk_quote::clone() && {
    return new Bulk_quote(std::move(*this));
}

Disc_quote class:
Disc_quote.h

#pragma once
#include "Quote.h"

class Disc_quote : public Quote {
public:
    Disc_quote() = default;
    Disc_quote(const std::string &bookNo, double price, size_t qty, double discount);
    Disc_quote(const Disc_quote &);
    Disc_quote &operator=(const Disc_quote &);
    Disc_quote(Disc_quote &&);
    Disc_quote &operator=(Disc_quote &&);
    virtual double net_price(size_t n) const = 0;
    virtual void debug() const;
    ~Disc_quote();
protected:
    size_t min_qty = 0;
    double discount = 0.0;
};

Disc_quote.cpp

#include "Disc_quote.h"

Disc_quote::Disc_quote(const std::string &bookNo, double price, size_t qty, double discount)
    : Quote(bookNo, price), min_qty(qty), discount(discount) {}

Disc_quote::Disc_quote(const Disc_quote &d)
    : Quote(d), min_qty(d.min_qty), discount(d.discount) {
    std::cout << "Disc_quote copy constructor" << std::endl;
}

Disc_quote &Disc_quote::operator=(const Disc_quote &rhs) {
    std::cout << "Disc_quote copy assignment" << std::endl;
    bookNo = rhs.bookNo;
    price = rhs.price;
    min_qty = rhs.min_qty;
    discount = rhs.discount;
    return *this;
}

Disc_quote::Disc_quote(Disc_quote &&d)
    : Quote(d), min_qty(std::move(d.min_qty)), discount(std::move(d.discount)) {
    std::cout << "Disc_quote move constructor" << std::endl;
}

Disc_quote &Disc_quote::operator=(Disc_quote &&rhs) {
    std::cout << "Disc_quote move assignment" << std::endl;
    bookNo = std::move(rhs.bookNo);
    price = std::move(rhs.price);
    min_qty = std::move(rhs.min_qty);
    discount = std::move(rhs.discount);
    return *this;
}

void Disc_quote::debug() const {
    std::cout << "This is Disc_quote objec call" << std::endl;
    Quote::debug();
    std::cout << "The min number of books is: " << min_qty << " and the discount is: " << discount << std::endl;
}

Disc_quote::~Disc_quote() {}

Limited_quote class:
Limited_quote.h

#pragma once
#include "Disc_quote.h"

class Limited_quote : public Disc_quote {
public:
    Limited_quote() = default;
    Limited_quote(const std::string &bookNo, double book_price, size_t min_qty, double discount, size_t max_qty);
    Limited_quote(const Limited_quote &);
    Limited_quote &operator=(const Limited_quote &);
    Limited_quote(Limited_quote &&);
    Limited_quote &operator=(Limited_quote &&);
    virtual double net_price(size_t n) const;
    virtual void debug() const;
    ~Limited_quote();
    virtual Limited_quote *clone() const &;
    virtual Limited_quote *clone() &&;
private:
    size_t max_qty;
};

Limited_quote.cpp

#include "Limited_quote.h"

Limited_quote::Limited_quote(const std::string &bookNo, double book_price, size_t min_qty, double discount, size_t max_qty)
    : Disc_quote(bookNo, book_price, min_qty, discount), max_qty(max_qty) {}

Limited_quote::Limited_quote(const Limited_quote &l)
    : Disc_quote(l), max_qty(l.max_qty) {
    std::cout << "Limited_quote copy constructor" << std::endl;
}

Limited_quote &Limited_quote::operator=(const Limited_quote &rhs) {
    std::cout << "Limited_quote copy assignment" << std::endl;
    bookNo = rhs.bookNo;
    price = rhs.price;
    min_qty = rhs.min_qty;
    discount = rhs.discount;
    max_qty = rhs.max_qty;
    return *this;
}

Limited_quote::Limited_quote(Limited_quote &&l)
    : Disc_quote(l), max_qty(std::move(l.max_qty)) {
    std::cout << "Limited_quote move constructor" << std::endl;
}

Limited_quote &Limited_quote::operator=(Limited_quote &&rhs) {
    std::cout << "Limited_quote move assignment" << std::endl;
    bookNo = std::move(rhs.bookNo);
    price = std::move(rhs.price);
    min_qty = std::move(rhs.min_qty);
    discount = std::move(rhs.discount);
    max_qty = std::move(rhs.max_qty);
    return *this;
}

double Limited_quote::net_price(size_t n) const {
    if (min_qty < n && n < max_qty) {
        return n * (1 - discount) * price;
    } else {
        return n * price;
    }
}

void Limited_quote::debug() const {
    std::cout << "===This is a Limited_quote object call" << std::endl;
    Disc_quote::debug();
    std::cout << "The max number of books is: " << max_qty << std::endl;
}

Limited_quote::~Limited_quote() {}

Limited_quote *Limited_quote::clone() const & {
    return new Limited_quote(*this);
}

Limited_quote *Limited_quote::clone() && {
    return new Limited_quote(std::move(*this));
}