Question: I am working with stacks and need to check to see if two are the same. I have overloaded the 

```
bool operator== 

```

function in my code, and now I need to put the logic in the code. I will check a few things to see if the two stacks are the same: the length, the data type, and the content of each element. Length and content are no problem, its the data type that is giving me issues.

I tried to make a function:

```
...
    Type getType();
};

template <class Type>
Type getType(){ returnType;}

```

But this did not work.

I also thought about:

```
bool operator== (stack<Type> &lhs, stack<Type> &rhs){

    return (lsh.Type == rhs.Type);
//additional conditions will be checked.
}

```

How to I check if they are the same type?

**EDIT:** What if I just checked the data type of the top elements of the two stacks? would that be sufficient?

Answer: 
If you implement `operator==` like this:

```
template<typename Type>
bool operator== (const stack<Type> &lhs, const stack<Type> &rhs){
    // compare and return.
}

```

You already know that both stacks will contain elements of the same type. There's no need to check for that.

If you want to allow stacks using different template arguments to be compared, you could do something like this:

```
template<typename Type1, typename Type2>
bool operator== (const stack<Type1> &lhs, const stack<Type2> &rhs){
    // compare
}

```

Then compare the elements using `operator==` and you'll be done. Of course, if there's no `operator==` for parameters of type `Type1` and `Type2`, then the compiler will issue an error.

*Edit*: Since you want a nice error message, you could do this(using C++11):

```
#include <type_traits>

template<typename Type1, typename Type2>
bool operator== (const stack<Type1> &lhs, const stack<Type2> &rhs){
    // This is a compile time assert!
    static_assert(std::is_same<Type1, Type2>::value, "Types are not equal!");
    // compare
}

```

I'd avoid this anyway. It's simpler to let the compiler issue its own error, rather than doing this check yourself.
If you implement the stack data structure using *templates* (e.g. `template <typename T> class Stack...`), then you just need to overload `operator==` and check sizes and do an item-wise comparison:

```
template <typename T>
bool operator==(const Stack<T> & lhs, const Stack<T> & rhs)
{
  if (lhs.Size() != rhs.Size())
    return false;

  // Compare item by item
  ...
}

```

The type will be implicitly checked by the C++ compiler type system (if you have a `Stack<int>` and try to compare against a `Stack<string>` you will have a compiler error).