Understanding C++03 Standard Grammar for Operator Overloading

Question

The standard C++03 grammar for overloading an operator is as follows:

operator-function-id:
operator operator
operator operator < template-argument-list?>

The first one is the ordinary operator overloading syntax that we normally use, e.g.

Myclass operator + (Myclass s) {...}

But what does the second alternative mean? In particular, under what situation do we use the template-argument-list? After a quick look at C++11, I found that the second form was removed from the standard. What was the original intention of it?

EDIT: after testing with VC++2010, below is one way of using the above syntax, although it does not make much sense to me:

class K {
public:
    int a;
    template <int B>
    int operator + (int b) {
        return a+b+B;
    }
};


int _tmain(int argc, _TCHAR* argv[])
{
    K k;
    k.a=1;
    int s;
    s=k.operator+<115>(2);
    printf("%d\n",s);
    return 0;

}

output:118

Answer 1

The grammar rule which allows specialization of operator function templates still exists in C++11, it's just in a different place.

[temp.names]/1 (C++03):

A template specialization (14.7) can be referred to by a template-id:

template-id:

template-name < template-argument-listopt>

template-name:

identifier

template-argument-list:

template-argument
template-argument-list , template-argument

template-argument:

assignment-expression
type-id
id-expression

[temp.names]/1 (C++11):

A template specialization (14.7) can be referred to by a template-id:

simple-template-id:

template-name < template-argument-listopt>

template-id:

simple-template-id
operator-function-id < template-argument-listopt> <- HERE
literal-operator-id < template-argument-listopt>

template-name:

identifer

template-argument-list:

template-argument ...opt
template-argument-list , template-argument ...opt

template-argument:

constant-expression
type-id
id-expression

This was likely done because the grammatical rule operator-function-id is referred to in contexts where that template argument list would not make sense, so they moved the rule to somewhere more reasonable </conjecture>.

---

Here is an example of this rule in action:

struct foo{
    template <typename T>
    void operator() (T t) { std::cout << t; }
};

template <>
void foo::operator()<double> (double) { 
    std::cout << "It's a double!"; 
}

Note the specialization for operator() for when T is double. If you run this code:

foo f;
f(0);
f(0.0);

Then 0 will be printed for the first call, and It's a double! for the second.

Live demo