Question

This is the statement from the C++03 standard, §14.7.1p5:

If the overload resolution process can determine the correct function
to call without instantiating a class template definition, it is
unspecified whether that instantiation actually takes place. [Example:

template <class T> struct S {
       operator int();
};

void f(int);
void f(S<int>&);
void f(S<float>);

void g(S<int>& sr) {
        f(sr);     // instantiation of S<int> allowed but not required
                   // instantiation of S<float> allowed but not required
};

—end example]

I am unable to understand this point. Does it have undefined behavior?

I found another similar problem, which I also don’t understand. There it is explained that the correct behavior is undefined, but what does that mean?

here:
MSVC: Implicit Template Instantiation, though templated constructor not used

Answer 1

During overload resolution it is determined that the correct function to call when you write f(sr) is void f(S<int>&); without explicitly instantiating the definition of class template S, it is unspecified whether your class is actually instantiated.

Undefined behaviour and Unspecified behaviour are two completely different things.

instantiation of S< int > allowed but not required

For example:

template <class T =int> 
struct S 
{
  operator int();
};

is allowed but not required.