Quote

Quote.h

#ifndef QUOTE_H
#define QUOTE_H


#include <string>
#include <iostream>


class Quote
{
    friend bool operator !=(const Quote& lhs, const Quote& rhs);
public:
    Quote() { std::cout << "default constructing Quote\n"; }
    Quote(const std::string &b, double p) :
        bookNo(b), price(p) { std::cout << "Quote : constructor taking 2 parameters\n"; }


    //! copy constructor
    Quote(const Quote& q) : bookNo(q.bookNo), price(q.price)
    { std::cout << "Quote: copy constructing\n"; }


    //! move constructor
    Quote(Quote&& q) noexcept : bookNo(std::move(q.bookNo)), price(std::move(q.price))
    { std::cout << "Quote: move constructing\n"; }


    //! copy =
    Quote& operator =(const Quote& rhs)
    {
        if(*this != rhs)
        {
            bookNo = rhs.bookNo;
            price  = rhs.price;
        }
        std::cout << "Quote: copy =() \n";


        return *this;
    }


    //! move =
    Quote& operator =(Quote&& rhs)  noexcept
    {
        if(*this != rhs)
        {
            bookNo = std::move(rhs.bookNo);
            price  = std::move(rhs.price);
        }
        std::cout << "Quote: move =!!!!!!!!! \n";


        return *this;
    }


    //! clone self
    virtual Quote* clone() const & {return new Quote(*this);}
    virtual Quote* clone() &&      {return new Quote(std::move(*this));}


    std::string     isbn() const { return bookNo; }
    virtual double  net_price(std::size_t n) const { return n * price; }
    virtual void    debug() const;


    virtual ~Quote()
    {
        std::cout << "destructing Quote\n";
    }


private:
    std::string bookNo;


protected:
    double  price = 10.0;
};


bool inline
operator !=(const Quote& lhs, const Quote& rhs)
{
    return lhs.bookNo != rhs.bookNo
           &&
           lhs.price  != rhs.price;
}


//! non-member
double print_total(std::ostream &os,const Quote &item, size_t n);


#endif // QUOTE_H

Quote.cpp

#include "quote.h"


void Quote::debug() const
{
    std::cout //<< "data members of this class:\n"
              << "bookNo= " <<this->bookNo << " "
              << "price= " <<this->price<< " \n";
}


//! non-member
double print_total(std::ostream &os,const Quote &item, size_t n)
{
    // depending on the type of the object bound to the item parameter
    // calls either Quote::net_price or Bulk_quote::net_price
    double ret = item.net_price(n);
    os << "ISBN: " << item.isbn() // calls Quote::isbn
       << " # sold: " << n << " total due: " << ret << std::endl;
     return ret;
}

Disc_uote.h

#ifndef DISC_QUOTE_H
#define DISC_QUOTE_H

#include "quote.h"
class Disc_quote : public Quote
{
    friend bool operator !=(const Disc_quote& lhs, const Disc_quote& rhs);
public:
    Disc_quote() { std::cout << "default constructing Disc_quote\n"; }

    Disc_quote(const std::string& b, double p, std::size_t q, double d) :
        Quote(b, p), quantity(q), discount(d)
    {
        std::cout << "Disc_quote : constructor taking 4 parameters.\n";
    }

    //! copy constructor
    Disc_quote(const Disc_quote& dq) :
        Quote(dq), quantity(dq.quantity), discount(dq.discount)
    {
        std::cout << "Disc_quote : copy constructor.\n";
    }

    //! move constructor
    Disc_quote(Disc_quote&& dq) noexcept :
        Quote(std::move(dq)), quantity(std::move(dq.quantity)), discount(std::move(dq.discount))
    {
        std::cout << "Disc_quote : move constructor.\n";
    }

    //! copy =()
    Disc_quote& operator =(const Disc_quote& rhs)
    {
        Quote::operator =(rhs);
        this->quantity = rhs.quantity;
        this->discount = rhs.discount;

        std::cout << "Disc_quote : copy =()\n";

        return *this;
    }

    //! move =()
    Disc_quote& operator =(Disc_quote&& rhs) noexcept
    {
        if (*this != rhs)
        {
            Quote::operator =(std::move(rhs));
            this->quantity = std::move(rhs.quantity);
            this->discount = std::move(rhs.discount);
        }
        std::cout << "Disc_quote : move =()\n";

        return *this;
    }

    virtual double net_price(std::size_t n) const override = 0;

    ~Disc_quote()
    {
        std::cout << "destructing Dis_quote\n";
    }

protected:
    std::size_t quantity = 3;
    double      discount = 0.0;
};

bool inline
operator !=(const Disc_quote& lhs, const Disc_quote& rhs)
{
    return Quote(lhs) != Quote(rhs)
            &&
            lhs.quantity != rhs.quantity
            &&
            lhs.discount != rhs.discount;
}

#endif // DISC_QUOTE_H

Bulk_quote.h

#ifndef BULK_QUOTE_H
#define BULK_QUOTE_H
#include "disc_quote.h"


class Bulk_quote : public Disc_quote
{


public:
    Bulk_quote() {std::cout << "default constructing Bulk_quote\n"; }


    //! changed the below to the inherited constructor for ex15.27.
    //! rules:  1. only inherit from the direct base class.
    //!         2. default,copy and move constructors can not inherit.
    //!         3. any data members of its own are default initialized.
    //!         4. the rest details are in the section section 15.7.4.
    /*
    Bulk_quote(const std::string& b, double p, std::size_t q, double disc) :
        Disc_quote(b,p,q,disc) { std::cout << "Bulk_quote : constructor taking 4 parameters\n"; }
    */
    using Disc_quote::Disc_quote;


    //! copy constructor
    Bulk_quote(const Bulk_quote& bq) : Disc_quote(bq)
    { std::cout << "Bulk_quote : copy constructor\n"; }


    //! move constructor
    Bulk_quote(Bulk_quote&& bq) : Disc_quote(std::move(bq))
    {
        std::cout << "Bulk_quote : move constructor\n";
    }


    //! copy =()
    Bulk_quote& operator =(const Bulk_quote& rhs)
    {
        Disc_quote::operator =(rhs);
        std::cout << "Bulk_quote : copy =()\n";


        return *this;
    }




    //! move =()
    Bulk_quote& operator =(Bulk_quote&& rhs)
    {
        Disc_quote::operator =(std::move(rhs));
        std::cout << "Bulk_quote : move =()\n";


        return *this;
    }


    //! clone self
    virtual Bulk_quote* clone() const & {return new Bulk_quote(*this);}
    virtual Bulk_quote* clone() &&      {return new Bulk_quote(std::move(*this));}


    double net_price(std::size_t n) const override;
    void  debug() const override;


    ~Bulk_quote() override
    {
        std::cout << "destructing Bulk_quote\n";
    }
};


#endif // BULK_QUOTE_H

Bulk_quote.cpp

#include "bulk_quote.h"


double Bulk_quote::net_price(std::size_t n) const
{
    return n * price * ( n >= quantity ? 1 - discount : 1);
}


void Bulk_quote::debug() const
{
    std::cout //<< "data members of this class:\n"
              << "min_qty= " << quantity << " "
              << "discount= " << this->discount<< " \n";
}

Limit_quote.h

#ifndef LIMIT_QUOTE_H
#define LIMIT_QUOTE_H

#include "disc_quote.h"

class Limit_quote : public Disc_quote
{
public:
    Limit_quote() = default;
    Limit_quote(const std::string& b, double p, std::size_t max, double disc):
        Disc_quote(b,p,max,disc)  {   }

    double net_price(std::size_t n) const override
    { return n * price * (n < quantity ? 1 - discount : 1 ); }

    void debug() const override;
};

#endif // LIMIT_QUOTE_H

Limit_quote.cpp

#include "limit_quote.h"


void Limit_quote::debug() const
{
    std::cout //<< "data members of this class:\n"
              << "max_qty= " << this->quantity << " "
              << "discount= " << this->discount<< " \n";
}