Why doesn't the compiler perform a type conversion?

Question

Consider the following code.

#include 
#include 

struct SimpleStruct
{
    operator std::string () { return value; }
    std::         


        

Answer 1

operator< for std::string is a function template. The overloads are:

  template<class charT, class traits, class Allocator>
    bool operator< (const basic_string<charT,traits,Allocator>& lhs,
            const basic_string<charT,traits,Allocator>& rhs);
  template<class charT, class traits, class Allocator>
    bool operator< (const basic_string<charT,traits,Allocator>& lhs,
            const charT* rhs);
  template<class charT, class traits, class Allocator>
    bool operator< (const charT* lhs,
            const basic_string<charT,traits,Allocator>& rhs);

Your call doesn't match any of the available overloads, so they are all removed from a list of candidates. Since no function template was picked as a candidate for resolving the call, there is nothing to convert SimpleStruct to.

template <class T>
class String
{
};

template <class T>
bool operator< (const String<T>&, const String<T>&) { return true; }


//if a suitable non-template function is available, it can be picked
//bool operator< (const String<char>&, const String<char>&) { return true; }

struct SimpleStruct
{
   operator String<char> () { return value; }
   String<char> value;
};

int main()
{
    String<char> s;
    SimpleStruct ss;
    s < ss; //the call doesn't match the function template, leaving only the commented-out candidate
}