函数模板专业化失败：编码错误或 MSVC2013 错误？

Question

下面的代码可以使用 g++ 4.8.1 (mingw) 和 http://gcc.godbolt.org/ 上的各种最新 clang 和 gcc 版本正确编译，但是使用 MSVC2013 Update 4 它失败了，显然是由于 typedef typename A<T>::value_type value_type; 行。编译器给出以下错误：

x.cpp(30): error C2893: Failed to specialize function template 'void B<C,int>::bar(void)' With the following template arguments: 'MemberFn=void C::baz(int)'

更简单的 typedef typedef T value_type; 有效。

我是不是做错了什么？或者这是 Microsoft C++ 编译器中的已知错误？

补充问题：

从文体的角度来看，假设我有选择权，是在派生的 class（例如 typedef T value_type;）中重新定义类型还是从base class（例如 typedef typename A<T>::value_type value_type;，或 C++11 using typename A<T>::value_type;）？（注意：我现在正在考虑 C++03 兼容性，因此避免了 using。）这里有一些不确定的讨论：Use typedef/using from templated base class in derived class 我问的原因是如果 typedef T value_type; 反正是首选，我不用那么担心

#include <cstdio>

template <typename T>
struct A {
    typedef A<T> base_type;
    typedef T value_type;
};

template <typename Derived, typename T>
struct B : public A<T> {
    typedef Derived derived_type;
    //typedef T value_type; // this works
    typedef typename A<T>::value_type value_type; // this fails in MSVC 2013
    //using typename A<T>::value_type; // this fails in MSVC 2013 too

    template<void (derived_type::*MemberFn)(value_type) >
    void bar()
    {
        (static_cast<derived_type*>(this)->*MemberFn)(42);
    }
};

struct C : public B<C, int> {
    void baz(int i)
    {
        std::printf("baz(%d)\n", i);
    }

    void foo()
    {
        bar<&C::baz>();
    }
};

int main(int, char *[])
{
    C c;
    c.foo();
}

更新#1：这是一个框架的简化测试用例。我不是要求对结构进行一般性批评。我不希望这个结构在没有上下文的情况下有意义。

更新 #2： 这是一个相关问题，讨论 using 是否与 typename 结合有效：C++ template inheritance issue with base types

更新 #3： 我已经在 Microsoft Connect 上提交了一份 public 错误报告。如果您可以重现该问题，并认为这是一个错误，请为该错误点赞：https://connect.microsoft.com/VisualStudio/feedback/details/1740423

Answer 1

看起来不错。我用VS2015测试过，同样的错误信息。事实上，它应该在 B 中没有 typedef 的情况下工作，因为它从 A 继承了 'value_type'，所以它也在命名空间中 if struct B.

Answer 2

我有一个可能的解决方案（我只能用 VS2015 测试这个）

如果您使用基类型本身作为模板参数，它会被解析并且您可以访问 value_type.

template <typename T>
struct A {
    typedef T value_type;
    typedef A<T> base_type;
};

template <typename Derived, typename T, typename Base = A<T>>
struct B : public Base
{
    typedef Derived derived_type;
    typedef void (derived_type::*member_func_type)(typename Base::value_type);

    template<member_func_type MemberFn>
    void bar()
    {
        (static_cast<derived_type*>(this)->*MemberFn)(42);
    }
};


struct C : public B<C, int> 
{
    void baz(int i)
    {
        std::printf("baz(%d)\n", i);
    }

    void foo()
    {
        bar<&C::baz>();
    }
};

或者我更喜欢的解决方案：

template <typename T>
struct A {
    typedef A<T>    base_type;
    typedef T       value_type;
};

template <typename Derived, typename T, typename Base = A<T>>
struct B : public Base
{
    typedef Derived                     derived_type;
    typedef typename Base::base_type    base_type;
    typedef typename Base::value_type   value_type;

    typedef void (derived_type::*member_func_type)(value_type);

    template<member_func_type MemberFn>
    void bar()
    {
        (static_cast<derived_type*>(this)->*MemberFn)(42);
    }
};

我必须承认这个解决方案有它的缺陷，比如用其他东西覆盖第三个模板参数的能力。至少另一个基 class 需要声明 base_type 和 value_type。

编辑： 使用 static_assert 可以防止更改 Base 模板参数。

template <typename Derived, typename T, typename Base = A<T> >
struct B : public Base
{
    static_assert(std::is_same<Base, typename A<T>>::value, "Redefinition of template parameter Base is not allowed");

    typedef Derived                     derived_type;
    typedef typename Base::base_type    base_type;
    typedef typename Base::value_type   value_type;

    typedef void (derived_type::*member_func_type)(value_type);

    template<member_func_type MemberFn>
    void bar()
    {
        (static_cast<derived_type*>(this)->*MemberFn)(42);
    }
};

示例：

template <typename T>
struct D {
    typedef D<T>    base_type;
    typedef T       value_type;
};

struct E : public B<C, int, D<int>>
{
};

结果：

error C2338: Redefinition of template parameter Base is not allowed

更新：

更改 B 的模板参数的顺序会改变行为。这里原来的代码只有 T 和 Derived 的顺序改变了。

#include <cstdio>

template <typename T>
struct A {
    typedef A<T> base_type;
    typedef T value_type;
};

template <typename T, typename Derived>
struct B : public A<T> {
    typedef Derived derived_type;
    //typedef T value_type; // this works
    typedef typename A<T>::value_type value_type; // this fails in MSVC 2013
                                                  //using typename A<T>::value_type; // this fails in MSVC 2013 too

    template<void (derived_type::*MemberFn)(value_type) >
    void bar()
    {
        (static_cast<derived_type*>(this)->*MemberFn)(42);
    }
};

struct C : public B<int, C> {
    void baz(int i)
    {
        std::printf("baz(%d)\n", i);
    }

    void foo()
    {
        bar<&C::baz>();
    }
};


int main(int, char *[])
{
    C c;
    c.foo();
}

这可以编译并且工作正常。

我仍然不能完全确定这是一个错误。

更新

所以这似乎是 MSVC 中缺少的功能。 MSVC（到 2015/14.0）似乎不支持 "Two-phased-name-lookup".

Darran Rowe: VC hasn't implemented three C++98/03 features: two-phase name lookup, dynamic exception specifications, and export. Two-phase name lookup remains unimplemented in 2015, but it's on the compiler team's list of things to do, pending codebase modernization. Dynamic exception specifications also remain unimplemented (VC gives non-Standard semantics to throw() and ignores other forms), but they were deprecated in C++11 and nobody cares about them now that we have noexcept. It's unlikely that we'll ever implement them, and there's even been talk of removing them from C++17. Finally, export was removed in C++11.

来源C++11/14/17 Features In VS 2015 RTM

在 2012 年有一个请求该功能的错误，但它在没有评论的情况下被关闭：support two-phase name lookup - by Ivan Sorokin

所以看起来你在这里做的一切，但 MSVC 只是不支持 C++ 标准的这一部分。

函数模板专业化失败：编码错误或 MSVC2013 错误？

Function template specialization failure: coding error or MSVC2013 bug?

c++

templates

visual-c++