Operator overloading "operator T * ()" produces a comparison operator?

class Test
{
public:
    operator Test * () { return NULL; };
};

int main()
{
    Test test;
    if (test == NULL)
        printf("Wtf happened here?\n");

    return 0;
}

How is it that this code compiles? How did Test get a comparison operator? Is 开发者_运维百科there some implicit casting going around? What does that overloaded operator even mean (and do)?

The overloaded operator adds a conversion from Test to Test *. Since there is no comparision operator defined that takes Test and NULL as arguments, any conversion operators that exists are tried. operator Test * returns a type which is comparable with NULL, so it is used.

Yes, you've added an implicit conversion to T*, so the compiler will use it to compare against NULL.

A few other things to note:

NULL is shorthand for 0, so this means that comparison against 0 will be allowed. (This isn't true for other integer values, however. 0 is special.)

Your type also can be implicitly used in boolean contexts. That is, this is legal:

Test test;
if (test)
{
    // ...
}

C++0x allows you to specify an explicit keyword for conversion operators to disallow this sort of thing.

Implicit conversion to pointer types is often pretty dubious. In addition to the pitfalls of the conversion happening in unexpected cases, it can allow dangerous situations if the object owns the returned pointer. For example, consider a string class that allowed implicit conversion to const char*:

BadString ReturnAString();

int main()
{
    const char* s = ReturnAString();
    // Uh-oh.  s is now pointing to freed memory.

    // ...
}

+1 for Baffe's response. If you're looking to somehow expose some instance of a wrapped object via * then perhaps you should overload -> instead of overloading *.

class Bar
{
public:
   void Baz() { ... }
}

class Foo
{
private:
    Bar* _bar;
public:
    Bar* operator -> () { return _bar; }
}

// call like this:
Foo f;
f->Baz();

Just a thought.

You have not defined your own comparison thus he compiler has done one for you. you have however tried to overload the dereference operator... which I can't see why.

you want to define your operator== function

read this