Printable View
Hi, ive been trying to get this operator= overload to work for a few days now..
this is my recent attempt... Think you could help me out. Thanx
Code:SLList<Type> &operator= (const SLList<Type> &list)
{
if(this == &list)
return *this;
SLList<Type> temp = list;
return temp;
}
Well you are trying to return a reference to a local variable which is a big no no.
operator = should be setting the values of *this object to the values of list.
So you'd have to look at the internals of SSList and do something like:
Code:a = list.a;
b = list.b;
c = list.c;
// etc
Thanx, I understand that as far as basics, im not quite sure as to how, to apply this method, when working the "list" object, since its a dynamic SinglyLinked List;
i think i said that right.
or perhaps my error lies somewhere else. maybe this can help.
Code:template <typename Type>
class SLLIter;
template <typename Type>
class SLList
{
private:
struct Node
{
Type element;
Node *next;
};
Node *head;
public:
//SLList(void);
friend class SLLIter;
// SLList : constructor.
SLList ()
{
head = NULL;
}
// operator = : assignment operator.
// NOTE : invalidates all iterators to this list.
SLList<Type> &operator= (const SLList<Type> &list)
{
//if(this == &list)
// return *this;
if(this == &list)
return *this;
else
{
*this = list;
return *this;
}
}
// addHead : append a new item to the front of the list.
void addHead (const Type &v)
{
Node *temp = new Node;
temp->element = v;
temp->next = head;
head = temp;
}
// clear : clear out the list
void clear ()
{
while(head)
{
Node *temp = head->next;
delete head;
head = temp;
}
}
// insert : place a new item directly before the index
// passed in. Do nothing on a bad iterator.
// Note : iterator will point at the newly inserted
// item after the function call.
void insert (SLLIter<Type> &index, const Type &v)
{
Node *temp = new Node;
temp->element = v;
temp->next = head;
head = temp;
}
// remove : remove (and delete) the item at the index
// passed in. Do nothing on a bad iterator.
// Note : iterator will point at the item after the one
// removed after the function call, or NULL (bad) if
// the tail is the one removed.
void remove (SLLIter<Type> &index)
{
Node *cur, *prev;
// walk through all list items.
for (prev = NULL, cur = head; cur; prev = cur, cur = cur->next)
{
if (cur->element == index.curr->element)
{
// remove 'cur' from the list.
if (prev == NULL)
// if we are removing the 1st node.
head = head->next;
else
// good when cur is not the head.
prev->next = cur->next;
delete cur;
return;
}
}
/*
Node *temp = head;
if(temp->element == index.curr->element)
{
if(index.prev == NULL)
{
index.prev = head->next;
index.curr = index.prev->next;
delete head;
head = index.prev;
return;
}
if(index.curr->next == NULL)
{
index.prev->next = NULL;
delete index.curr;
return;
}
temp = index.curr;
index.prev->next = index.curr->next;
index.curr = index.curr->next;
delete temp;
return;
}
*/
/*
Node *temp, *pNode;
temp = head;
pNode = NULL;
if(temp->element == index.curr->element)
{
if(pNode == NULL)
{
pNode= head->next;
delete head;
head = pNode;
return;
}
else if (pNode !=NULL)
{
pNode->next = temp->next;
delete temp;
return;
}
}
else if (temp->element != index.curr->element)
{
pNode = temp;
temp = temp->next;
}
*/
}
// How to declare a node pointer of a structure declared
// within another template class
// ‘typename’ syntax needed b/c A* B can be interpreted as
// multiply instead of a pointer declaration w/ templates
typename SLList<Type>::Node* location;
virtual ~SLList(void)
{
clear();
}
};
template <typename Type>
class SLLIter
{
public:
friend class SLList<Type>;
typename SLList<Type>::Node *curr;
//typename SLList<Type>::Node *prev;
// SLLIter Public Interface
SLList<Type> * list;
// SLLIter : constructor.
SLLIter (SLList<Type> &listToIterate){ list = &listToIterate;}
// ~SLLIter : destructor.
virtual ~SLLIter (){}
// begin : move the iterator to the front of the list
void begin (){curr = list->head;}
// end : only return true when iterator is beyond the last
// item
bool end ()
{
if(curr == NULL)
return true;
else
return false;
}
// operator++ : prefix (only) ++ operator
SLLIter<Type> &operator++ ()
{
//if(curr)
//{
curr = curr->next;
return *this;
//}
}
// current : extract the element at the current location.
Type ¤t () {return curr->element;}
};
An = operator is used as such:
result = rhs;
when passed into an operator overload function, rhs is the passed in paramter, result is *this. A return value that you might want to use is bool to return success or failure.
Here's an example (assuming the function is inline):
However, technically the above code won't work because the passed in parameter is passed as const, which you can change. When I do this, I have an iterator to loop through the rhs list so it can stay const.Code:bool operator= (const SLList<Type> &rhs)
{
clear() //like the constructor, get rid of all current nodes
if (rhs.isEmpty()) return false;
rhs.start(); //start at first node
do
{
insert(rhs.getData());
} while (rhs.next());
}
return true;
}
[edit]
I whole-heartedly decided not to read all that code. So you should just replace function names or use iterators if you have one.
[/edit]
You are defining the assignment operator in terms of itself. Do as Thantos suggested and copy the internals of the List. In your case, you must copy the linked list, so set this->head equal to a copy of list.head, then set this->head->next equal to a copy of list.head->next, and so on. You would probably want to use a loop of some sort to traverse the list and copy its data into the this object.Code:if(this == &list)
return *this;
else
{
*this = list;
return *this;
}
Thanx for all the help i got it squared away had to re-write the whole thing...
{thats why you don't code when half-asleep} :D :P
wow i didn't realize the code was so lengthy
operator= should never fail. Only exception to this is if you had dynamically allocated memory then if allocating fails then you should throw an exception. The operator= should return the same type of as the object (basically return *this).Quote:
A return value that you might want to use is bool to return success or failure.
If you don't then you wouldn't be able to use = like you could with built in types (ie)
Code:MyClass x = y = v = z = w;
This is the new and improved operator= overload i came up with. works great. thanx again for the help..
Code:SLList<Type> &operator= (const SLList<Type> &list)
{
if (this == &list)
return *this;
this->clear();
Node * temp = list.head;
SLLIter<Type> ait (*this);
ait.begin();
while(temp)
{
insert(ait,temp->element);
++ait;
temp = temp->next;
}
return *this;
}