Segmentation fault pushing strings in a stack - c++

Question

I'm still stuck on an issue that keeps occurring with a class assignment which works with templates and Linked-List-based Stacks. I am constantly getting segmentation faults and I cannot for the life of me see why.
main() asks for a value to determine how many disks to play the game with, which calls set_Discs(), which appends "x"s to a string object tmp_str to represent disks for the game. This string object is then pushed onto the stack rod[0] (the first rod) and then it loops back. I call a cout to print the top stack object each time through the loop as a test and it works, so I can successfully store the string objects. However upon calling the next function print_Game() it does the first iteration of the for-loop (printing the first line) and goes bust again.
int main() {
TowerHanoi game;
size_t disc_in;
//How many discs to be used
cout << "Welcome to Towers of Hanoi!"<< "Please enter how many discs you want to play with: " << endl;
cin >> disc_in;
game.set_Discs(disc_in);
game.print_Game();
//Ask for source and target rod
return EXIT_SUCCESS;
}
The set_Discs() function:
void TowerHanoi::set_Discs(size_t disc) {
//cout << "test: " << rod[0].top() << endl;
discs = disc;
while (disc > 0) {
string tmp_str;
for (size_t i=0; i<disc; i++) {
tmp_str.append("x");
}
disc--;
rod[0].push(tmp_str);
cout << "test: " << rod[0].top() << endl;
}
}
The function print_Game() is a recent logical endeavour so forgive me if it's bad and under-worked. The loop adds spacing, then prints the top string object, then calls pop() (which calls removeFromHead() in LinkedList.template) to make the next string object the top object for the next time through the loop, and so on. Refer to addToHead().
void TowerHanoi::print_Game() {
size_t spaces = discs;
string topLen = rod[0].top();
string xString;
cout << "top length: " << topLen.length() << endl;
for (size_t a=0; a<discs;a++) {
LStack<string> rodCopy = rod[0];
cout << "==="; //3 spaces
for (size_t i=0; i<spaces-topLen.length();i++) { //add to xString
xString.append("=");
}
cout << "===" << xString << rod[0].top() << xString << endl;
rod[0].pop();
spaces--;
}
}
Some relevant code from LStack.template (this is the Stack):
//push
template <typename Obj>
void LStack<Obj>::push(Obj& head_in) {
list->addToHead(head_in);
used++;
}
//pop
template <typename Obj>
Obj LStack<Obj>::pop() {
used--;
return list->removeFromHead();
}
//top
template <typename Obj>
const Obj& LStack<Obj>::top() {
return list->list_getHead();
}
Relevant code from LinkedList.template:
template <typename Item>
void LinkedList<Item>::addToHead(Item& entry) {
node<Item>* temp = head;
head = new node<Item>();
head->set_data(entry);
head->set_link(temp);
}
template <typename Item>
const Item& LinkedList<Item>::removeFromHead() {
node<Item>* head_copy = head; //create a copy of head
head->set_data(head_copy->link()); //set head's data to the previous object
return head_copy->data(); //return head's original data
}
Node.template:
template <typename Object>
void node<Object>::set_data(const Object& new_data){
word = new_data;
}
template <typename Object>
void node<Object>::set_link(node<Object>* new_link){
next= new_link;
}
template <typename Object>
void node<Object>::set_previous(node<Object>* new_prev) {
previous = new_prev;
}
template <typename Object>
const Object& node<Object>::data() const{ //return the word
return word;
}
template <typename Object>
const Object& node<Object>::link() const { //return next node (const function)
return next->data();
}
template <typename Object>
const Object& node<Object>::back() const { //return previous node (const)
return previous->data();
}

Answer 1

Identifying the data being pushed on stack:
void TowerHanoi::set_Discs(size_t disc)
{
while (disc > 0)
{
string tmp_str; <-- note here, tmp_str is stack variable
rod[0].push(tmp_str);
}
}
Now, let us see the LStack::push() function:
//push
template <typename Obj>
void LStack<Obj>::push(Obj& head_in) <-- note here, input to push() is pass by reference
{
list->addToHead(head_in);
used++;
}
Once, set_Discs() function call is done, the reference to the used stack variables inside this function is not valid.
This may be related to the problem of program crashing / terminating abruptly when print_Game() function is called where LStack stored data is being used.