带有嵌套模板类的模板类，g ++编译良好，vs2013不会编译

Question

I'm implementing my own map and this is a piece of the code. A part of the code that is troubling me is these two declarations:

template<typename KEY, typename VAL>
Map<KEY,VAL>::MapPair<KEY,VAL> Map<KEY,VAL>::make_map_pair(KEY k, VAL v){
    return MapPair<KEY,VAL>(k,v);
 }

template<typename KEY, typename VAL>
template<typename K, typename V>
Map<KEY,VAL>::MapPair<K,V>& Map<KEY,VAL>::MapPair<K,V>::setKey(K keyp, V val){
    key = keyp;
    value = val;
 }

The class def is as follows:

 template <typename KEY, typename VAL>
 class Map{
 private:
    template<typename K, typename V>
    class MapPair {
    public:
        K key;
        V value;
        MapPair(){};
        MapPair(K key, V value);
        MapPair<K,V>& setKey(K key, V val);
        V& getValue();
        K getKey();
        bool operator==(MapPair<K,V> item);
    };

    List<MapPair<KEY,VAL>> pair_list_;
    MapPair<KEY,VAL> make_empty_map_pair(KEY k);
    MapPair<KEY,VAL> make_map_pair(KEY k, VAL v);
 public:
    Map(){}
    bool exists(KEY key);
    VAL& operator[](KEY key);
    VAL pop_pair(KEY key);
 };

This code compiles without a peep from g++, but Visual Studio 2013 flips out errors:

error C2059: syntax error : ')'
error C2059: syntax error : ')'

each of the top function definitions generate an error.

From g++ under debain 7.5

g++ -Wall -c -std=c++11  vm.cpp
g++ vm.o -o vm

and it runs nicely with no run time issues and does what its supposed to do.

The question is why does g++ run this fine, and vs2013 wont compile it? What can I do to make this code compile properly on vs2013? What kind of habits can I develop to ensure portability in the code that I write?

Answer 1

So it turns out, VS2013 likes to have typename inserted before the return type of a nested class. I knew I 'could' do that but id never know why I would until this instance.

template<typename KEY, typename VAL>
typename Map<KEY,VAL>::MapPair<KEY,VAL> Map<KEY,VAL>::make_map_pair(KEY k, VAL v){
/*^^^^^ right here before the nested class object that it will return.*/
    return MapPair<KEY,VAL>(k,v);
}

Best idea is to use it so the code can ported with less changes, even though g++ wont require it.

Answer 2

My reading of the C++11 standard suggests that typename is required. VS2013 is doing the right thing.

Without the typename keyword, a dependent name is assumed not to name a type.

14.6 Name resolution [temp.res]

2) A name used in a template declaration or definition and that is dependent on a template-parameter is assumed not to name a type unless the applicable name lookup finds a type name or the name is qualified by the keyword typename.

3) When a qualified-id is intended to refer to a type that is not a member of the current instantiation and its nested-name-specifier refers to a dependent type, it shall be prefixed by the keyword typename

7) Within the definition of a class template or within the definition of a member of a class template following the declarator-id , the keyword typename is not required when referring to the name of a previously declared member of the class template that declares a type. [Note: such names can be found using unqualified name lookup, class member lookup into the current instantiation , or class member access expression lookup when the type of the object expression is the current instantiation

14.6.2.1 Dependent types [temp.dep.type]

A name refers to the current instantiation if it is

• in the definition of a primary class template or a member of a primary class template, the name of the class template followed by the template argument list of the primary template (as described below) enclosed in <>

When Map<KEY, VAL> is used in the definition of Map , it refers to the current instantiation . When parsing the definition of make_map_pair a type name qualified by Map<KEY, VAL>:: can in general be found by class member name lookup into the current instantiation .

However, when the C++ parser encounters Map<KEY, VAL> in the return-type of a member function definition - before the declarator-id - it has not yet encountered the name of the enclosing class. The parser cannot determine whether or not Map refers to the enclosing class at this point.

For this reason - regardless of whether or not Map<KEY, VAL> names the current instantiation - the standard does not permit omission of typename within the definition of a member of a class template before the declarator-id.

This example by Vaughn Cato demonstrates that the behaviour of Clang/GCC is inconsistent, and requires typename in a similar scenario:

template <typename T>
struct A {
    typedef int X;
    X f();
};

template <typename T>
A<T>::X A<T>::f() // error: missing 'typename'
{
}

If we conclude that the name Map is dependent and typename is required then the template keyword is also required:

14.2 Names of template specializations [temp.names]

When the name of a member template specialization appears after . or -> in a postfix-expression or after a nested-name-specifier in a qualified-id, and the object or pointer expression of the postfix-expression or the nested-name-specifier in the qualified-id depends on a template parameter (14.6.2) but does not refer to a member of the current instantiation (14.6.2.1), the member template name must be prefixed by the keyword template. Otherwise the name is assumed to name a non-template.

The corrected example would be:

template<typename KEY, typename VAL>
typename Map<KEY,VAL>::template MapPair<KEY,VAL>
    Map<KEY,VAL>::make_map_pair(KEY k, VAL v) {
    return MapPair<KEY,VAL>(k,v);
}

There was a discussion of the same issue here: Can typename be omitted in the type-specifier of an out of line member definition?