c++ - 运算符(operator)的 MSVC 错误 |

Question

我正在开发一个广泛使用 C++ 模板的库。在写作时，我遇到了这样的代码(当然是简化的):

#include <sstream>

namespace ns{
    template<class A, class B>
    class c{};

    class a{};

    template<class A>
    class b{
    public:
        template<class B>
        auto
        take(A, B){
            return c<A, B>{};
        }
    };

    template<class A>
    auto
    make_b(A){
        return b<A>{};
    }

    template<class A, class B>
    auto
    operator|(A _a, B _b){
        return _b.take(_a, _b);
    }

}

using namespace ns;

int main(){
    a{} | make_b(a{});
    return 0;
}

在使用 msvc 19 (Visual Studio 2017) 编译它时，出现以下错误类别:

/opt/compiler-explorer/windows/19.10.25017/lib/native/include/xlocale(314): warning C4530: C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc (28): error C2228: left of '.take' must have class/struct/union (28): note: type is ''

/opt/compiler-explorer/windows/19.10.25017/lib/native/include/xstring(2923): note: see reference to function template instantiation 'auto ns::operator |(A,B)' being compiled with [ A=unsigned int, B= ] /opt/compiler-explorer/windows/19.10.25017/lib/native/include/xstring(2922): note: while compiling class template member function 'void std::basic_string,std::allocator>::shrink_to_fit(void)'

/opt/compiler-explorer/windows/19.10.25017/lib/native/include/system_error(658): note: see reference to function template instantiation 'void std::basic_string,std::allocator>::shrink_to_fit(void)' being compiled

/opt/compiler-explorer/windows/19.10.25017/lib/native/include/stdexcept(22): note: see reference to class template instantiation 'std::basic_string,std::allocator>' being compiled

删除 using namespace 有效，但我不想禁止它(我为什么要禁止？)。有解决办法吗？

编辑:当然，我用 GCC 和 Clang 测试了代码——在 GCC 下从 4.9 和 clang3 编译，所以这完全是 MSVC 问题。

EDIT2:我查看了报告的错误，似乎 MSVC 在使用 using namespace 时扩展了其标准库中重载的 operator| 的范围。

Answer 1

它以这种方式工作，但我无法解释为什么它不能以原始方式工作，希望它能帮助其他人。

虽然我的猜测是您的模板太宽泛并且它被标准库中的一些代码实例化了。实际上，如果您只是注释掉任何 std header 或删除 using namespace ns，您的代码也可以工作。

namespace ns {
    template<class A, class B>
    class c {};

    class a {};

    template<class A>
    class b {
    public:
        using MyA = A;
        template<class B>
        auto
            take(A, B) {
            return c<A, B>{};
        }
    };

    template<class A>
    auto
        make_b(A) {
        return b<A>{};
    }

    template<class B>
    auto
        operator|(typename B::MyA _a, B _b) {
        return _b.take(_a, _b);
    }
}