类模板的成员函数有条件地无效（隐式实例化有效；显式实例化失败）

Question

我创建了一个类模板。根据其模板参数，它支持不同的操作。类模板应（隐式）实例化为模板参数的多种组合。对于其中一些组合，可能存在没有意义（并且也无法编译）的成员函数。然而，只要我不强制执行显式实例化，一切似乎都会按预期工作。

现在，有一些可怕的案例被称为“未指定”、“未定义”、“格式错误；无需诊断”……。我绝对想避免这些事情。所以我寻求建议如何处理这种情况。

这是一个显示相同观察结果的示例。请注意，我对如何修复这个确切的玩具示例不太感兴趣。

#include <iostream>
#include <type_traits>

template<class T>
struct SingleSink {
  SingleSink(T) {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
  }
};

template<class T>
struct DoubleSink {
  DoubleSink(T, T) {
    std::cout << __PRETTY_FUNCTION__ << std::endl;
  }
};

template<class T, int arity /*, some other stuff */>
struct SuperSink {
// This class shall do something special depending on, say, `arity`.
// Instead of partially specializing the whole class template (and introducing
// code duplication for the remaining functionality), let us externalize the 
// `arity`-dependent behavior to a special member.

  using Sink = std::conditional_t<
    arity == 1,
    SingleSink<T>,
    DoubleSink<T>
  >;

  Sink sink_;

// [some more data members that do not depend on `arity`]

// for a fixed `Sink` one of the following constructors should fail to compile
  SuperSink(T i) : sink_{i} {}
  SuperSink(T i, T j) : sink_{i, j} {}
// ... so these are what I call "conditionally invalid member functions".
};

// explicit instantiation yields error (deactivated by comments):
// template struct SuperSink<int, 1>;
// template struct SuperSink<int, 2>;

int main() {
// implicit instantiation works
  SuperSink<int, 1>{5};
  SuperSink<int, 2>{5, 6};

// these yield a compile error (as desired)
// SuperSink<int, 1>{5, 6};
// SuperSink<int, 2>{5};
}

1. 如果我从不这样做，这些有条件无效的成员函数会是一个问题吗？ 需要显式实例化？
2. 如果是：检查显式实例化是否有效是好的做法吗？

Answer 1

如果我从不需要显式实例化，这些有条件无效的成员函数会成为问题吗？

甚至 STL 中的模板也有“无效”方法，例如：

std::vector<T>::resize(std::size_t)

具有非默认可构造

T

。

因此，使用“无效”方法，您的类可以正常使用。记录您的要求是一种选择。

但是，这些方法对 SFINAE 并不友好，因为错误不会出现在直接上下文中，而是出现在实例化中。

无效时您可以自行使用SFINAE删除它们，例如：

template <std::size_t N = arity, std::enable_if_t<N == 1, int> = 0>
SuperSink(T i) : sink_{i} {}

template <std::size_t N = arity, std::enable_if_t<N != 1, int> = 0>
SuperSink(T i, T j) : sink_{i, j} {}

在 C++20 中，您可以指定一些条件以在类中包含方法（类似于上面的 SFINAE，但具有更好的语法并且没有额外的模板）：

SuperSink(T i) requires (arity == 1) : sink_{i} {}

SuperSink(T i, T j) requires (arity != 1) : sink_{i, j} {}

Answer 2

我至少看到了这个问题，即设计破坏了如下所示的类型特征，因此当使用 SFINAE 来决定调用哪些构造函数时，您可能会遇到问题。

static_assert(!std::is_constructible<SuperSink<int, 1>, int, int>::value);

static_assert(!std::is_constructible<SuperSink<int, 2>, int>::value);

您可以通过反转设计来解决此问题：将

SingleSink

和

DoubleSink

定义为通用

SuperSink

的特殊情况（或者如果需要：专业化）。

#include <iostream>
#include <type_traits>

template<class T, int arity>
struct SuperSink {

 template<typename... Ts, typename = std::enable_if_t<sizeof...(Ts) == arity> >
  SuperSink(Ts... is) {
       std::cout << __PRETTY_FUNCTION__ << std::endl;
  }

};


template<typename T>
struct SingleSink : SuperSink<T, 1> {
    using Base = SuperSink<T, 1>;
    using Base::Base; // inherit constructor
    // implement special functionality here
};


template<typename T>
struct DoubleSink : SuperSink<T, 2> {
    // follow same pattern as in SingleSink.
}


int main() {
    // implicit instantiation works
    SuperSink<int, 1>{5};
    SuperSink<int, 2>{5, 6};

    // Now, these work as desired
    static_assert(!std::is_constructible<SuperSink<int, 1>, int, int>::value);

    static_assert(!std::is_constructible<SuperSink<int, 2>, int>::value);

    // these yield a compile error (as desired)
    //  SuperSink<int, 1>{5, 6};
    // SuperSink<int, 2>{5};
}