在类定义之外的模板类成员函数主体中，何时需要模板参数？

Question

This code compiles (Visual Studio 2013). Note that I pass in Set , not Set<T> , as a parameter to operator=, in the function body which is outside the class definition. But I can't return Set or have it be a member of Set ; it must return Set<T> and be a member of Set<T> .

Where is it legitimate to leave out the template parameters? Inside the class definition , and where else?

Is this a change in the standard? I'm trying to maintain compatibility with all existing versions, including 98.

template <typename T>
class Set 
{
public:
    Set() {}         

    const Set& operator=(const Set& rhs); 
    //Shouldn't this have to be 
    //const Set<T>& operator= (const Set<T>& rhs); ?

};

template <typename T>
const Set<T>& Set<T>::operator= (const Set& rhs) //<-- HERE
{
    Set temp;                                    //<-- AND HERE
    /* ... */
    return *this;
}

int main()
{
    Set<int> S, T;
    T = S;
}

Answer 1

The class name is made available in the class scope. And in a separate member definition, once you've passed the C++03 return type specification and the function name, you're in class scope. Thus, this is OK in C++03:

template< class T >
Set<T> const& Set<T>::operator=( Set const& rhs ) 

And this is OK in C++11:

template< class T >
auto Set<T>::operator=( Set const& rhs) -> Set const&

---

This doesn't really have anything to do with templates, but it has to do with accessing a name that's available in class scope.

For example, in C++03 you'd have to write

struct S
{
    struct Inner {};
    Inner foo();
};

S::Inner S::foo() { return Inner(); }

while with C++11 and later you can write

struct S
{
    struct Inner {};
    auto foo() -> Inner;
};

auto S::foo() -> Inner { return {}; }

which is one good reason, among many others, to adopt the trailing return type syntax as a single syntax convention.

---

This is not OK in either C or C++, regardless of which year's standard:

void main() //! NOT VALID.