I did not divide all in one .cpp by modules, I hope this is not the problem. Added scopes to every variable in functions, in an attempt to fix the problem.
For the most part, the reason itself is interesting why the compiler cannot work, as I understand it, dynamic compilation.

The actual compiler error code:

/ tmp / ccJCiuqE.o: In function `Quote :: ~ Quote () ':
1501.cpp :(. Text._ZN5QuoteD2Ev [_ZN5QuoteD5Ev] + 0xd): undefined reference to `vtable for Quote '
/tmp/ccJCiuqE.o:(.rodata._ZTV16Count_disk_quote [_ZTV16Count_disk_quote ]+0x28): undefined reference to `Quote :: debug () '
/tmp/ccJCiuqE.o:(.rodata._ZTV10Disk_quote [_ZTV10Disk_quote ]+0x28): undefined reference to `Quote :: debug () '
/tmp/ccJCiuqE.o:(.rodata._ZTI10Disk_quote [_ZTI10Disk_quote ]+0x10): undefined reference to `typeinfo for Quote '
collect2: error: ld returned 1 exit status

class Quote

#include & lt; iostream & gt;
  #include & lt; string & gt;
  using namespace std;
  class Quote {
    public:
    Quote () = default;
    Quote (const string & amp; book, double sales_price):
        bookNo (book), price (sales_price) {}
    string isbn () const {return bookNo;}
    virtual double net_price (size_t) const;
    virtual ~ Quote () = default;
    virtual void debug ();
    private:
    std :: string bookNo;
    protected:
    double price = 0.0;
  };

class Disk_quote

class Disk_quote: public Quote {
public:
  Disk_quote () = default;
  Disk_quote (const string & amp; book, double price, size_t qty, double disk):
Quote (book, price), quantity (qty), discount (disk) {}
  double net_price (size_t) const = 0;
protected:
  size_t quantity = 0;
  double discount = 0.0 ;;
};

class Bulk_quote

class Bulk_quote: public Disk_quote {
public:
  Bulk_quote () = default;
  Bulk_quote (const string & amp; book, double price, size_t qty, double disk):
        Disk_quote (book, price, qty, disk) {}
  void debug () final;
  double net_price (size_t) const;
};
double Bulk_quote :: net_price (size_t cnt) const {
    if (cnt & gt; = Disk_quote :: quantity)
      return cnt * (1-Disk_quote :: discount) * Quote :: price;
    else
      return cnt * Quote :: price;
}
void Bulk_quote :: debug () {
  if (quantity & gt; 0 || Bulk_quote :: discount & gt; 0) {
    cout & lt; & lt; Quote :: isbn () & lt; & lt; Quote :: price & lt; & lt; Disk_quote :: quantity & lt; & lt; Disk_quote :: discount & lt; & lt; endl;
  }
  else
    cout & lt; & lt; Quote :: isbn () & lt; & lt; Quote :: price & lt; & lt; endl;
}

cass Count_disk_quote

class Count_disk_quote: public Disk_quote {
public:
  Count_disk_quote () = default;
  Count_disk_quote (const string & amp; book, double price, size_t qty, double disk, size_t max):
        Disk_quote (book, price, qty, disk), max_quantity (max) {}
  double net_price (size_t) const;
private:
  size_t max_quantity = quantity;
};
double Count_disk_quote :: net_price (size_t cnt) const {
  if (cnt & lt; = Count_disk_quote :: max_quantity) {
    if (cnt & gt; = Disk_quote :: quantity)
      return cnt * (1-Disk_quote :: discount) * Quote :: price;
    else
      return cnt * Quote :: price;
  }
  else
return (Count_disk_quote :: max_quantity * (1-Disk_quote :: discount) * Quote :: price)
         + ((cnt - Count_disk_quote :: max_quantity) * Quote :: price);
}
double print_total (ostream & amp; os, const Quote & amp; item, size_t n) {
  double ret = item.net_price (n);
  os & lt; & lt; "ISBN:" & lt; & lt; item.isbn () & lt; & lt; "# sold:" & lt; & lt; n & lt; & lt; "total due:" & lt; & lt; ret & lt; & lt; endl;
  return ret;
}
int main () {
  return 0;
}

Answer 1, authority 100%

As usual, you just don’t have the definitions (bodies) of the two functions –

virtual double net_price (size_t) const;
  virtual void debug ();

in the Quote class.

Since the ABSTRACT class Disk_quote inherits from it, I conclude that you simply forgot to add = 0 to the declarations of these virtual functions and make the class Quote also abstract:

virtual double net_price (size_t) const = 0;
  virtual void debug () = 0;

True, you still have debug () abstract in Count_disk_quote , so you might need to define Quote :: debug () and make it purely virtual Quote :: net_price () . See for yourself how you have it.

Answer 2, authority 50%

The compiler does not see the function definition

virtual void debug ();

declared in class Quote

It looks like the same problem is taking place with another virtual function

virtual double net_price (size_t) const;