Syntax for Templated Member Functions

Consider the following code:

template <typename Datatype>
class MyClass
{
    void doStuff();

    template <typename AnotherDatatype>
    void doTemplateStuff(AnotherDatatype Argument);
};

template <typename Datatype>
void MyClass<Datatype>::doStuff()
{
    // ...
}

template <typename Datatype>
template <typename AnotherDatatype>
void MyClass<Datatype>::doTemplateStuff(AnotherDatatype Argument)
{
    // ...
}

The implementation for the second member function, doTemplateStuff, will not compile if I condense it like this:

template <typename Datatype, typename AnotherDatatype>
void MyClass<Datatype>::doTemplateStuff(AnotherDatatype Argument)
{
    // ...
}

Why is this? Shouldn't separating template information by commas have the same effect as putting each typename on its own line? Or is there some subtle difference I'm not aware of...?

(Also, if someone 开发者_如何转开发can think of a better title please let me know.)

---

This is an excellent question. I don't know the specific reason that the standards committee decided to design templates this way, but I think it's a callback to lambda calculus and type theory. Mathematically speaking, there is an isomorphism between any function that takes two arguments and returns a value and a function that takes in a single argument, then returns a function that takes in yet another argument and then returns a value. For example:

λx. λy. x + y

is isomorphic with (but not identical to)

λ(x, y). x + y

where (x, y) is a single object representing the pair of x and y.

With C++ member function templates, C++ chose to use the first of these systems. You have to specify all the arguments for the outermost function, then, separately, all of the arguments for the innermost function. Mathematically this is equivalent to specifying all of the arguments at the same time in one argument list, but C++ didn't choose to do this.

Now, a really good question is why they didn't do this. I'm not fully sure of the rationale, but if I had to guess it's because of weird interactions with template specialization. If I can think of something specific I'll update this post.

---

Putting comma's between the template declaration tells the compiler to expect two template parameters. In your case, because the object is a template object when you declare the function as you do you're violating your own declaration. It's looking for that second template in the MyClass object, referencing the actual class declaration and realizing that it's an error.

Hence,

template<typename T, typename V>
struct Foo{
    void bar();
};

template<typename T, typename V>
void Foo<T,V>::bar(){...}

is what it's expecting to see.

template<typename T>
struct Foo{
    void bar();
}

template<typename T, typename V>
void Foo<T>::bar(){...}

is an error. It's wondering where that other template parameter came from.

If you want to do this you'll need to write the function right there:

template<typename T>
struct Foo{
    template<typename V>
    void bar(const V& _anInputValue){
        cout << _anInputValue;
    }

    void baz();
};

template<typename T>
void Foo<T>::baz(){
    cout << "Another function.";
}