Dynamic Array & Class Inheritance - c++

Question

I am doing a homework assignment for my summer OO class and we need to write two classes. One is called Sale and the other is called Register. I've written my Sale class; here's the .h file:
enum ItemType {BOOK, DVD, SOFTWARE, CREDIT};
class Sale
{
public:
Sale(); // default constructor,
// sets numerical member data to 0
void MakeSale(ItemType x, double amt);
ItemType Item(); // Returns the type of item in the sale
double Price(); // Returns the price of the sale
double Tax(); // Returns the amount of tax on the sale
double Total(); // Returns the total price of the sale
void Display(); // outputs sale info
private:
double price; // price of item or amount of credit
double tax; // amount of sales tax
double total; // final price once tax is added in.
ItemType item; // transaction type
};
For the Register class we need to include a dynamic array of Sale objects in our member data.
So my two questions are:
Do I need to inherit from my Sale class into my Register class (and if so, how)?
Can I have a generic example of a dynamic array?
Edit: We cannot use vectors.

Answer 1

No inheritance is required. A generic example:
std::vector<Sale> sales;
Gotta love templates.

Answer 2

No, inheritance would not be appropriate in this case. You would want to keep track of the number of sales and the size of the array as fields in the Register class. The class definition would include this
class Register{
private:
int numSales;
int arraySize;
Sale* sales;
public:
Register();
~Register();
void MakeSale(Sale);
};
Register::Register(){
numSales = 0;
arraySize = 5;
sales = new Sale[arraySize];
}
void Register::MakeSale(Sale s){
if(numSales == arraySize){
arraySize += 5;
Sale * tempArray = new Sale[arraySize];
memcpy(tempArray, sales, numSales * sizeof(Sale));
delete [] sales;
sales = tempArray;
}
sales[numSales] = s;
++numSales;
}
Register::~Register()
{
delete [] sales;
}
This doesn't include bounds checking or whatever other stuff you need to do when you make a sale, but hopefully this should help.

Answer 3

If you CANNOT use vectors, then you can use a std::list. You really should use standard containers as much as possible - chances are that any home-rolled solution will be inferior. The standard library is extensively optimized and tested - do you really feel the need to make the same investment when you have better things to be doing than reinventing the wheel?
std::list should not allocate more space than necessary. However, it has some serious limitations. The fact that a vector and other forms of dynamic array is contiguous gives large performance advantages.
Not being able to use vectors seems like a very arbitrary limitation. The fact that they allocate more space than necessary is a feature, not a bug. It allows the container to amortize the expensive copy and/or move operations involved in a reallocation. An intelligent vector implementation should check for low memory situations and handle those gracefully. If it doesn't, you should submit patches to your standard library implementation or move to a new one. But imposing arbitrary constraints with no explanation, e.g.:
There should never be more than 5 unused slots in this array (i.e. the
number of allocated spaces may be at most 5 larger than the number of
slots that are actually filled with real data).
is bad practice. And where did the number FIVE come from? It's not even a power of two! If you want to hack around this limitation using std::vector::reserve, that's probably your best bet. But all that book-keeping should not need to be done.
And, agreed with everyone else: inheritance is not what you want here.