如何为模板类中定义的类定义朋友

Question

假设我有以下定义嵌套类的模板类：

template <typename T>
struct foo {
    struct bar { };
};

假设我正在编码的环境也有以下帮助类，它应该专门用于需要特殊处理的任何类型：

template <typename T>
struct maybeChangeType { using type = T; }  /* default: same type */

如何将maybeChangeType 专门用于foo<T>::bar？专门针对 foo<int>::bar 很容易，但 foo 将与 100 多个不同的 T 一起使用，所以这不是一个真正的选择。

注意：在将此问题标记为重复问题之前，请仔细阅读。这个问题不是询问如何在一般情况下进行专业化（例如Understanding templates in c++），或者如何声明朋友，甚至如何声明模板的朋友。它询问如何为模板类的非模板嵌套成员声明朋友（如标题所述）。

试图以“正常”的方式定义特化是行不通的，因为foo<T>::bar 不是可演绎的上下文（坏信号：它需要在前面加上typename）：

/* error: template parameters not deducible in partial specialization */
template <typename T>
struct maybeChangeType<typename foo<T>::bar>;

将特化声明为友元也会产生编译错误：

template <typename T>
struct foo {
    struct bar {
        /* errors:
         * - class specialization must appear at namespace scope
         * - class definition may not be declared a friend
         */
        template <>
        friend struct maybeChangeType<bar> { using type=T; };
    };
};

上面的错误说明这些朋友的实际定义一定是脱节的：

template <typename T>
struct foo {
    struct bar {
        friend struct maybeChangeType<bar>;
    };
};

但现在我们又回到了开始的地方：任何为 foo<T>::bar 定义特化的尝试都会失败，因为它在不可推导的上下文中使用了 bar。

注意：我可以通过提供友元重载内联来解决函数问题，但这对类没有帮助。

注意：我可以通过将内部类移出命名空间范围来解决此问题，但这会严重污染命名空间（许多内部类用户实际上没有任何业务可玩）并使实现复杂化（例如，他们会不再可以访问其封闭类的私有成员，friend 声明的数量将激增）。

注意：我理解为什么允许任意特化名称 foo<T>::bar 会很危险/不受欢迎（例如，如果 foo<T> 有 using bar = T 会怎样），但在这种情况下 bar 确实是一个类（甚至不是模板！） foo 确实定义了，因此不应该有任何 ODR 毛茸茸或专业化会影响其他（意外）类型的风险。

想法？

Answer 1

作为一种侵入式解决方案，可以使用函数进行类型编程（元编程）。您可以将类型函数编写为友元函数：

template<typename T> struct type_t { using type = T; };

template <typename T>
struct foo {
    struct bar {
        friend constexpr auto maybeChangeType_adl(type_t<bar>) -> type_t<T>
        { return {}; }
    };
};

将type_t<T> 替换为任何type_t<my_type_function_result>。没有必要，但有时很方便，定义这个函数，例如用于常量表达式中的计算。 type_t 可以通过比较运算符来增强，例如用中缀 a == b 替换 std::is_same<A, B>。直接使用 type_t<T> 类型而不是 T 有两个原因：

1. 对于maybeChangeType_adl 的定义，需要 构造一个返回类型的对象。
2. 并非所有类型都可以从函数返回。例如。抽象类型、函数类型、数组类型。那些仍然可以用作 模板参数。

---

在 C++14 中，我会使用变量模板来实现这个功能：

template<typename T> constexpr auto type = type_t<T>{};

// ...

friend constexpr auto maybeChangeType_adl(type_t<bar>) { return type<T>; };

虽然这失去了一些对称性（参数与返回类型）。

---

在任何情况下，您都可以按如下方式查询类型：

template<typename T> using inner_type = typename T::type;

template<typename T> using maybeChangeType =
    inner_type<decltype(maybeChangeType_adl(type_t<T>{}))>;

可以提供一个备用函数maybeChangeType 来镜像 OP 中的主模板：

template<typename T> auto maybeChangeType(type_t<T>) -> type_t<T> { return {}; }

或者，您将 maybeChangeType 类模板专门用于 maybeChangeType_adl 函数的存在：

template<typename T, typename = void>
struct maybeChangeType { using type = T; };

template<typename T>
struct maybeChangeType<T, void_t<decltype(maybeChangeType_adl(type_t<T>{}))>>
{ using type = inner_type<decltype(maybeChangeType_adl(type_t<T>{}))>; };

Answer 2

如果可以在bar 中导出模板参数T，如果可以在maybeChangeType 中添加另一个（默认）模板参数，可以试试这个：

#include <type_traits>

template <typename T>
struct foo {
    struct bar {
      using type = T;
    };
};

template <typename T, typename = void>
struct maybeChangeType { using type = T; };  /* default: same type */

template <typename T>
struct maybeChangeType<T,
    typename std::enable_if<std::is_same<T,
                                         typename foo<typename T::type>::bar
                                         >::value
                            >::type>
{ using type = T; };

int main() {}

Answer 3

受到@ex-bart 和@dyp 答案的启发，我想出了以下C++11 解决方案：

struct Helper {
    template <typename T>
    static typename T::other_type getType(T);

    template <typename T, typename... Ignored>
    static T getType(T, Ignored...);
};

template <typename T>
struct maybeChangeType {
    using type = decltype(Helper::getType(std::declval<T>()));
};

struct foo { };
struct bar { using other_type = int; }

int main() {
    maybeChangeType<foo>::type f = foo();
    maybeChangeType<bar>::type b = int();
}

它的优点是不会将最终用户或类实现暴露给黑魔法——用户只需使用maybeChangeType，类可以通过简单地提供 typedef other_type 来专门化它。