Seg Fault When Debugging

[monarch_dodra]

Ok, I will try to answer your statements:

1) Well we just went over inheritance, so it is a new concept. I thought that since I am using static memory, I wouldn't need to deal with destructors in this case. Does the compiler not generate one?

It does, but you still have to declare it is a virtual. All you have to do is declare it, and provide an empty implementation (or you will get a link error).

Like this

.h
class yourclass
{
    virtual ~yourclass();
}

.cpp
yourclass::~yourclass(){}

The background work is still generated by the compiler, so don't go deleting stuff you otherwise wouldn't.

4) And, for the stack and queue, it might be the problem, but I am used to doing it like that. I've double checked everything with code from the book. Quite frankly, I wish I could use vectors, but, they don't allow that. And based off of the directions, it seems they want us to write our own stack and queue.

No offense, but that's just ****ing stupid. Knowing when and how to use somebody else's code, and just plain learning about standard components is some of the most important things you should be learning. Seems teachers are gung ho about you using arrays, when professional programmers avoid them like the plague.

I took the liberty of quoting your lab:

You will need to select a Stack and a Queue implementation to manage subsets of customers checking in. The check-in procedure rules should make it clear which type of implementation is
best for each. Notice, for example, that no limit is placed on how many non-elite customers there might be. On any given day, there may be ten or hundreds. Pick a reasonable implementation for
the class managing each set of customers, and justify your choices in your internal documentation.
You are encouraged to actually implement the Stack and Queue ADTs yourself, referring to those in the book only if and when you get stuck. Some variant of singly or doubly linked lists is an
obvious choice, but an array based implementation could also be used and might be preferable in some situations.

While it clearly says you are encourage to write them yourself, it also says you are to select the implementation, justify your choices and document it.

If your teacher is not a close minded "do it the way I said" person, I think the best thing you can do is select to use std queue/stack, explain you are using an internal array/vector or linked list implementation, and justify your choice. Both the internal container, but also the fact that those are standard and robust components, that have been thoroughly tested by millions of people for over a decade.

WORST case scenario, write your own stack queue to humor your teacher (if writing one is really part of the exercise), and then, after having written it, explain that std queue/stack is better and use that.

My 2 cents.