c++ - 模板类内部模板类的外部类运算符

Question

我正在尝试为模板类内部的模板类编写外部类模板运算符。

我希望下面的片段能解释我的意思。

enum MyEnum {};

template <MyEnum a>
class ClassWithTemplateClass {
 public:
    template <bool B> 
    class TemplateClass {
        // ...
    };
};

当我这样写运算符时:

template <MyEnum enumVal, bool B>
auto operator<<(ClassWithTemplateClass<enumVal>::TemplateClass<B> &a, int b) {
    // ...
    return a;
}

编译器返回错误:

错误:将“operator<<”声明为非函数

你能告诉我这个运算符应该怎么写吗？

Answer 1

ClassWithTemplateClass<enumVal>::是 nested name specifier这又是一个 non-deduced context .自 enumVal是出现在范围解析运算符 :: 左侧的模板参数，编译器无法推断出它的值。

<<运算符可以定义为 (1) 类中的 friend TemplateClass :

enum MyEnum { X, Y, Z };

template <MyEnum E>
struct ClassWithTemplateClass
{
    template <bool B> 
    struct TemplateClass
    {
        friend auto& operator<<(TemplateClass& a, int b)
        {
            return a;
        }
    };
};

哪里TemplateClass始终引用 ClassWithTemplateClass<?>::TemplateClass<?> 的特定实例

DEMO

或 (2) 里面ClassWithTemplateClass :

enum MyEnum { X, Y, Z };

template <MyEnum E>
struct ClassWithTemplateClass
{
    template <bool B> 
    struct TemplateClass
    {
    };

    template <bool B>
    friend auto& operator<<(TemplateClass<B>& a, int b)
    {
        return a;
    }
};

DEMO 2

或者，(3) 您可以为每个预定义的枚举值提供一个单独的运算符定义(尽管它可以有比定义为常量更多的值)，这样只有 B需要推导:

enum MyEnum { X, Y, Z };

template <MyEnum E>
struct ClassWithTemplateClass
{
    template <bool B> 
    struct TemplateClass
    {        
    };
};

template <bool B>
auto& operator<<(ClassWithTemplateClass<X>::TemplateClass<B>& a, int b)
{
    return a;
}

template <bool B>
auto& operator<<(ClassWithTemplateClass<Y>::TemplateClass<B>& a, int b)
{
    return a;
}

template <bool B>
auto& operator<<(ClassWithTemplateClass<Z>::TemplateClass<B>& a, int b)
{
    return a;
}

DEMO 3

，或 (4) 将模板参数存储为 TemplateClass 的静态数据成员，并使用它们来使运算符 SFINAE 可用并检索它们的值:

enum MyEnum { X, Y, Z };

template <MyEnum E>
struct ClassWithTemplateClass
{
    template <bool B> 
    struct TemplateClass
    {
        static constexpr MyEnum ClassWithTemplateClass_E = E;
        static constexpr bool TemplateClass_B = B;
    };
};

template <typename T
        , MyEnum E = T::ClassWithTemplateClass_E
        , bool B = T::TemplateClass_B>
auto& operator<<(T& a, int b)
{
    return a;
}

DEMO 4

作为另一种选择，(5) 您可以从 operator<< 发送调用到另一个函数，并显式指定其模板参数，以便签名完全符合您的要求，并且模板参数是已知的:

enum MyEnum { X, Y, Z };

template <MyEnum E>
struct ClassWithTemplateClass;

template <MyEnum E, bool B>
auto& print(typename ClassWithTemplateClass<E>::template TemplateClass<B>& a, int b);

template <MyEnum E>
struct ClassWithTemplateClass
{
    template <bool B> 
    struct TemplateClass
    {
        friend auto& operator<<(TemplateClass& a, int b)
        {
            return print<E, B>(a, b);
        }
    };
};

template <MyEnum E, bool B>
auto& print(typename ClassWithTemplateClass<E>::template TemplateClass<B>& a, int b)
{
    return a;
}

DEMO 5