I know questions like this have been asked a ton, so I am super sorry if my question is indeed identical to those. I've tried to find the solution to my problem, but none of the given solutions have resolved the error.
I am trying to change a linked list class into a template. I am getting two of the same error ("Expected unqualified-id") when overloading operators.
Below are the code snippets that are getting the error:
template <typename DataType> LinkedList<DataType>& template <typename DataType>LinkedList<DataType>::operator=(const LinkedList &aCopy){ //assignment operator //error seen here
while(root!=nullptr){
Node* oneBefore= root;
root =root->next;
delete oneBefore;
}
Node *newNode= new Node;
Node *temp=aCopy.root;
root=newNode;
while(temp!=nullptr){
newNode->value=temp->value;
temp=temp->next;
if(temp!=nullptr){
newNode->next=new Node;
newNode=newNode->next;
}
else{newNode->next=nullptr;}
}
return *this;
}
template <typename DataType> typename LinkedList<DataType>::Iterator template<typename DataType> LinkedList<DataType>::Iterator::operator++(DataType){//error seen here
return *this;
}
and here is my full code, in case that is necessary:
template <typename DataType>
class LinkedList {
public:
struct Node {
//Node(Node *aNext=nullptr) : next(aNext) {}
DataType value; //this is the value you want to save
Node *next; //this points to the next node in the list (or nullptr)
};
//friend class Iterator; //do Ineed this even though it's a nested class
Node *root;
//---------------------------------------------------------------
//add a NESTED Iterator class...
class Iterator {
public:
Iterator();//default constructor
//Iterator() : current(nullptr) {}
Iterator(Node* aNode);
//Iterator(Node* aNode): current(aNode){};//constructor
Iterator& operator=(const LinkedList::Iterator& aCopy) noexcept; //added this DELETE DUMMY?
~Iterator(); //dtor
Iterator operator++();
Iterator operator++(DataType);
bool operator==(const Iterator &anIterator);
bool operator!=(const Iterator &anIterator);
DataType operator*();
operator Node*();
Node *current; //do I need to put LinkedList since it's a nested class?
//add all the necessary operators
protected:
};
//--------------------------------------------------------------
LinkedList(); //default constructor...
LinkedList(const LinkedList& aCopy); //copy ctor
~LinkedList(); //dtor
LinkedList& operator=(const LinkedList& aCopy); //assignment operator
void append(DataType value);
void prepend(DataType value);
void remove(DataType value);
int size(); //needs to return unsigned int????
Iterator begin();
Iterator end();
Iterator find(DataType aValue); //find
protected:
};
//class Iterator;
template <typename DataType> LinkedList<DataType>::LinkedList() {
root=nullptr;
}
template <typename DataType> LinkedList<DataType>::LinkedList(const LinkedList& aCopy){ //copy ctor
Node *temp=aCopy.root;
Node *newNode = new Node;
root=newNode;
while (temp != nullptr){
newNode-> value=temp->value;
temp=temp->next;
if (temp !=nullptr){
newNode->next=new Node;
newNode=newNode->next;
}
else{ newNode->next=nullptr;}
}
}
template <typename DataType> LinkedList<DataType>& template <typename DataType>LinkedList<DataType>::operator=(const LinkedList &aCopy){ //assignment operator
while(root!=nullptr){
Node* oneBefore= root;
root =root->next;
delete oneBefore;
}
Node *newNode= new Node;
Node *temp=aCopy.root;
root=newNode;
while(temp!=nullptr){
newNode->value=temp->value;
temp=temp->next;
if(temp!=nullptr){
newNode->next=new Node;
newNode=newNode->next;
}
else{newNode->next=nullptr;}
}
return *this;
}
LinkedList<DataType>::~LinkedList(){ //dtor
Node* oneBefore = nullptr;
while(root!=nullptr){
oneBefore=root;
root=root->next;
delete oneBefore;
}
}
LinkedList<DataType>::Iterator LinkedList::find(DataType aValue){
Node* temp=root;
Iterator myIterator = begin();
for(myIterator = this->begin(); myIterator != this->end(); myIterator++){
if(temp->value==aValue){
return temp;
}
temp=temp->next;
}
return nullptr;
}
void LinkedList<DataType>::append(DataType value){
Node* newNode=new Node;
newNode->value=value;
if(root!=nullptr){
Node* temp = root;
while (temp->next !=nullptr){
temp=temp->next;
}
newNode->next=nullptr;
temp->next=newNode;
}
if(root==nullptr){
newNode->next=nullptr;
root=newNode;
}
}
void LinkedList<DataType>::prepend(DataType value){
Node* newNode=new Node;
newNode->value=value;
if (root!=nullptr){
newNode->next=root;
root=newNode;
}
if(root==nullptr){
root=newNode;
newNode->next=nullptr;
}
}
void LinkedList<DataType>::remove(DataType value){
if(root!=nullptr){
Node *before=nullptr;
Node *temp=root;
if(temp->value==value){
root=temp->next;
}
else{
while(temp->value!=value &&temp->next != nullptr){
before=temp;
temp=temp->next;
}
if(temp->value==value){
before->next=temp->next;
}
}
delete temp;
}
}
int LinkedList<DataType>::size(){
Node* aNode = root;
int numElements=0;
while(aNode!=nullptr){
aNode=aNode->next;
numElements=numElements+1;
}
return numElements;
}
LinkedList<DataType>::Iterator LinkedList::begin(){
return LinkedList::Iterator(root);
}
LinkedList<DataType>::Iterator LinkedList::end(){
Node *aNode=root;
while(aNode!=nullptr){
aNode=aNode->next;
}
return LinkedList::Iterator(aNode);
}
LinkedList<DataType>::Iterator::Iterator() : current(nullptr) {}
LinkedList<DataType>::Iterator::Iterator(Node* aNode): current(aNode){
};
template <typename DataType> typename LinkedList<DataType>::Iterator LinkedList<DataType>::Iterator::operator++(){//I have no idea what the difference is supposed to be between this one and the one below
current=current->next;
return *this;
}
template <typename DataType> typename LinkedList<DataType>::Iterator template<typename DataType> LinkedList<DataType>::Iterator::operator++(DataType){//I have no idea what the difference is supposed to be between this one and the one below
current=current->next;
return *this;
}
template <typename DataType> LinkedList<DataType>::Iterator& LinkedList::Iterator::operator=(const LinkedList::Iterator& aCopy) noexcept{ //assignment operator
current=aCopy.current;
return *this;
}
template <typename DatatType> bool LinkedList<DataType>::Iterator::operator !=(const LinkedList::Iterator& aCopy){
return current != aCopy.current;
}
bool LinkedList<DataType>::Iterator::operator==(const LinkedList::Iterator& aCopy){
return current==aCopy.current;
}
DataType LinkedList<DataType>::Iterator::operator*(){
return current->value;
}
LinkedList<DataType>::Iterator::~Iterator(){}
