assignment overloading

[zandrailia]

I'm trying to write a program that uses the stack ADT with a linked list implementation. I can't seem to overload the assignment operator. I keep getting an error that says

"StackClass::Pop cannot convert 'this' pointer from 'const StackClass' to 'StackClass&'"

All of my other methods are working correctly, but let me know if you need more

void StackClass::operator =(const StackClass& orig)
{
	Clear();

	StackClass temp;
        
	while(!orig.IsEmpty())
	{
		temp.Push(orig.Retrieve());

		orig.Pop();
	}//end while


	while(!temp.IsEmpty())
	{
		Push(temp.Retrieve());

		temp.Pop();
	}//end while

}

[PanGalactic]

You are calling a non-const method on a const reference. That's not permitted.

[helios]

The assignment doesn't look right. When one uses assignment, one doesn't expect the right-hand operator to be modified, yet here it's being emptied.
What you should do is access the members yourself, instead of relying on the methods.

[zandrailia]

I changed the parameter and it does what I want it to now

void StackClass::operator =(StackClass orig)
{
	Clear();

	StackClass temp;
        
	while(!orig.IsEmpty())
	{
		temp.Push(orig.Retrieve());

		orig.Pop();
	}//end while


	while(!temp.IsEmpty())
	{
		Push(temp.Retrieve());

		temp.Pop();
	}//end while

}

[PanGalactic]

Well, orig is now a copy of the parameter object, so you don't need temp in there.

Surely there is a better way to do the assignment than this.

[helios]

How is the copy constructor implemented? The assignment should look practically the same.
In fact, lately I've been implementing the two like this:

class A{
	//members
public:
	A::A(const A &b){
		//initializations
		(*this)=b;
	}
	A &operator=(const A &b){
		//delete all dynamically allocated members
		//perform assignments
	}
};

[zandrailia]

This is the entire .cpp and .h files, this is the one that give problems because I'm trying to modify a const in the operator=, I know I can't modify orig, but I really can't think of what to do. I either end up with the previous error message, or I get one about infinite recursion.

helios - when I originally learned c++, I was told that *this returns a shallow copy so my copy constructor isn't going to do what I want it to.

#include<cstdlib>

typedef int KeyType;

struct ItemType		
{					
	KeyType key;		
};


struct node;


class StackClass

{
  public:
			
	StackClass(); 
	
	StackClass(const StackClass& orig);

	~StackClass();

	bool IsEmpty() const; 

	bool IsFull() const;	

	void Push(/*in*/ItemType newItem);

	void Pop();	

	ItemType Retrieve() const;
   
	void Clear();

	virtual void operator =(const StackClass& orig);

 private:

   node* stack; 


protected:
   node* Allocate();



};  // end StackClass


StackClass::StackClass()
{	
	stack = NULL;

}  // end default constructor

StackClass::StackClass(const StackClass& orig)
{
	stack = NULL;
	operator=(orig);
}

StackClass::~StackClass()
{
	Clear();
}
bool StackClass::IsEmpty() const
{
  
	return(stack == NULL);

}//end IsEmpty
bool StackClass::IsFull() const
{

	return false;

} // end IsFull

ItemType StackClass::Retrieve() const
{

	return stack->data;

}  // end Retrieve

void StackClass::Push(/*in*/ItemType newItem)//newItem is the item to be inserted
								
{				
	node* temp;
	
	if(!IsFull())
	{
		temp = Allocate();
		temp->data = newItem;
		temp->next = stack;
		stack = temp;
	}


}// end Push

void StackClass::Pop()
{
	node* temp;

	if(!IsEmpty())
	{
		temp = stack;
		stack = stack->next;
		delete temp;
	}//end if


}  // end Pop

void StackClass::Clear() 
{

	while(!IsEmpty())
		Pop();

}//end Clear
void StackClass::operator =(const StackClass& orig)
{
	Clear();

	StackClass temp;

	while(!orig.IsEmpty())
	{
		temp.Push(orig.Retrieve());

		orig.Pop();
	}//end while


	while(!temp.IsEmpty())
	{
		Push(temp.Retrieve());

		temp.Pop();
	}//end while

}//end operator=

node* StackClass::Allocate()
{
	
	node* temp = new node;

	if(temp == NULL)
	{
		exit(999);
	}
	
	else
	{
		temp->next = NULL;
	
		return temp;
	}

}//end Allocate 

[PanGalactic]

You probably want your copy constructor to walk the nodes manually and create new nodes in the new object that are copies from the original.

Then -- create a swap() method:

void StackClass::swap(StackClass& other)
{
    std::swap(stack, other.stack);
}

And then implement your operator=() in terms of the second method outlined here:

http://en.wikipedia.org/wiki/Assignment_operator_in_C%2B%2B

It's called the no-fail swap method and makes creating assignment operators a breeze. But there may still be complexity in the copy constructor.

[helios]

when I originally learned c++, I was told that *this returns a shallow copy so my copy constructor isn't going to do what I want it to.

No. this is a pointer to the object that calls the member. Therefore, *this is the object itself. Doing *this=b is no different from doing *pointer=object. In my example, line 6 is calling A::operator=(), so it's equivalent to what you did on line 61.
If that's how your copy constructor was implemented when you posted

void StackClass::operator =(StackClass orig)
{
	Clear();

	StackClass temp;
        
	while(!orig.IsEmpty())
	{
		temp.Push(orig.Retrieve());

		orig.Pop();
	}//end while


	while(!temp.IsEmpty())
	{
		Push(temp.Retrieve());

		temp.Pop();
	}//end while

}

then that would have caused infinite recursion.

[jsmith]

+1 for PanGalactic's solution.