some& operator=(const some& that)
{
    if((void*)this==(void*)&that)
        return *this;
    ...
}

some& operator=(const some& that)
{
    if(this==&that)
        return *this;
    ...
}

BOP>

struct some{};
bool operator==(const some*, const some*)
{
    return false;
}
int main()
{
    return 0;
}

 error C2803: 'operator ==' must have at least one formal parameter of class type

"ComeauTest.c", line 2: error: nonmember operator requires a parameter with class or
          enum type
  bool operator==(const some*, const some*)
       ^

    if(*this==that)
    {}

Note that a template assignment operator doesn't replace the default assignment operator. For assignments of stacks of the same type, the default assignment operator is still called.

template <typename T> 
 template <typename T2> 
Stack<T>& Stack<T>::operator= (Stack<T2> const& op2) 
{ 
    if ((void*)this == (void*)&op2) {    // assignment to itself? 
        return *this; 
    } 

    Stack<T2> tmp(op2);             // create a copy of the assigned stack 

    elems.clear();                  // remove existing elements 
    while (!tmp.empty()) {          // copy all elements 
        elems.push_front(tmp.top()); 
        tmp.pop(); 
    } 
    return *this; 
}

d> template <typename T>
d>  template <typename T2>
d> Stack<T>& Stack<T>::operator= (Stack<T2> const& op2)
d> {
d>     if ((void*)this == (void*)&op2) {    // assignment to itself?
d>         return *this;
d>     }
d> ...
d>     return *this;
d> }
d>

Stack<int> a1;
Stack<int> a2;
a1.operator=<int>(a2);

D>template <typename T> 
D> template <typename T2> 
D>Stack<T>& Stack<T>::operator= (Stack<T2> const& op2) 
D>{ 
D>    if ((void*)this == (void*)&op2) {    // assignment to itself? 
D>        return *this; 
D>    } 

D>    Stack<T2> tmp(op2);             // create a copy of the assigned stack 

D>    elems.clear();                  // remove existing elements 
D>    while (!tmp.empty()) {          // copy all elements 
D>        elems.push_front(tmp.top()); 
D>        tmp.pop(); 
D>    } 
D>    return *this; 
D>} 
D>

#include <stdio.h>
struct A { int a; };
struct B { int b; };

struct C : public A, public B
{
    void test(B * p)
    {
        printf ("this %s p\n", 
            (this == p) ? "==" : "!=" );
        printf("(void*)this %s (void*)p", 
            ((void*)this == (void*)p) ? "==" : "!=");
    };
};

void main()
{
    C c;
    c.test(&c);
};

WH>>some& operator=(const some& that)
WH>>{
WH>>    if(this==&that)
WH>>        return *this;
WH>>    ...
WH>>}
WH>>

namespace boost {

// Do not make addressof() inline. Breaks MSVC 7. (Peter Dimov)

// VC7 strips const from nested classes unless we add indirection here
# if BOOST_WORKAROUND(BOOST_MSVC, == 1300)
template <typename T> typename add_pointer<T>::type
# else
template <typename T> T*
# endif
addressof(T& v)
{
  return reinterpret_cast<T*>(
       &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
}

}

D>template <typename T> 
D> template <typename T2> 
D>Stack<T>& Stack<T>::operator= (Stack<T2> const& op2) 
D>{ 
D>    if ((void*)this == (void*)&op2) {    // assignment to itself? 
D>        return *this; 
D>    } 

D>    Stack<T2> tmp(op2);             // create a copy of the assigned stack 

D>    elems.clear();                  // remove existing elements 
D>    while (!tmp.empty()) {          // copy all elements 
D>        elems.push_front(tmp.top()); 
D>        tmp.pop(); 
D>    } 
D>    return *this; 
D>} 
D>

template <typename T> 
 template <typename T2> 
Stack<T>& Stack<T>::operator= (Stack<T2> const& op2) 
{ 
    Stack<T> newthis;
    Stack<T2> tmp(op2);             // create a copy of the assigned stack 

    while (!tmp.empty()) {          // copy all elements 
        newthis.push_front(tmp.top()); 
        tmp.pop(); 
    } 

    newthis.swap( *this );
    return *this; 
}

D>template <typename T> 
D> template <typename T2> 
D>Stack<T>& Stack<T>::operator= (Stack<T2> const& op2) 
D>{ 
D>    if ((void*)this == (void*)&op2) {    // assignment to itself? 
D>        return *this; 
D>    } 

D>    Stack<T2> tmp(op2);             // create a copy of the assigned stack 

D>    elems.clear();                  // remove existing elements 
D>    while (!tmp.empty()) {          // copy all elements 
D>        elems.push_front(tmp.top()); 
D>        tmp.pop(); 
D>    } 
D>    return *this; 
D>} 
D>

Page 47 (stack5assign.hpp),
Page 49 (stack6assign.hpp),
Page 54 (stack8.hpp):
In the templified assignment operator of Stack the test of assignment to itself is useless because the template member assignment operator is never used for assignment between objects of the same type, and if the address of rhs == this, then the object must reasonably be of the same type.

int main()
{
   A<int>a;
   a.operator=<>(a);

   return 0;
}