Multiple conversion errors while trying to load text file into a linked list

Question

I'm trying to load a text file with the values: 10 11 12 13 14 15 16 17 18 19 20 30 40 50 55 60 70 80 90 91 92 93 94 95 96 97 98 99 into a linked list, inserting each new value into the end of the list. The issue I'm having is that when I run the code, I get the error that I'm trying to run a string through a function that expects an int, which makes sense, but once I added stoi() into the mix to convert the values to int, I started getting crazy amounts of errors.

I've been working on this function for the past day or so, and none of my searching as yielded any results. I feel that I'm pretty close with this, but I'm probably missing something big here. Still pretty new to linked lists as a whole, we just learned about them in class last week.

#include <iostream>
#include <fstream>
#include <string>
#include "linkedlist.h" // Has the prototypes for each function
using namespace std;
// I didn't include a lot of functions since I don't think they're
// related to the error, but let me know if I should

Node* createNewNode(int data) {
    Node *ptr;
    Node *temp = new Node();
    temp -> data = data;
    temp -> next = NULL;
    ptr = temp;
    return ptr;
}

Node* createNewList() {
    Node *head = NULL;
    return head;
}

Node* load(string filename) {
    Node *head = createNewList();
    string num;
    ifstream myfile(filename.c_str());
    while(myfile >> num) { // looping through each number
        int num1 = stoi(num); // Converting string to int
        myfile << insertAtEnd(head, num1);      
    }
    return head;
}

void insertAtEnd(Node *list, int data) {
    Node *ptr = createNewNode(data);
    if (list == NULL) {
        list = ptr;
     }
     else { 
         Node *temp = list;
         while(temp -> next != NULL) {
             temp = temp -> next;
         }
         temp -> next = ptr;
    }
}

int main() {
    load("../resource/listdata.txt"); // name/location of the file
    //No errors from rest of code but I can post if necessary
}

There are far too many errors for me to just paste them here, but I took a screenshot of most of them here: https://i.stack.imgur.com/RWCbV.png .

Thank you in advance for any help you can give me!

Edits:

Node* load(string filename) {
    Node *head = createNewList();
    string num;
    ifstream myfile(filename.c_str());
    while(myfile >> num) { // looping through each number
        int num1 = stoi(num); // Converting string to int
        insertAtEnd(head, num1);      
    }
    myfile.close();
    return head;
}

There are no longer any compiling errors, though when the code runs it outputs: 0 0 NULL exit status -1

If I had to guess, I would assume my issue is now the while(myfile >> num) area, because I don't think the code is properly traversing the text file and using the numbers, though I'm not sure about that.

Edit 2:

Node *load (string filename) {
  Node *head;
  string num;
  ifstream myfile(filename.c_str());
  while(myfile >> num) {
    if(head) {
      int num1 = stoi(num);
      insertAtEnd(head, num1);
    } 
    else {
      head = createNewList();
      int num1 = stoi(num);
      head = createNewNode(num1);
    }
  }
  myfile.close();
  return head;
}

I'm hoping I followed the instructions correctly, though there's a good chance I haven't... I'm getting the same message as above, being 0 0 NULL exit status -1 but no errors still, which is good and bad, as I'd love to see what isn't working right now.

Answer 1

I'd create a class to keep track of head and all the functions concerning one list of nodes. I'll call it NodeList. I'd also add a pointer to the last node in the list for convenience and speed.

#include <iostream>
#include <fstream>
#include <string>

struct Node {
    Node* next;
    int data;
};

class NodeList {
    Node* head;
    Node* last;
public:
    // default constructor - an empty list
    NodeList() : head(nullptr), last(nullptr) {}

    // construction using a filename
    NodeList(const std::string& filename) : NodeList() {
        load(filename);
    }

    // deleted copy & move ctors and assignment operators for simplicity
    NodeList(const NodeList&) = delete;
    NodeList(NodeList&&) = delete;
    NodeList& operator=(const NodeList&) = delete;
    NodeList& operator=(NodeList&&) = delete;

    // destructor    
    ~NodeList() {
        clear();
    }

    // go through all Nodes and delete them
    void clear() {
        Node* curr = head;
        Node* next;
        while(curr) {
            next = curr->next;
            delete curr;
            curr = next;
        }
        head = nullptr;
        last = nullptr;
    }

    // load data from a file
    void load(const std::string& filename) {
        clear();
        append(filename);
    }

    // append data from a file
    void append(const std::string& filename) {
        std::ifstream is(filename);
        is >> *this;   // using operator>> further down
    }

    // find a node by value      
    Node* find(int data) const {
        Node* curr = head;
        while(curr && curr->data != data) curr = curr->next;
        return curr;
    }

    // add a node last in the list    
    Node* add(int data) {
        Node* nn = new Node{nullptr, data};
        if(last) { last->next = nn; last = nn; }
        else { head = last = nn; }
        return nn;
    }

    // delete a node by supplying a Node*    
    void del(Node* n) { // delete a certain node
        if(n==nullptr) return;

        if(head==n) {
            if(last==n) head = last = nullptr;
            else head = head->next;
        } else {
            Node* curr = head;
            do {
                if(curr->next==n) {
                    curr->next = n->next;
                    break;
                }
                curr = curr->next;
            } while(curr);
        }
        delete n;
    }

    void del(int data) { // delete a Node by value
        del(find(data));
    }

    // operator>> to populate the NodeList from an istream
    friend std::istream& operator>>(std::istream&, NodeList&);

    // operator<< to stream all values in the NodeList to an ostream
    friend std::ostream& operator<<(std::ostream&, const NodeList&);
};

// add nodes from stream
std::istream& operator>>(std::istream& is, NodeList& nl) {
    int tmp;
    // no need for std::stoi(), just stream into an int
    while(is >> tmp) nl.add(tmp);
    return is;
}

// output nodes to stream
std::ostream& operator<<(std::ostream& os, const NodeList& nl) {
    Node* curr = nl.head;
    while(curr) {
        os << curr->data << " ";
        curr = curr->next;
    }
    return os;
}

int main() {
    NodeList nl("listdata.txt");
    std::cout << nl << "\n";

    Node* p = nl.find(40);
    nl.del(p);  // delete the Node found above
    nl.del(10); // delete the first Node
    nl.del(99); // delete the last Node

    std::cout << nl << "\n";
}

Output (given the data in your post):

10 11 12 13 14 15 16 17 18 19 20 30 40 50 55 60 70 80 90 91 92 93 94 95 96 97 98 99
11 12 13 14 15 16 17 18 19 20 30 50 55 60 70 80 90 91 92 93 94 95 96 97 98

Answer 2

Your code shows good thought, so consider: the pointer head is supposed to point to the list's leading element, is it not? However, the only lines in your code that assign a value to head assign NULL (should be nullptr, incidentally).

That would be a problem.

Since altering the return type of insertAtEnd() is in your problem forbidden, we should call that function only when head already has a value, as

    if (head != nullptr) {
        // call insertAtEnd()
    }
    else {
        // do something to start the list and, incidentally,
        // to assign a value to head
    }

Actually, that's a beginner's way to write it. More fluent would be

    if (head) {
        // ...

which means the same thing.

Anyway, if you do it this way, you can and probably should make your insertAtEnd() function simpler because it will no longer need to handle the case of an empty list.

[...]

Now you have worked some more. Your output is still not what you expect, so how to debug it? When you have a problem but are unsure where in your code the bug is, how should you go about localizing it? That is, how should you figure out on which line the trouble arises? The program is too big to find the problem merely by staring at the code!

To debug, I would try something like this:

Node *load (string filename) {
  Node *head;
  string num;
  ifstream myfile(filename.c_str());
  cerr << "diagn 100\n";
  while(myfile >> num) {
    cerr << "diagn 150\n";
    if(head) {
      cerr << "diagn 200, head == " << head << "\n";
      int num1 = stoi(num);
      insertAtEnd(head, num1);
      cerr << "diagn 250\n";
    } 
    else {
      cerr << "diagn 300, head == " << head << "\n";
      head = createNewList();
      cerr << "diagn 325, head == " << head << "\n";
      int num1 = stoi(num);
      head = createNewNode(num1);
      cerr << "diagn 350, head == " << head << "\n";
    }
  }
  myfile.close();
  cerr << "diagn 900, head == " << head << "\n";
  return head;
}

Most likely, most of those outputs to the error stream will tell you nothing you did not already know, but one or more of the outputs might look wrong. When you find the one that looks wrong, if any, that will tell you where to focus your debugging attention.

(The "diagn," incidentally, stands for "diagnostic." I like "diagn" because no other English word I use has those letters, so it's easy to search for in program text.)

Regarding the error stream, std::cerr, this by default sends output to the same place std::cout does. However, it is possible to divert the one stream or the other, or both, sending the two to different places. Exactly how to divert depends on which system (Debian, Windows, OSX, etc.) you are using, but the diversion usually isn't hard to make.