使用SFINAE禁用模板类成员函数

Question

假设我有一个接受某种类型T 。 这意味着它可以接受某些类型的optional<U> 。 如果它不是optional类型，我想禁用该功能，但是如果它是...，那么我想知道该类型U

我已经能够通过模板禁用该功能，但是我不知道如何在不两次编写同一个类并将一个模板模板版本化的情况下检测模板化模板类。

代码 ：

class Dummy{};

template <typename T>
class C {
    T t;

public:
    C(T t) : t(std::move(t)) { }

    T get() {
        return t;
    }

    // Will clearly fail when T doesn't have a value_type
    template <typename R = T, typename OptT = typename T::value_type, typename = std::enable_if_t<std::is_same_v<T, optional<OptT>>>>
    std::vector<OptT> stuff() {
        std::vector<OptT> vec;
        // Do stuff, fill vec
        return vec;
    }
};

int main() {
    C<Dummy> c{Dummy()};                // Error
    // C<optional<Dummy>> c{Dummy()};   // Works fine
    c.get();
}

通过这样做，我得到

main.cpp：在“ C类”的实例中：

main.cpp：33：14：从这里开始

main.cpp：25：23：错误：``类虚拟''中没有名为``value_type''的类型

  std::vector<OptT> stuff() { ^~~~~ 

注意 ：如果有此类的专业化，这是可以的，我所关心的就是检测其std::optional 。 我不需要它为任何其他类型工作……只是可选的。 这可能允许某种形式的模板专业化，但是在研究它时我没有弄清楚该如何做。

我怎样才能使此函数仅在类型为std::optional ，然后当它是该类型时，才能够在Optional内部获取类型？ 我可以不触碰T的模板定义吗？ （例如，我可以将其保留为template <typename T>而不将其更改为template <template <typename> T>或不必复制以上两者的类来做吗？）

Answer 1

我建议如下定义一个自定义类型特征

template <typename>
struct optionalType
 { };

template <typename T>
struct optionalType<std::optional<T>>
 { using type = T; };

当且仅当使用std::optional调用时定义type （ std::optional<T>的类型T ）。

现在，您的stuff()变成

template <typename R = T,
          typename OptT = typename optionalType<R>::type>
std::vector<OptT> stuff() {
    std::vector<OptT> vec;
    // Do stuff, fill vec
    return vec;
}

请OptT ，只有当R （aka T ）是std::optional时，才出现OptT ，即std::optional的类型。 您将发生替换失败，否则将禁用stuff() 。

您可以验证

C<Dummy>                c0{Dummy()};
C<std::optional<Dummy>> c1{Dummy()};

//c0.stuff(); // compilation error
c1.stuff();   // compile

Answer 2

您的问题在这里：

// Will clearly fail when T doesn't have a value_type
template <typename R = T,
          typename OptT = typename T::value_type,
          typename = std::enable_if_t<std::is_same_v<T, optional<OptT>>>>

是您引入了一个新的虚拟模板参数R ，但是您仍然使用旧的T来进行所有检查。 因此，所有检查实际上都不依赖。 将它们交换到R ，就可以了。

---

一种不同的方法是仅使用标记参数来遵循不同的功能：

template <typename> struct tag { };

template <typename R=T>
auto stuff() -> decltype(stuff_impl(tag<R>{})) {
    return stuff_impl(tag<R>{});
}

现在，您可以有效地使用常规模板推导来提取类型：

template <typename U>
std::vector<U> stuff_impl(tag<std::optional<U>>) {
    return {};
}