Re: user-defined conversion combined with argument-dependent lookup

From:

"Alf P. Steinbach" <alfps@start.no>

Newsgroups:

comp.lang.c++

Date:

Fri, 30 Nov 2007 23:56:20 +0100

Message-ID:

<13l158r1bu42c9@corp.supernews.com>

* Belebele:

Suppose that I have a class that has a user-defined conversion to
std::string, and I would like to compare objects of that class to
"strings" (e.g. literals, std::strings):

class InUpperCase {
public:
    operator std::string() const;
};

...
InUpperCase()=="a string"; // This does not compile.
    // fine, bool operator==(InUpperCase const& , char const* );
    // is not declared anywhere.

InUpperCase()==std::string("a string"); // This one does not compile
either,
    // even though, there is a definition for an operator== in std
    // that takes two std::strings.

I expected the second expression to compile fine due to ADL combined
with the user-defined conversion. Any idea why?

Consider

     #include <string>

     struct Foo
     {
         operator std::string() const { return ""; }
     };

     template< typename Ch >
     void bar( std::basic_string<Ch> const& ) {}

     int main()
     {
         bar( Foo() );
     }

Template matching doesn't succeed.

When you're the one writing the bar() function you can always support
future classes like Foo e.g. by making the argument a
ConvertibleTo<std::string>, with each Foo class publicly derived from
ConvertibleTo<std::string>.

Cheers, & hth.,

- Alf

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?