operator overloading

[hopesfall]

If I want to overload the == operator, and I do so by doing something like:

bool Stack<T>::operator==(const Stack<T>& rhs) const{

	for(int i = 0; i < MAX_STACK;i++){


		T topRHS,topLHS;
		
		rhs.getTop(topRHS);
		this->getTop(topLHS);
		//rhs.pop(topRHS); // why can't I do this?
		//this->pop(topLHS); // why can't I do this either?
		if(topLHS != topRHS){
			return false;
		}
		

	}

I want to use the == operator to check if my Stacks are the equal. Stacks are equal if every element in the stack are exactly the same. So, am I thinking about it correctly by using a for loop to check if each stack element on the left hand side of == is the same as the right hand side? Whenever I try to pop the compiler doesn't let me enter the function, it just sends me to the disassembly (i'm not sure what that is either).

[webJose]

Strange that it allows you to compile. My guess was going to be: Your program cannot compile because most likely pop() is non-const while operator== is const. But you say it shows assembly code, which leads me to think that you were in fact able to compile.

[roberts]

nvm

[viliml]

you cant pop it becouse it is a const! use a non-const temporary stack.
like this:

bool Stack<T>::operator==(const Stack<T>& rhs) const
{
	Stack<T> tempa=*this, tempb=rhs
        for(int i = 0; i < MAX_STACK;i++)
       {
		T topRHS, topLHS;
		tempb.getTop(topRHS);
		tempa.getTop(topLHS);
		tempb.pop(topRHS);
		tempa.pop(topLHS);
		if(topLHS != topRHS) return false;
                }
        return true;
	}

[vlad from moscow]

It is principally incorrect approach. You cannot compare a stack by popping its elements. Because after this operation you get an ampty or modified stack that does not correspond to the original. It is supposed that after comparision compared objects will not be changed and wiil keep their original state.
If your stack is an adapter of another container then usually such an operation with stacks is realized by comparing base containers which have already such operation defined.

[viliml]

vlad from moscow: I use temporary variables, so the original stack remains the same!

[vlad from moscow]

Yes, I see. But this approach is uneffective. As I said it is better to compare containers which are bases for stacks that is without pop and top operations. For example if a stack is build with an array it is better to compare directly arrays.

[JLBorges]

> I want to use the == operator to check if my Stacks are the equal.
> Stacks are equal if every element in the stack are exactly the same.

The overload of std::operator==() for std::stack<> does precisely that.

#include <stack>
#include <iostream>

int main()
{
    std::stack<int> a ;
    std::stack<int> b ;
    for( int i=0 ; i<5 ; ++i ) { a.push(i) ; b.push(i) ; } // 4,3,2,1,0
    std::cout << std::boolalpha << (a==b) << '\n' ; // true
    b.pop() ; b.pop() ; b.push( a.top() ) ; b.push( a.top() ) ; // 4,4,2,1,0
    std::cout << std::boolalpha << (a==b) << '\n' ; // false
}