C++ Segmentation Fault: Passing a string to a node in a linked list

Question

I'm new to working with class templates and am simply trying to define a temporary node 'temp' in a class associated with the Linked List, which sets the string that the node stores to some temporary string that is created in the function TowerHanoi::set_Discs(size_t disc) via user input. When I call the function temp->set_data(tmp_str) i get a segmentation fault. I tried calling temp->set_data("hello"); on its own and i still get the error. I'm not sure what's going on here and i've tried researching into it but to no avail. I'm probably missing something obvious, but i'm just quite lost now. Let me know if you need more code. Thanks.

TowerHanoi.cpp:

#include "TowerHanoi.h"
#include <iostream>
#include <cstdlib>

using namespace std;
using oreilly_A2::node;

namespace oreilly_A2 {
    TowerHanoi::TowerHanoi() {
        for (int i=0;i<2;i++) {
            rod[i] = LStack<node<std::string> >();
        }
    }

    TowerHanoi::TowerHanoi(size_t numDiscs) {
        for (int i=0; i < 2; i++) {
            rod[i] = LStack<node<string> >();
        }
        discs = numDiscs;

    }

    void TowerHanoi::set_Discs(size_t disc) {
        node<string>* temp=NULL;

        while (disc != 0) {
            string tmp_str;
            for (size_t i=0; i<disc; i++) {
                tmp_str.append("x");

            }
            disc--;
        temp->set_data(tmp_str);
        rod[0].push(temp);
    }

    void TowerHanoi::print_Game() {

        for (size_t s=1; s<discs; s++) {
                cout << "   "; 
                    for (size_t o=1; o<discs-s;o++) {
                        cout << " ";
                    }
                //cout << tmp_node->data() << endl;
                    cout << "x" << endl;
            }
    }

}

node.h file:

#ifndef NODE_CAMERON_H
#define NODE_CAMERON_H
#include <string>

namespace oreilly_A2 {
    template <typename Item>
        class node {

        public:

        node(); //constructor for node

        node(const Item val, node* newNext); //constructor with parameters

        ~node(); //destructor

        void set_data(Item new_data); //set the word that this node contains

        void set_link(node* new_link); //set the 'next' node
        void set_previous(node* new_prev);

        Item data() const; //return this node's word

        const node* link() const; //return next

        const node* back() const;

        node* link(); //return next

        node* back(); 

        private:

        node* next; //the next node
        node* previous;
        Item word; //the word this node contains

        };
}
#include "Node.template"
#endif

node.template file:

    namespace oreilly_A2 {


    template <typename Item>
    node<Item>::node() {
        next=NULL;
        previous=NULL;
    }
    //Node.template
    template <typename Item>
    node<Item>::node(const Item val, node* newNext=NULL) {
        word = val;
        next = newNext;
    }

    template <typename Item>
    node<Item>::~node() {
        delete next;
        delete previous;
        delete word;
    }

    template <typename Item>
    void node<Item>::set_data(Item new_data){
            word = new_data;
    }


    template <typename Item>
    void node<Item>::set_link(node* new_link){
            next = new_link;

    }


    template <typename Item>
    void node<Item>::set_previous(node* new_back) {
            previous = new_back;
    }


    template <typename Item>
    Item node<Item>::data() const {  //return the word
            return word;
    }


    template <typename Item>
    const node<Item>* node<Item>::link() const { //return next node (const function)
            return next;
    }


    template <typename Item>
    const node<Item>* node<Item>::back() const { //return previous node (const)
            return previous;
    }


    template <typename Item>
    node<Item>* node<Item>::link() {
            return next; //return next node (non-const)
    }


    template <typename Item>
    node<Item>* node<Item>::back() { //return previous node (const)
            return previous;
    }

}

Answer 1

You have initialized temp as NULL. So when you are trying to do temp->set_data(tmp_str); you are actually trying to access NULL pointers.

All you need to do is initialize temp. I have correct the code below

 void TowerHanoi::set_Discs(size_t disc) {
            node<string>* temp=new node<string>();

            while (disc != 0) {
                string tmp_str;
                for (size_t i=0; i<disc; i++) {
                    tmp_str.append("x");

                }
                disc--;
            temp->set_data(tmp_str);
            rod[0].push(temp);
        }

To avoid memory leak you need to delete all the memory allocated after you are done.

Answer 2

Unless I have missed something the temp variable is NULL at the time of calling set_data. As any regular object you need to first initialized it.

node<string>* temp=new node<string>();

And then freeing it when appropriate to avoid memory leaks.

This is not the case with temp_str because the later is not a pointer, it's a value so it gets initialized automatically (and also freed automatically when it gets out of scope).