Wie verkette ich zwei einfach verkettete Listen über Operatorüberladung?

Question

Dies ist meine Header-Datei

#ifndef LINKEDLIST_H 
#define LINKEDLIST_H 

#include <iostream> 
#include <string> 
using namespace std; 

class Node 
{ 
    friend class LinkedList; 

public: 
    Node(string& name, int num) :studentName(name), RUID(num) 
    { 
     this->next = NULL; 
    } 

private: 
    string studentName; 
    int RUID; 
    Node *next; 
}; 

class LinkedList 
{ 
public: 
    LinkedList(); 
    ~LinkedList(); 

    LinkedList& operator+(LinkedList &i); 
    //LinkedList operator=(); 

    void makeLists(int n); 
    void addNode(LinkedList &i); 
    void removeNode(); 
    void printList(); 
    void printElement(); 
    void sortList(); 

private: 
    Node *head; 
    Node *tail; 
    int size; 
}; 

#endif 

... und dies ist mein Operator + Funktion

LinkedList& LinkedList::operator+(LinkedList &i) 
{ 
    LinkedList tohma; 
    tohma = *this; 
    tohma += i; 
    return tohma; 
} 

Ich bin mit dem Operator + = eine Fehlermeldung bekommen, aber ich bin so ratlos wie Ich sollte es anders machen. Ich habe das Gefühl, dass ich in der Nähe bin, aber vielleicht mache ich einen logischen Fehler?

Jedwedes Hilfe würde

Answer 1

Typischerweise erkennt, operator+ für eine LinkedList ist wie folgt strukturiert:

LinkedList operator+(const LinkedList& _list) { 

    // ptr to list to return, initialised with this 
    LinkedList* ret_list = this; 

    // temporary node ptr for iterating through _list 
    Node* temp = _list.head; 

    // loop through contents of _list 
    while (temp != nullptr) { 
     // insert data from _list to ret_list 
     ret_list->insert(temp->data); 
     // ^= this will need to be changed for your specific list fields and insert methods 
     temp = temp->next; 
    } 

    return &ret_list; 

} 

Was die operator+=, die ähnliche Logik hat:

LinkedList& operator+=(const LinkedList& _list) { 

    Node* temp = _list.head; 

    while (temp != nullptr) { 
     insert(temp->data); 
     temp = temp->next; 
    }   

    return *this; 

} 

Ich habe vielleicht etwas falsch gemacht, da es ziemlich spät ist, aber es sollte genau sein.

Answer 2

LinkedList LinkedList::operator+(const LinkedList &i) 
{ 
    LinkedList* tohma = this; 
    Node* temp = i.head; 

    tohma->tail->next = temp; 

    return *tohma; 
} 

Da ich schon der Tailing-Knoten für meine erste Liste gespeichert hatte, konnte ich bedienen, dass es mit der zweiten Liste verketten